~ubuntu-branches/ubuntu/saucy/clamav/saucy

dnl
dnl   Copyright (C) 2002 - 2006 Tomasz Kojm <tkojm@clamav.net>
dnl   gethostbyname_r and readdir_r checks (c) COPYRIGHT MIT 1995
dnl   socklen_t check (c) Alexander V. Lukyanov <lav@yars.free.net>
dnl
dnl   This program is free software; you can redistribute it and/or modify
dnl   it under the terms of the GNU General Public License as published by
dnl   the Free Software Foundation; either version 2 of the License, or
dnl   (at your option) any later version.
dnl
dnl   This program is distributed in the hope that it will be useful,
dnl   but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
dnl   GNU General Public License for more details.
dnl
dnl   You should have received a copy of the GNU General Public License
dnl   along with this program; if not, write to the Free Software
dnl   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
dnl   MA 02110-1301, USA.

AC_INIT(clamscan/clamscan.c)
AC_CREATE_TARGET_H(target.h)
AM_INIT_AUTOMAKE(clamav, "0.92")
AM_CONFIG_HEADER(clamav-config.h)

LC_CURRENT=3
LC_REVISION=3
LC_AGE=0
LIBCLAMAV_VERSION="$LC_CURRENT":"$LC_REVISION":"$LC_AGE"
AC_SUBST(LIBCLAMAV_VERSION)

AC_PROG_AWK
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_PROG_LIBTOOL

AC_DEFINE(SCANBUFF, 131072, [scan buffer size])
AC_DEFINE(FILEBUFF, 8192,   [file i/o buffer size])

AC_HEADER_STDC

AC_ARG_ENABLE(gcc-vcheck,
[  --disable-gcc-vcheck	  do not check for buggy gcc version ],
gcc_check=$enableval, gcc_check="yes")

msg_gcc_check="use --disable-gcc-vcheck to disable this check. Before reporting any bugs check with a supported version of gcc"

dnl Check for gcc-4.1.0
if test "$gcc_check" = "yes"; then
	if test "x$ac_compiler_gnu" = "xyes"; then
		AC_MSG_CHECKING([for a supported version of gcc])
		gcc_version=`${CC} -dumpversion`
		case "${gcc_version}" in
			4.1.0*)
				AC_MSG_RESULT([no (${gcc_version})])
				AC_MSG_ERROR([gcc 4.1.0 is known to incorrectly compile upx.c. Upgrade your compiler to at least 4.1.1/4.1.2)])
				;;
			*)
				AC_MSG_RESULT([ok (${gcc_version})])
				;;
	esac
	fi
fi

dnl Checks if compiler produces valid code, regardless of compiler
dnl we do these checks here to avoid receiving endless bugreports about
dnl breakages due to compiler bugs.

dnl Check if compiler produces invalid code on gcc PR27603 (affects upx.c)
dnl testcase from gcc testsuite
AC_MSG_CHECKING([for gcc bug PR27603])
AC_TRY_RUN(
	   [
/* (C) Richard Guenther */	   
void exit (int);
void abort (void);
int a;
int main()
{
  int j;
  for (j = 0; j < 6; j++)
  {
    if ((unsigned)j - 3 <= 1)
      exit (0);
    a = 1000 * (6 - j);
  }
  abort ();
}
], [AC_MSG_RESULT([ok, bug not present])],
[AC_MSG_ERROR([your compiler has gcc PR27603 bug, use a different compiler, see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=27603])])

dnl Check if compiler produces invalid code on gcc PR28045 (affects upx.c)
dnl testcase from gcc testsuite
AC_MSG_CHECKING([for gcc bug PR28045])
AC_TRY_RUN(
	   [
/* (C) Andrew Pinski */	   
extern void abort(void);
struct a
{
   unsigned int bits : 1;
   signed long val : ((sizeof(long) * 8) - 1);
};
int Fnegate (struct a b)
{
  if ((-((long)b.val)) <= ((long) ((1UL << ((sizeof(long) * 8) - 2)) -1UL))
      && (-((long)b.val)) >= (-(((long) ((1UL << ((sizeof(long) * 8) - 2)) -1UL))) - 1))
     return 0 ;
  abort ();
}
int main ()
{
  struct a b = {1, 1};
  Fnegate (b);
  return 0;
}
], [AC_MSG_RESULT([ok, bug not present])],
[AC_MSG_ERROR([your compiler has gcc PR28045 bug, use a different compiler, see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=28045])])

dnl Check if compiler produces invalid code on gcc PR26763-2 (affects upx.c)
dnl testcase from gcc testsuite
AC_MSG_CHECKING([for gcc bug PR26763-2])
AC_TRY_RUN(
	   [
/* (C) Richard Guenther */	   
extern void abort(void);

int try (char *a, int d)
{
  return a + d > a;
}

int main(void)
{
  char bla[100];

  if (try (bla + 50, -1))
    abort ();

  return 0;
}
], [AC_MSG_RESULT([ok, bug not present])],
[AC_MSG_ERROR([your compiler has gcc PR26763-2 bug, use a different compiler, see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=26763])])

dnl Check if compiler produces invalid code on own testcase based on upx.c
AC_MSG_CHECKING([for valid code generation of CLI_ISCONTAINED])
AC_TRY_RUN(
	   [	   
#include <stdio.h>
static struct v{
	char* dst;
	unsigned long dsize;
	unsigned long dcur;
	unsigned long backsize;
 	signed long unp_offset;
} values[] = {
	{(char*)0xf78ab008, 0x2e000, 1, 4, 0xfffff9f3},
	{(char*)0xb7af1008, 0x2e000, 1, 4, 0xfffff9f3}

};
extern void abort(void);

#define CLI_ISCONTAINED(bb, bb_size, sb, sb_size)	\
    (bb_size > 0 && sb_size > 0 && sb_size <= bb_size	\
     && sb >= bb && sb + sb_size <= bb + bb_size && sb + sb_size > bb)

int main()
{
	int i;
	for(i=0;i<sizeof(values)/sizeof(values[0]);i++) {
		struct v* v= &values[i];
		char* dst = v->dst;
		unsigned long* dsize = &v->dsize;
		unsigned long dcur = v->dcur;
		unsigned long backsize = v->backsize-1;
		signed long  unp_offset = v->unp_offset;

		if(!CLI_ISCONTAINED(dst, *dsize, dst+dcur+unp_offset, backsize) ||
				!CLI_ISCONTAINED(dst, *dsize,dst+dcur,backsize) || unp_offset >= 0)  {
			continue;
		}
		abort();
	}
	return 0;
}
], [AC_MSG_RESULT([ok, bug not present])],
[AC_MSG_ERROR([your compiler has a bug that causes clamav 670, use a different compiler, see http://bugs.clamav.net/bugzilla/show_bug.cgi?id=670])])

AC_CHECK_HEADERS(stdint.h unistd.h sys/int_types.h dlfcn.h inttypes.h sys/inttypes.h memory.h ndir.h stdlib.h strings.h string.h sys/mman.h sys/param.h sys/stat.h sys/types.h malloc.h poll.h limits.h sys/filio.h sys/uio.h termios.h iconv.h stdbool.h pwd.h grp.h)
AC_CHECK_HEADER(syslog.h,AC_DEFINE(USE_SYSLOG,1,[use syslog]),)

AC_TYPE_OFF_T
AC_COMPILE_CHECK_SIZEOF(short)
AC_COMPILE_CHECK_SIZEOF(int)
AC_COMPILE_CHECK_SIZEOF(long)
AC_COMPILE_CHECK_SIZEOF(long long)

AC_ARG_ENABLE(experimental,
[  --enable-experimental	enable experimental code],
enable_experimental=$enableval, enable_experimental="no")

if test "$enable_experimental" = "yes"; then
  AC_DEFINE(CL_EXPERIMENTAL,1,[enable experimental code])
fi

AC_CHECK_LIB(socket, bind, [LIBS="$LIBS -lsocket"; CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lsocket"; FRESHCLAM_LIBS="$FRESHCLAM_LIBS -lsocket"; CLAMD_LIBS="$CLAMD_LIBS -lsocket"])
AC_CHECK_LIB(nsl, gethostent, [LIBS="$LIBS -lnsl"; CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lnsl"; FRESHCLAM_LIBS="$FRESHCLAM_LIBS -lnsl"; CLAMD_LIBS="$CLAMD_LIBS -lnsl"])

AC_CHECK_LIB(iconv, libiconv_open, LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -liconv")

AC_CHECK_FUNCS(poll setsid memcpy snprintf vsnprintf strerror_r strlcpy strlcat inet_ntop setgroups initgroups ctime_r mkstemp)
AC_FUNC_MMAP
AC_FUNC_FSEEKO

dnl Check for broken snprintf (code by Phil Oleson <oz*nixil.net>)
if test "x$ac_cv_func_snprintf" = "xyes" ; then
        AC_MSG_CHECKING([whether snprintf correctly terminates long strings])
        AC_TRY_RUN(
                [
#include <stdio.h>
int main(void){char b[5];snprintf(b,5,"123456789");return(b[4]!='\0');}
                ],
                [AC_MSG_RESULT(yes)],
                [
                        AC_MSG_RESULT(no)
                        AC_DEFINE(BROKEN_SNPRINTF,1,[Define if your snprintf is busted])
                        AC_MSG_WARN([****** Your snprintf() function is broken, complain to your vendor])
                ]
        )
fi

have_pthreads=no
AC_CHECK_HEADER(pthread.h,[have_pthreads=yes],)

AM_MAINTAINER_MODE
dnl Check for zlib
AC_MSG_CHECKING(for zlib installation)
AC_ARG_WITH(zlib,
[  --with-zlib=DIR	  path to directory containing zlib library (default=
			  /usr/local or /usr if not found in /usr/local)],
[
if test "$withval"; then
  ZLIB_HOME="$withval"
  AC_MSG_RESULT(using $ZLIB_HOME)
fi
], [
ZLIB_HOME=/usr/local
if test ! -f "$ZLIB_HOME/include/zlib.h"
then
  ZLIB_HOME=/usr
fi
AC_MSG_RESULT($ZLIB_HOME)
])

AC_ARG_ENABLE(zlib-vcheck,
[  --disable-zlib-vcheck	  do not check for buggy zlib version ],
zlib_check=$enableval, zlib_check="yes")

if test ! -f "$ZLIB_HOME/include/zlib.h"
then
    AC_MSG_ERROR(Please install zlib and zlib-devel packages)
else

    vuln=`grep "ZLIB_VERSION \"1.2.0" $ZLIB_HOME/include/zlib.h`
    if test -z "$vuln"; then
	vuln=`grep "ZLIB_VERSION \"1.2.1" $ZLIB_HOME/include/zlib.h`
    fi

    if test -n "$vuln"; then
	if test "$zlib_check" = "yes"; then
	    AC_MSG_ERROR(The installed zlib version may contain a security bug. Please upgrade to 1.2.2 or later: http://www.zlib.net. You can omit this check with --disable-zlib-vcheck but DO NOT REPORT any stability issues then!)
	else
	    AC_MSG_WARN([****** This ClamAV installation may be linked against])
	    AC_MSG_WARN([****** a broken zlib version. Please DO NOT report any])
	    AC_MSG_WARN([****** stability problems to the ClamAV developers!])
	fi
    fi

    if test "$ZLIB_HOME" != "/usr"; then
	CPPFLAGS="$CPPFLAGS -I$ZLIB_HOME/include"
	save_LDFLAGS="$LDFLAGS"
	LDFLAGS="$LIBS -L$ZLIB_HOME/lib"
	AC_CHECK_LIB(z, inflateEnd, [LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -L$ZLIB_HOME/lib -lz"; AC_DEFINE(HAVE_ZLIB_H,1,zlib installed)], AC_MSG_ERROR(Please install zlib and zlib-devel packages))
	LDFLAGS="$save_LDFLAGS"
    else
	AC_CHECK_LIB(z, inflateEnd, [LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -lz"; AC_DEFINE(HAVE_ZLIB_H,1,zlib installed)], AC_MSG_ERROR(Please install zlib and zlib-devel packages))
    fi
fi

AC_ARG_ENABLE(bzip2,
[  --disable-bzip2	  disable bzip2 support],
want_bzip2=$enableval, want_bzip2="yes")

if test "$want_bzip2" = "yes"
then
    AC_CHECK_LIB(bz2, bzReadOpen, AC_DEFINE(NOBZ2PREFIX,1,bzip funtions do not have bz2 prefix),)
    AC_CHECK_HEADER(bzlib.h,[LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -lbz2"; AC_DEFINE(HAVE_BZLIB_H,1,have bzip2)], AC_MSG_WARN([****** bzip2 support disabled]))
fi

AC_ARG_ENABLE(unrar,
[  --disable-unrar	  don't build libclamunrar and libclamunrar_iface ],
want_unrar=$enableval, want_unrar="yes")

AC_ARG_ENABLE(dns,
    AC_HELP_STRING([--disable-dns], [disable support for database verification through DNS]),
    [want_dns=$enableval], [want_dns=yes]
)
if test $want_dns = yes; then
    AC_CHECK_LIB(resolv, __dn_expand, resolv_lib="-lresolv",)
    if test -z "$resolv_lib"; then
	AC_CHECK_LIB(resolv, dn_expand, resolv_lib="-lresolv",)
    fi
    AC_CHECK_HEADER(resolv.h,[FRESHCLAM_LIBS="$FRESHCLAM_LIBS $resolv_lib"; CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS $resolv_lib"; AC_DEFINE(HAVE_RESOLV_H,1,have resolv.h)], AC_MSG_WARN([****** DNS support disabled]), [
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
])
fi

AC_ARG_ENABLE(clamuko,
[  --disable-clamuko	  disable clamuko support (Linux, DragonFly and FreeBSD only)],
want_clamuko=$enableval, want_clamuko="yes")

AC_FUNC_SETPGRP

AC_ARG_ENABLE(milter,
[  --enable-milter	  build clamav-milter],
have_milter=$enableval, have_milter="no")

if test "$have_milter" = "yes"; then
  sendmailprog=no
  AC_ARG_WITH(sendmail,
  [  --with-sendmail=PATH    specify location of Sendmail binary (default=auto find)],
  sendmailprog=$with_sendmail, sendmailprog=no)

  if test "$sendmailprog" = "no" ; then
    AC_PATH_PROG(sendmailprog, sendmail, no, $PATH:/sbin:/usr/sbin:/usr/lib:/usr/libexec)
  fi

  AC_DEFINE_UNQUOTED(SENDMAIL_BIN, "$sendmailprog", [location of Sendmail binary])

  sendmailver=`$sendmailprog -d0 < /dev/null | head -1 | awk '{print $2}'`

  if test -n "$sendmailver"; then
    sendmailver_a=`echo $sendmailver | awk -F. '{printf $1}'`
    sendmailver_b=`echo $sendmailver | awk -F. '{printf $2}'`
    sendmailver_c=`echo $sendmailver | awk -F. '{printf $3}'`

    AC_DEFINE_UNQUOTED(SENDMAIL_VERSION_A, $sendmailver_a, [major version of Sendmail])
    AC_DEFINE_UNQUOTED(SENDMAIL_VERSION_B, $sendmailver_b, [minor version of Sendmail])
    AC_DEFINE_UNQUOTED(SENDMAIL_VERSION_C, $sendmailver_c, [subversion of Sendmail])
  fi
fi

AC_ARG_ENABLE(dsig,
[  --disable-dsig	  disable support for digital signatures],
want_dsig=$enableval, want_dsig="yes")

if test "$want_dsig" = "yes"
then
    AC_CHECK_LIB(gmp, __gmpz_init, [LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -lgmp"; AC_DEFINE(HAVE_GMP,1,have gmp installed)], [AC_CHECK_LIB(gmp, mpz_init, [LIBCLAMAV_LIBS="$LIBCLAMAV_LIBS -lgmp"; AC_DEFINE(HAVE_GMP,1,have gmp installed)], AC_MSG_WARN([****** GNU MP 2 or newer NOT FOUND - digital signature support will be disabled !]); want_dsig="no")])
fi

AC_ARG_ENABLE(pthreads,
[  --disable-pthreads      disable POSIX threads support],
have_pthreads=$enableval,)

AC_ARG_ENABLE(cr,
[  --disable-cr		  don't link with C reentrant library (BSD) ],
use_cr=$enableval,)

AC_ARG_ENABLE(id-check,
[  --enable-id-check	  use id utility instead of /etc/passwd parsing],
use_id=$enableval, use_id="no")

AC_ARG_ENABLE(yp-check,
[  --enable-yp-check	  use ypmatch utility instead of /etc/passwd parsing],
use_yp=$enableval, use_yp="no")

AC_ARG_WITH(user, 
[  --with-user=uid	  name of the clamav user (default=clamav)],
clamav_user="$withval", clamav_user="clamav")

AC_ARG_WITH(group, 
[  --with-group=gid	  name of the clamav group (default=clamav)],
clamav_group="$withval", clamav_group="clamav")

AC_DEFINE_UNQUOTED(CLAMAVUSER,"$clamav_user",[name of the clamav user])
AC_DEFINE_UNQUOTED(CLAMAVGROUP,"$clamav_group",[name of the clamav group])

AC_ARG_ENABLE(clamav,
[  --disable-clamav	  disable test for clamav user/group],
test_clamav=$enableval, test_clamav=yes)

AC_ARG_ENABLE(debug,
[  --enable-debug	  enable debug code],
enable_debug=$enableval, enable_debug="no")

if test "$enable_debug" = "yes"; then
  AC_DEFINE(CL_DEBUG,1,[enable debugging])
fi

AC_ARG_ENABLE(no-cache,
[  --enable-no-cache	  use "Cache-Control: no-cache" in freshclam],
enable_nocache=$enableval, enable_nocache="no")

if test "$enable_nocache" = "yes"; then
  AC_DEFINE(FRESHCLAM_NO_CACHE,1,[use "Cache-Control: no-cache" in freshclam])
fi

AC_ARG_ENABLE(dns-fix,
[  --enable-dns-fix	  enable workaround for broken DNS servers (as in SpeedTouch 510)],
enable_dnsfix=$enableval, enable_dnsfix="no")

if test "$enable_dnsfix" = "yes"; then
  AC_DEFINE(FRESHCLAM_DNS_FIX,1,[enable workaround for broken DNS servers])
fi

AC_ARG_ENABLE(bigstack,
[  --enable-bigstack	  increase thread stack size],
enable_bigstack=$enableval, enable_bigstack="no")

if test "$enable_bigstack" = "yes"; then
  AC_DEFINE(C_BIGSTACK,1,[Increase thread stack size.])
fi

AC_ARG_WITH(dbdir, 
[  --with-dbdir=path	  path to virus database directory],
db_dir="$withval", db_dir="_default_")

dnl I had problems with $pkgdatadir thus these funny checks
if test "$db_dir" = "_default_"
then
    if test "$prefix" = "NONE"
    then
	db_dir="$ac_default_prefix/share/clamav"
    else
	db_dir="$prefix/share/clamav"
    fi
fi

AC_DEFINE_UNQUOTED(DATADIR,"$db_dir", [Path to virus database directory.])
DBDIR="$db_dir"
AC_SUBST(DBDIR)

dnl configure config directory
cfg_dir=`echo $sysconfdir | grep prefix`

if test -n "$cfg_dir"; then
    if test "$prefix" = "NONE"
    then
	cfg_dir="$ac_default_prefix/etc"
    else
	cfg_dir="$prefix/etc"
    fi
else
    cfg_dir="$sysconfdir"
fi

CFGDIR=$cfg_dir
AC_SUBST(CFGDIR)
AC_DEFINE_UNQUOTED(CONFDIR,"$cfg_dir",[where to look for the config file])

dnl check for in_port_t definition
AC_TRY_RUN([
#include <sys/types.h>
#include <netinet/in.h>
int main(int argc, char **argv) { in_port_t pt; pt = 0; return pt; }
], AC_DEFINE(HAVE_IN_PORT_T,1,[in_port_t is defined]), AC_MSG_RESULT(in_port_t is not defined))

dnl check for in_addr_t definition
AC_TRY_RUN([
#include <sys/types.h>
#include <netinet/in.h>
int main(int argc, char **argv) { in_addr_t pt; pt = 0; return pt; }
], AC_DEFINE(HAVE_IN_ADDR_T,1,[in_addr_t is defined]), AC_MSG_RESULT(in_addr_t is not defined))

case "$target_os" in
linux*)
    AC_DEFINE(C_LINUX,1,[target is linux])
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
	if test "$want_clamuko" = "yes"; then
	    AC_DEFINE(CLAMUKO,1,[enable clamuko])
	fi
    fi
    case `uname -r` in
    1.*|2.0.*)
       AC_DEFINE(INCOMPLETE_CMSG,1,[Early Linux doesn't set cmsg fields])
       ;;
    esac
    ;;
kfreebsd*-gnu)
    AC_DEFINE(C_KFREEBSD_GNU,1,[target is kfreebsd-gnu])
    if test "$have_pthreads" = "yes"; then
       THREAD_LIBS="-lpthread"
       TH_SAFE="-thread-safe"
       AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
       AC_DEFINE(_REENTRANT,1,[thread safe])
       if test "$want_clamuko" = "yes"; then
           AC_DEFINE(CLAMUKO,1,[enable clamuko])
       fi
    fi
    ;;
cygwin*)
    AC_DEFINE(C_CYGWIN,1,[os is cygwin])
    if test "$test_clamav" = "yes"; then
	if test ! -r /etc/passwd; then
	   test_clamav="no"
	fi
    fi
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    use_gethostbyname_r="no"
    ;;
solaris*)
    FRESHCLAM_LIBS="$FRESHCLAM_LIBS -lresolv"
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	CLAMD_LIBS="$CLAMD_LIBS -lresolv"
	CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lresolv"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_SOLARIS,1,[os is solaris])
    ;;
freebsd[[45]]*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-pthread -lc_r"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
	if test "$want_clamuko" = "yes"; then
	    AC_DEFINE(CLAMUKO,1,[enable clamuko])
	fi
    fi
    AC_DEFINE(C_BSD,1,[os is freebsd 4 or 5])
    use_gethostbyname_r="no"
    ;;
freebsd*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lthr"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
	if test "$want_clamuko" = "yes"; then
	    AC_DEFINE(CLAMUKO,1,[enable clamuko])
	fi
    fi
    AC_DEFINE(C_BSD,1,[os is freebsd 6])
    use_gethostbyname_r="no"
    ;;
dragonfly*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-pthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
	if test "$want_clamuko" = "yes"; then
	    AC_DEFINE(CLAMUKO,1,[enable clamuko])
	fi
    fi
    AC_DEFINE(C_BSD,1,[os is dragonfly])
    use_gethostbyname_r="no"
    ;;
openbsd*)
    if test "$have_pthreads" = "yes"; then
	if test "$use_cr" = "no"; then
	    THREAD_LIBS="-pthread"
	else
	    THREAD_LIBS="-pthread -lc_r"
	fi
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_BSD,1,[os is OpenBSD])
    use_gethostbyname_r="no"
    ;;
bsdi*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-pthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_BSD,1,[os is BSDI BSD/OS])
    use_gethostbyname_r="no"
    ;;
netbsd*)
     if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
     fi
    AC_DEFINE(C_BSD,1,[os is NetBSD])
    use_gethostbyname_r="no"
    ;;
bsd*)
    AC_MSG_RESULT(Unknown BSD detected. Disabling thread support.)
    have_pthreads="no"
    AC_DEFINE(C_BSD,1,[os is bsd flavor])
    use_gethostbyname_r="no"
    ;;
beos*)
    AC_MSG_RESULT(BeOS detected. Disabling thread support.)
    have_pthreads="no"
    AC_DEFINE(C_BEOS,1,[os is beos])
    ;;
darwin*)
    AC_DEFINE(C_BSD,1,[os is bsd flavor])
    AC_DEFINE(C_DARWIN,1,[os is darwin])
    AC_DEFINE(BIND_8_COMPAT,1,[enable bind8 compatibility])
    use_netinfo="yes"
    use_gethostbyname_r="no"
    ;;
os2*)
    FRESHCLAM_LIBS="$FRESHCLAM_LIBS -lsyslog"
    CLAMD_LIBS="$CLAMD_LIBS -lsyslog"
    CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lsyslog"
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_OS2,1,[os is OS/2])
    ;;
sco*)
    dnl njh@bandsman.sco.uk: SCO Unix port
    dnl FRESHCLAM_LIBS="-lsocket"
    dnl CLAMD_LIBS="-lsocket"
    dnl CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lsocket"
    ;;
hpux*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_HPUX,1,[os is hpux])
    use_gethostbyname_r="no"
    ;;
aix*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_AIX,1,[os is aix])
    ;;
*-*-osf*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-pthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
	AC_DEFINE(_POSIX_PII_SOCKET,1,[POSIX compatibility])
    fi
    AC_DEFINE(C_OSF,1,[os is osf/tru64])
    ;;
nto-qnx*)
     if test "$have_pthreads" = "yes"; then
       AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
       AC_DEFINE(_REENTRANT,1,[thread safe])
     fi
    AC_DEFINE(C_QNX6,1,[os is QNX 6.x.x])
    ;;
irix*)
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    AC_DEFINE(C_IRIX,1,[os is irix])
    ;;
interix*)
    AC_DEFINE(C_INTERIX,1,[os is interix])
    if test "$test_clamav" = "yes"; then
	if test ! -r /etc/passwd; then
	   test_clamav="no"
	fi
    fi
    if test "$have_pthreads" = "yes"; then
	THREAD_LIBS="-lpthread"
	TH_SAFE="-thread-safe"
	AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
	AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    ;;
gnu*)
    AC_DEFINE(C_GNU_HURD,1,[target is gnu-hurd])
    if test "$have_pthreads" = "yes"; then
       THREAD_LIBS="-lpthread"
       TH_SAFE="-thread-safe"
       AC_DEFINE(CL_THREAD_SAFE,1,[thread safe])
       AC_DEFINE(_REENTRANT,1,[thread safe])
    fi
    ;;
*)
    ;;
esac

AC_SUBST(LIBCLAMAV_LIBS)
AC_SUBST(CLAMD_LIBS)
AC_SUBST(CLAMAV_MILTER_LIBS)
AC_SUBST(FRESHCLAM_LIBS)
AC_SUBST(TH_SAFE)
AC_SUBST(THREAD_LIBS)

dnl --enable-milter
if test "$have_milter" = "yes"; then
    dnl libmilter checking code adapted from spamass-milter by
    dnl Tom G. Christensen <tgc@statsbiblioteket.dk>

    dnl Check for libmilter and it's header files in the usual locations
    save_LDFLAGS="$LDFLAGS"
	CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lpthread"
    if test -d /usr/lib/libmilter ; then
	CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -L/usr/lib/libmilter"
    fi
    LDFLAGS="$LDFLAGS -lmilter $CLAMAV_MILTER_LIBS"
    AC_CHECK_LIB(milter, mi_stop,[CLAMAV_MILTER_LIBS="-lmilter $CLAMAV_MILTER_LIBS"],[
	dnl Older sendmails require libsm or libsmutil for support functions
	AC_SEARCH_LIBS(strlcpy, [sm smutil], [test "$ac_cv_search_strlcpy" = "none required" || CLAMAV_MILTER_XLIB="$ac_cv_search_strlcpy"])
	LDFLAGS="$save_LDFLAGS $CLAMAV_MILTER_LIBS $CLAMAV_MILTER_XLIB"
	$as_unset ac_cv_lib_milter_mi_stop
	AC_CHECK_LIB(milter, mi_stop,[CLAMAV_MILTER_LIBS="-lmilter $CLAMAV_MILTER_XLIB $CLAMAV_MILTER_LIBS"],[
	    AC_MSG_ERROR([Cannot find libmilter])
	])
    ])
    LDFLAGS="$save_LDFLAGS"
    AC_CHECK_HEADERS(libmilter/mfapi.h,have_milter="yes",[
	AC_MSG_ERROR([Please install mfapi.h from the sendmail distribution])
    ])
fi

AM_CONDITIONAL(BUILD_CLAMD, test "$have_pthreads" = "yes")
AM_CONDITIONAL(HAVE_MILTER, test "$have_milter" = "yes")
AM_CONDITIONAL(ENABLE_UNRAR, test "$want_unrar" = "yes")

if test "$have_pthreads" = "yes"
then
    AC_DEFINE(BUILD_CLAMD, 1, "build clamd")
fi

if test "$want_unrar" = "yes"
then
    AC_DEFINE(ENABLE_UNRAR, 1, "build unrar code")
fi

dnl Check if we can do fd passing
dnl Submitted by Richard Lyons <frob-clamav@webcentral.com.au>
AC_CHECK_FUNCS(recvmsg sendmsg)
AC_CACHE_CHECK([for msg_accrights field in struct msghdr],
	ac_cv_have_accrights_in_msghdr, [
    AC_TRY_RUN(
	[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
int main() {
#ifdef msg_accrights
exit(1);
#endif
struct msghdr m;
m.msg_accrights = 0;
exit(0);
}
	],
	[ ac_cv_have_accrights_in_msghdr="yes" ],
	[ ac_cv_have_accrights_in_msghdr="no" ]
    )
])
if test "x$ac_cv_have_accrights_in_msghdr" = "xyes" ; then
    AC_DEFINE(HAVE_ACCRIGHTS_IN_MSGHDR,1,[access rights in msghdr])
fi

AC_CACHE_CHECK([for msg_control field in struct msghdr],
	ac_cv_have_control_in_msghdr, [
    AC_TRY_RUN(
	[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
int main() {
#ifdef msg_control
exit(1);
#endif
struct msghdr m;
m.msg_control = 0;
exit(0);
}
	],
	[ ac_cv_have_control_in_msghdr="yes" ],
	[ ac_cv_have_control_in_msghdr="no" ]
    )
])
if test "x$ac_cv_have_control_in_msghdr" = "xyes" ; then
    AC_DEFINE(HAVE_CONTROL_IN_MSGHDR,1,[ancillary data style fd pass])
fi

dnl tcpwrappers support
dnl rules from http://ma.ph-freiburg.de/tng/tng-technical/2002-01/msg00094.html
AC_ARG_WITH(tcpwrappers,
[  --with-tcpwrappers      support hosts.allow / hosts.deny (default=auto)],
[ case "$withval" in
  yes|no) tcpw="$withval" ;;
  *)      AC_MSG_ERROR([--with-tcpwrappers does not take an argument]) ;;
  esac],
[ tcpw=auto ])

if test "$tcpw" != "no" && test "$have_milter" = "yes" ; then
        AC_CHECK_HEADERS(tcpd.h,[
                AC_MSG_CHECKING([for TCP wrappers library])
                save_LIBS="$LIBS"
                LIBS="$LIBS -lwrap $FRESHCLAM_LIBS"
                AC_TRY_LINK([
#include <tcpd.h>
int allow_severity = 0;
int deny_severity  = 0;

struct request_info *req;
                ],[
hosts_access(req)
                ],[AC_MSG_RESULT([-lwrap])
                have_wrappers=yes
		LIBS="$save_LIBS"
                CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lwrap"],[
                dnl try with -lnsl
                LIBS="$LIBS -lnsl $FRESHCLAM_LIBS"
                AC_TRY_LINK([
#include <tcpd.h>
int allow_severity = 0;
int deny_severity  = 0;

struct request_info *req;
                ],[
hosts_access(req)
                ],[AC_MSG_RESULT([-lwrap -lnsl])
                have_wrappers=yes
                CLAMAV_MILTER_LIBS="$CLAMAV_MILTER_LIBS -lwrap"],[
                AC_MSG_RESULT(no)
                have_wrappers=no
                LIBS=$save_LIBS])],[
                have_wrappers=no])],[have_wrappers=no])

        if test $have_wrappers = yes ; then
                AC_DEFINE(WITH_TCPWRAP,1, [tcpwrappers support])
        elif test $tcpw = yes ; then
                AC_MSG_ERROR([could not find TCP wrappers])
        else
                AC_MSG_WARN([could not find TCP wrappers, support disabled])
        fi
fi

dnl Check for gethostbyname_r and number of its arguments
dnl Code from libwww/configure.in
AC_MSG_CHECKING(for gethostbyname_r)
if test -z "$ac_cv_gethostbyname_args"; then
AC_TRY_COMPILE(
[
#include <sys/types.h>
#include <netdb.h>
],[
struct hostent *hp;
struct hostent h;
char *name;
char buffer[10];
int  h_errno;
hp = gethostbyname_r(name, &h, buffer, 10, &h_errno);
], ac_cv_gethostbyname_args=5)
fi
if test -z "$ac_cv_gethostbyname_args"; then
AC_TRY_COMPILE(
[
#include <sys/types.h>
#include <netdb.h>
],[
struct hostent h;
struct hostent_data hdata;
char *name;
int  rc;
rc = gethostbyname_r(name, &h, &hdata);
], ac_cv_gethostbyname_args=3)
fi
if test -z "$ac_cv_gethostbyname_args"; then
AC_TRY_COMPILE(
[
#include <sys/types.h>
#include <netdb.h>
], [
struct hostent h;
struct hostent *hp;
char *name;
char buf[10];
int rc;
int h_errno;

rc = gethostbyname_r(name, &h, buf, 10, &hp, &h_errno);
], ac_cv_gethostbyname_args=6)
fi

AC_ARG_ENABLE(gethostbyname_r,
[  --disable-gethostbyname_r	  disable support for gethostbyname_r],
use_gethostbyname_r=$enableval,)

if test "$use_gethostbyname_r" = "no"; then
    AC_MSG_RESULT(support disabled)
elif test -z "$ac_cv_gethostbyname_args"; then
    AC_MSG_RESULT(no)
else
    if test "$ac_cv_gethostbyname_args" = 3; then
	AC_DEFINE(HAVE_GETHOSTBYNAME_R_3,1,[gethostbyname_r takes 3 arguments])
    elif test "$ac_cv_gethostbyname_args" = 5; then
	AC_DEFINE(HAVE_GETHOSTBYNAME_R_5,1,[gethostbyname_r takes 5 arguments])
    elif test "$ac_cv_gethostbyname_args" = 6; then
	AC_DEFINE(HAVE_GETHOSTBYNAME_R_6,1,[gethostbyname_r takes 6 arguments])
    fi
    AC_MSG_RESULT([yes, and it takes $ac_cv_gethostbyname_args arguments])
fi

dnl Check for readdir_r and number of its arguments
dnl Code from libwww/configure.in

AC_MSG_CHECKING(for readdir_r)
if test -z "$ac_cv_readdir_args"; then
    AC_TRY_COMPILE(
    [
#include <sys/types.h>
#include <dirent.h>
    ],
    [
    struct dirent dir, *dirp;
    DIR *mydir;
    dirp = readdir_r(mydir, &dir);
    ], ac_cv_readdir_args=2)
fi
if test -z "$ac_cv_readdir_args"; then
    AC_TRY_COMPILE(
        [
#include <sys/types.h>
#include <dirent.h>
    ],
    [
        struct dirent dir, *dirp;
        DIR *mydir;
        int rc;
        rc = readdir_r(mydir, &dir, &dirp);
    ], ac_cv_readdir_args=3)
fi

AC_ARG_ENABLE(readdir_r,
[  --enable-readdir_r		    enable support for readdir_r],
enable_readdir_r=$enableval, enable_readdir_r="no")

if test "$enable_readdir_r" = "no"; then
    AC_MSG_RESULT(support disabled)
elif test -z "$ac_cv_readdir_args"; then
    AC_MSG_RESULT(no)
else
    if test "$ac_cv_readdir_args" = 2; then
	AC_DEFINE(HAVE_READDIR_R_2,1,[readdir_r takes 2 arguments])
    elif test "$ac_cv_readdir_args" = 3; then
	AC_DEFINE(HAVE_READDIR_R_3,1,[readdir_r takes 3 arguments])
    fi
    AC_MSG_RESULT([yes, and it takes $ac_cv_readdir_args arguments])
fi

AC_MSG_CHECKING(for ctime_r)
if test "$ac_cv_func_ctime_r" = "yes"; then
    AC_TRY_COMPILE([
	#include <time.h>
    ],[
	char buf[31];
	time_t t;
	ctime_r(&t, buf, 30);
    ],[
	ac_cv_ctime_args=3
	AC_DEFINE(HAVE_CTIME_R_3,1,[ctime_r takes 3 arguments])
    ],[
	ac_cv_ctime_args=2
	AC_DEFINE(HAVE_CTIME_R_2,1,[ctime_r takes 2 arguments])
    ])

    AC_MSG_RESULT([yes, and it takes $ac_cv_ctime_args arguments])
fi

dnl Determine socklen_t type. Code from lftp.
AC_MSG_CHECKING(for socklen_t)
AC_CACHE_VAL(ac_cv_socklen_t,
[
    ac_cv_socklen_t=no
    AC_TRY_COMPILE([
	#include <sys/types.h>
        #include <sys/socket.h>
    ],
    [
	socklen_t len;
        getpeername(0,0,&len);
    ],
    [
	ac_cv_socklen_t=yes
    ])
])
AC_MSG_RESULT($ac_cv_socklen_t)
    if test $ac_cv_socklen_t = no; then
    AC_MSG_CHECKING(for socklen_t equivalent)
    AC_CACHE_VAL(ac_cv_socklen_t_equiv,
    [
	ac_cv_socklen_t_equiv=int
        for t in int size_t unsigned long "unsigned long"; do
	    AC_TRY_COMPILE([
		#include <sys/types.h>
		#include <sys/socket.h>
	    ],
            [
		$t len;
		getpeername(0,0,&len);
            ],
            [
		ac_cv_socklen_t_equiv="$t"
		break
            ])
	done
    ])
    AC_MSG_RESULT($ac_cv_socklen_t_equiv)
    AC_DEFINE_UNQUOTED(socklen_t, $ac_cv_socklen_t_equiv, [Define to "int" if <sys/socket.h> does not define.])
fi

dnl Check for clamav in /etc/passwd
if test "$test_clamav" = "yes"
then
    dnl parse /etc/passwd
    if test "$use_id" = "no"
    then
	AC_MSG_CHECKING(for $clamav_user in /etc/passwd)
	if test -r /etc/passwd; then
	    clamavuser=`cat /etc/passwd|grep "^$clamav_user:"`
	    clamavgroup=`cat /etc/group|grep "^$clamav_group:"`
	fi
    else
	AC_MSG_CHECKING(for $clamav_user using id)
	id $clamav_user > /dev/null 2>&1
	if test "$?" = 0 ; then
	    clamavuser=1
	    AC_PATH_PROG(GETENT, getent)
	    if test -n "$GETENT" ; then
		clamavgroup=`$GETENT group | grep "^${clamav_group}:"`
	    else
		clamavgroup=`cat /etc/group|grep $clamav_group`
	    fi
	fi
    fi

    if test "$use_netinfo" = "yes"
    then
	AC_MSG_CHECKING(for $clamav_user using netinfo)
        clamavuser=`/usr/bin/nidump passwd . |grep ${clamav_user}`
        clamavgroup=`/usr/bin/nidump group . |grep ${clamav_group}`
    fi

    if test "$use_yp" = "yes"
    then
	AC_MSG_CHECKING(for $clamav_user using ypmatch)
        clamavuser=`ypmatch ${clamav_user} passwd`
        clamavgroup=`ypmatch ${clamav_group} group`
    fi

    if test -z "$clamavuser" || test -z "$clamavgroup"
    then
	AC_MSG_RESULT(no)
	AC_MSG_ERROR(User $clamav_user (and/or group $clamav_group) doesn't exist. Please read the documentation !)
    else
	AC_MSG_RESULT([yes, user $clamav_user and group $clamav_group])
        CLAMAVUSER="$clamav_user"
        CLAMAVGROUP="$clamav_group"
        AC_SUBST(CLAMAVUSER)
        AC_SUBST(CLAMAVGROUP)
    fi
fi

AC_C_CONST
AC_C_INLINE
AC_C_BIGENDIAN
if test $ac_cv_c_bigendian = yes; then
  AC_DEFINE(WORDS_BIGENDIAN,1,endianess)
else
  AC_DEFINE(WORDS_BIGENDIAN,0,endianess)
fi

dnl check for __attribute__((packed))
AC_MSG_CHECKING([for structure packing via __attribute__((packed))])
AC_CACHE_VAL(have_attrib_packed,[
	AC_TRY_COMPILE(,
		[struct { int i __attribute__((packed)); } s; ],
		[have_attrib_packed=yes],
		[have_attrib_packed=no])
	])
AC_MSG_RESULT($have_attrib_packed)

if test "$have_attrib_packed" = no; then
	AC_MSG_CHECKING(for structure packing via pragma)
	AC_CACHE_VAL(have_pragma_pack,[
		AC_TRY_RUN([int main(int argc, char **argv) {
#pragma pack(1)			/* has to be in column 1 ! */
			struct { char c; long l; } s;
			return sizeof(s)==sizeof(s.c)+sizeof(s.l) ? 0:1; } ],
			[have_pragma_pack=yes],
			[have_pragma_pack=no])
		])
	AC_MSG_RESULT($have_pragma_pack)
	if test "$have_pragma_pack" = yes; then
		AC_DEFINE(HAVE_PRAGMA_PACK, 1, "pragma pack")
	else
		AC_MSG_CHECKING(for structure packing via hppa/hp-ux pragma)
		AC_CACHE_VAL(have_pragma_pack_hpux,[
			AC_TRY_RUN([
			/* hppa/hp-ux wants pragma outside of function */
#pragma pack 1 /* has to be in column 1 ! */
			struct { char c; long l; } s;
			    int main(int argc, char **argv) {
			return sizeof(s)==sizeof(s.c)+sizeof(s.l) ? 0:1; } ],
			[have_pragma_pack_hpux=yes],
			[have_pragma_pack_hpux=no])
		])
		AC_MSG_RESULT($have_pragma_pack_hpux)
		AC_DEFINE(HAVE_PRAGMA_PACK_HPPA, 1, "pragma pack hppa/hp-ux style")
	fi
fi

dnl check for __attribute__((aligned))
AC_MSG_CHECKING([for type aligning via __attribute__((aligned))])
AC_CACHE_VAL(have_attrib_aligned,[
	AC_TRY_COMPILE(,
		[typedef int cl_aligned_int __attribute__((aligned));],
		[have_attrib_aligned=yes],
		[have_attrib_aligned=no])
	])
AC_MSG_RESULT($have_attrib_aligned)

if test "$have_attrib_packed" = no -a "$have_pragma_pack" = no -a "$have_pragma_pack_hpux" = no; then
	AC_MSG_ERROR(Need to know how to pack structures with this compiler)
fi

if test "$have_attrib_packed" = yes; then
	AC_DEFINE(HAVE_ATTRIB_PACKED, 1, [attrib packed])
fi

if test "$have_attrib_aligned" = yes; then
	AC_DEFINE(HAVE_ATTRIB_ALIGNED, 1, [attrib aligned])
fi

dnl Check if <sys/select.h> needs to be included for fd_set
AC_MSG_CHECKING([for fd_set])
AC_TRY_COMPILE([#include <sys/types.h>],
        [fd_set readMask, writeMask;], have_fd_set=yes, have_fd_set=no)
if test $have_fd_set = yes; then
    AC_MSG_RESULT([yes, found in sys/types.h])
else
    AC_HEADER_EGREP(fd_mask, sys/select.h, have_fd_set=yes)
    if test $have_fd_set = yes; then
        AC_DEFINE(HAVE_SYS_SELECT_H, 1, "have <sys/select.h>")
        AC_MSG_RESULT([yes, found in sys/select.h])
    else
        AC_DEFINE(NO_FD_SET, 1, "no fd_set")
        AC_MSG_RESULT(no)
    fi
fi

AC_MSG_CHECKING(default FD_SETSIZE value)
AC_TRY_RUN([
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/types.h>
main() {
        FILE *fp = fopen("conftestval", "w");
        fprintf (fp, "%d\n", FD_SETSIZE);
        exit(0);
}
],
DEFAULT_FD_SETSIZE=`cat conftestval`,
DEFAULT_FD_SETSIZE=256,
DEFAULT_FD_SETSIZE=256)
AC_MSG_RESULT($DEFAULT_FD_SETSIZE)
AC_DEFINE_UNQUOTED(DEFAULT_FD_SETSIZE, $DEFAULT_FD_SETSIZE, "default FD_SETSIZE value")

dnl Check signed right shift implementation
AC_MSG_CHECKING(if signed right shift is sign extended)
AC_TRY_RUN([int main(void){int a=-1;int b=a>>1;return(a!=b);}],
    [have_signed_rightshift_extended=yes],
    [have_signed_rightshift_extended=no],
    [have_signed_rightshift_extended=no])
if test $have_signed_rightshift_extended = yes; then
    AC_DEFINE(HAVE_SAR, 1, Define signed right shift implementation)
fi
AC_MSG_RESULT($have_signed_rightshift_extended);

AC_C_FPU_BIGENDIAN

AC_OUTPUT([
libclamunrar/Makefile
libclamunrar_iface/Makefile
libclamav/Makefile
clamscan/Makefile
database/Makefile
docs/Makefile
clamd/Makefile
clamdscan/Makefile
clamav-milter/Makefile
freshclam/Makefile
sigtool/Makefile
clamconf/Makefile
etc/Makefile
Makefile
clamav-config
libclamav.pc
docs/man/clamav-milter.8
docs/man/clamconf.1
docs/man/clamd.8
docs/man/clamd.conf.5
docs/man/clamdscan.1
docs/man/clamscan.1
docs/man/freshclam.1
docs/man/freshclam.conf.5
docs/man/sigtool.1
])