rmilter/configure

#!/bin/sh

GCC="gcc"
MAKE=""
LEX=""
YACC=""
OS=""

LOCALBASE=/usr/local
PREFIX=$LOCALBASE

DCC_VER=1.2.74
COMPAT_DIR="./compat"

YACC_SRC="cfg_file.y"
LEX_SRC="cfg_file.l"
YACC_OUTPUT="cfg_yacc.c"
LEX_OUTPUT="cfg_lex.c"

SOURCES="upstream.c regexp.c rmilter.c libclamc.c cfg_file.c ratelimit.c memcached.c beanstalk.c main.c radix.c awl.c libspamd.c greylist.c ${LEX_OUTPUT} ${YACC_OUTPUT}"

CFLAGS="$CFLAGS -Wall -Wpointer-arith"
CFLAGS="$CFLAGS -ggdb -I${LOCALBASE}/include"
CFLAGS="$CFLAGS -DHASH_COMPAT"
LDFLAGS="$LDFLAGS -L${LOCALBASE}/lib"
PTHREAD_CFLAGS="-D_THREAD_SAFE"
OPT_FLAGS="-O -pipe -fno-omit-frame-pointer"
DEPS="awl.h cfg_file.h libclamc.h libspamd.h memcached.h radix.h ratelimit.h regexp.h \
	  rmilter.h spf.h upstream.h greylist.h ${LEX_OUTPUT} ${YACC_OUTPUT} \
	  uthash/uthash.h"
EXEC=rmilter
USER=postfix
GROUP=postfix
SENDMAIL=no
INSTALL="/usr/bin/install -v"
MKDIR="/usr/bin/install -v -d"
MANPATH="${PREFIX}/share/man"
CACHE=config.cache

MAKEFILE="Makefile"
MAKEFILE_IN="Makefile.in"

TARGETS="${EXEC}"

check_cache()
{
	type=$1
	name=$2
	
	if [ -f $CACHE ] ; then
		line=`fgrep "$type:$name" $CACHE 2>/dev/null`
		if [ $? -eq 0 ] ; then
			result=`echo $line | cut -d ':' -f 3`
			CACHED=`echo $line | cut -d ':' -f 4-`
			if [ "F$result" = "Fyes" ] ; then
				return 0
			elif [ "F$result" = "Fno" ] ; then
				return 1
			else
				return 2
			fi
		else
			return 3
		fi
	else
		return 3
	fi
}

write_cache()
{
	type=$1
	name=$2
	result=$3
	value=$4

	echo "$type:$name:$result:$value" >> $CACHE
}

cleanup()
{
	rm -f autotest.c
	rm -f autotest
	INCLUDE=""
}

test_binary()
{
	path="$PATH:$PREFIX/bin:$LOCALBASE/bin"

	while [ $# -ne 0 ] ; do
		_binary=$1
		_tmp_bin=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which ${_binary} 2>/dev/null` 
		if [ $? -eq 0 ] ; then
			BIN=$_binary
			return 0
		fi
		shift
	done
	
	return 1
}

check_compiler()
{
	if [ "F${CC}" != "F" ] ; then 
		GCC=${CC}
		test_binary ${CC}
		if [ $? -eq 0 ] ; then
			GCC=$BIN
			echo "found -> $GCC"
			write_cache "compiler" "${GCC}" "yes" "$GCC"
			return 0
		else
			echo "not found"
			exit 1
		fi
	fi
	echo -n "Testing for ${GCC}: "
	check_cache "compiler" "${GCC}"
	if [ $? -eq 0 ] ; then
		GCC=$CACHED
		echo "found(cached) -> $GCC"
		return 0
	fi
	
	test_binary "gcc" "cc" "pcc" "clang"
	if [ $? -eq 0 ] ; then
		GCC=$BIN
		echo "found -> $GCC"
		write_cache "compiler" "${GCC}" "yes" "$GCC"
		return 0
	else
		echo "not found"
		exit 1
	fi
}

check_make()
{	
	echo -n "Testing for make: "
	check_cache "make" "make"
	if [ $? -eq 0 ] ; then
		MAKE=$CACHED
		echo "found(cached) -> $MAKE"
		return 0
	fi

	test_binary "make" "pmake"
	if [ $? -eq 0 ] ; then
		MAKE=$BIN
		echo "found -> $MAKE"
		write_cache "make" "make" "yes" "$MAKE"
		return 0
	else
		echo "not found"
		exit 1
	fi

}

check_lex()
{
	echo -n "Testing for lex: "
	check_cache "binary" "lex"
	if [ $? -eq 0 ] ; then
		LEX=$CACHED
		echo "found(cached) -> $LEX"
		return 0
	fi
	
	test_binary "lex" "flex"
	if [ $? -eq 0 ] ; then
		LEX=$BIN
		echo "found -> $LEX"
		write_cache "binary" "lex" "yes" "$LEX"
		return 0
	else
		echo "not found"
		exit 1
	fi

}

check_yacc()
{
	echo -n "Testing for yacc: "
	check_cache "binary" "yacc"
	if [ $? -eq 0 ] ; then
		YACC=$CACHED
		echo "found(cached) -> $YACC"
		return 0
	fi

	echo -n "Testing for yacc: "
	test_binary "yacc" "byacc"
	if [ $? -eq 0 ] ; then
		YACC=$BIN
		echo "found -> $YACC"
		write_cache "binary" "yacc" "yes" "$YACC"
		return 0
	else
		echo "not found"
		exit 1
	fi

}

check_util()
{
	echo -n "Testing for $1: "
	check_cache "binary" "$1"
	if [ $? -eq 0 ] ; then
		echo "found(cached) -> $CACHED"
		return 0
	fi
	test_binary "$1"
	if [ $? -eq 0 ] ; then
		UTIL=$BIN
		echo "found -> $UTIL"
		write_cache "binary" "$1" "yes" "$UTIL"
		return 0
	else
		echo "not found"
		exit 1
	fi

}

check_function()
{
	FUNCTION=$1
	while [ $# -ne 0 ] ; do 
		if [ ! -n $2 ] ; then
			break
		fi
		shift
		if [ "F$INCLUDE" = "F" ] ; then
			INCLUDE="$1"
		else
			INCLUDE="$INCLUDE $1"
		fi
	done
	echo -n "Testing for $FUNCTION: "
	echo >> config.log
	echo "Testing for $FUNCTION: " >> config.log
	check_cache "function" "$FUNCTION"
	if [ $? -eq 0 ] ; then
		echo "-> OK (cached)"
		echo "-> OK (cached)" >> config.log
		return 0
	fi
	echo "#include <sys/types.h>" > autotest.c
	if [ "F$INCLUDE" != "F" ] ; then
		for inc in $INCLUDE ; do
			echo "#include \"$inc\"" >> autotest.c
		done
	fi
	echo "#include <stdlib.h>" >> autotest.c
	echo "int main (int argc, char **argv) { $FUNCTION; return 0; }" >> autotest.c
	echo "$GCC $PTHREAD_CFLAGS $CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS  autotest.c" >>config.log
	$GCC $PTHREAD_CFLAGS $CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS  autotest.c >>config.log 2>&1
	if [ $? -eq 0 ] ; then 
		echo "found"
		cleanup
		echo "-> OK" >> config.log
		write_cache "function" "$FUNCTION" "yes" ""
		return 0
	else
		echo "not found"
		echo "-> FAILED" >> config.log
		echo "Failed program was:" >> config.log
		cat autotest.c >> config.log
		cleanup
		write_cache "function" "$FUNCTION" "no" ""
		return 1
	fi
}

check_include()
{
	_INCLUDE="$1"
	echo -n "Testing for $_INCLUDE: "
	echo >> config.log
	echo "Testing for $_INCLUDE: " >> config.log
	check_cache "include" "$_INCLUDE"
	if [ $? -eq 0 ] ; then
		echo "-> OK (cached)"
		echo "-> OK (cached)" >> config.log
		_CFLAG=`echo "$_INCLUDE" | sed -e 's/[./]/_/g' | tr '[:lower:]' '[:upper:]'`
		CFLAGS="$CFLAGS -DHAVE_$_CFLAG"
		return 0
	fi
	echo "#include <sys/types.h>" > autotest.c
	echo "#include \"$_INCLUDE\"" >> autotest.c
	echo "#include <stdlib.h>" >> autotest.c
	echo "int main (int argc, char **argv) { return 0; }" >> autotest.c
	echo "$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS autotest.c" >>config.log
	$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS autotest.c >>config.log 2>&1
	if [ $? -eq 0 ] ; then 
		echo "found"
		echo "-> OK" >> config.log
		_CFLAG=`echo "$_INCLUDE" | sed -e 's/[./]/_/g' | tr '[:lower:]' '[:upper:]'`
		CFLAGS="$CFLAGS -DHAVE_$_CFLAG"
		write_cache "include" "$_INCLUDE" "yes" "$_CFLAG"
		cleanup
		return 0
	else
		echo "not found"
		echo "-> FAILED" >> config.log
		echo "Failed program was:" >> config.log
		cat autotest.c >> config.log
		write_cache "include" "$_INCLUDE" "no" ""
		cleanup
		return 1
	fi
}

check_macro()
{
	MACRO=$1
	_INCLUDE=""
	while [ $# -ne 1 -a -n $1 ] ; do 
		shift
		if [ "F$_INCLUDE" = "F" ] ; then
			_INCLUDE="$1"
		else
			_INCLUDE="$_INCLUDE $1"
		fi
	done
	echo -n "Testing for $MACRO: "
	echo >> config.log
	echo "Testing for $MACRO: " >> config.log
	check_cache "macro" "$MACRO"
	if [ $? -eq 0 ] ; then
		echo "-> OK (cached)"
		echo "-> OK (cached)" >> config.log
		return 0
	fi
	echo "#include <sys/types.h>" > autotest.c
	for _inc in $_INCLUDE ; do
		echo "#include \"$_inc\"" >> autotest.c
	done
	echo "#include <stdlib.h>" >> autotest.c
	echo "int main (int argc, char **argv) {" >>autotest.c
	echo "#ifndef $MACRO" >>autotest.c
	echo "#error \"$MACRO not defined\"" >>autotest.c 
	echo "#endif" >> autotest.c
	echo "}" >>autotest.c
	echo "$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS autotest.c" >> config.log
	$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS $PTHREAD_LDFLAGS autotest.c >>config.log 2>&1
	if [ $? -eq 0 ] ; then 
		echo "found"
		echo "-> OK" >> config.log
		write_cache "macro" "$MACRO" "yes" ""
		cleanup
		return 0
	else
		echo "not found"
		echo "-> FAILED" >> config.log
		echo "Failed program was:" >> config.log
		cat autotest.c >> config.log
		write_cache "macro" "$MACRO" "no" ""
		cleanup
		return 1
	fi
}

check_single_lib()
{
	_slib=$1
	_path=$2
	
	echo "#include <sys/types.h>" > autotest.c
	if [ "F$INCLUDE" != "F" ] ; then
		for inc in $INCLUDE ; do
			echo "#include \"$inc\"" >> autotest.c
		done
	fi
	echo "#include <stdlib.h>" >> autotest.c
	echo "int main (int argc, char **argv) { return 0; }" >> autotest.c
	echo "$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -L$_path -l$_slib $PTHREAD_LDFLAGS autotest.c" >>config.log
	$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -L$_path -l$_slib $PTHREAD_LDFLAGS autotest.c >>config.log 2>&1
	if [ $? -eq 0 ] ; then
			_found="yes"
			return 0
	fi
	
	return 1
}

check_lib()
{
	_SEARCH=""
	echo $1 | grep -- '--search=' > /dev/null
	if [ $? -eq 0 ] ; then
		_SEARCH=`echo $1 | sed -e 's/^--search=//'`
		shift
	fi

	LIB=$1
	while [ $# -ne 1 -a -n $1 ] ; do 
		shift
		if [ "F$INCLUDE" = "F" ] ; then
			INCLUDE="$1"
		else
			INCLUDE="$INCLUDE $1"
		fi
	done
	echo -n "Testing for lib$LIB: "
	echo >> config.log
	echo "Testing for lib$LIB: " >> config.log
	check_cache "lib" "$LIB"
	if [ $? -eq 0 ] ; then
		check_cache "libpath" "$LIB"
		if [ $? -eq 0 ] ; then
			LIBS="$LIBS -L$CACHED"
		fi
		LIBS="$LIBS -l$LIB"
		echo "-> OK (cached)"
		echo "-> OK (cached)" >> config.log
		return 0
	fi

	if [ "F$_SEARCH" = "F" ] ; then 
		check_single_lib "$LIB" "/lib"

		if [ $? -eq 0 ] ; then 
			echo "found"
			LIBS="$LIBS -l$LIB"
			echo "-> OK" >> config.log
			write_cache "lib" "$LIB" "yes" ""
			cleanup
			return 0
		else
			echo "not found"
			echo "-> FAILED" >> config.log
			echo "Failed program was:" >> config.log
			cat autotest.c >> config.log
			write_cache "lib" "$LIB" "no" ""
			cleanup
			return 1
		fi
	else
		_saved_ifs=$IFS
		IFS=":"
		for _p in $_SEARCH ; do
			IFS=$_saved_ifs
			check_single_lib "$LIB" "$_p"
			if [ $? -eq 0 ] ; then 
				echo "found"
				LIBS="$LIBS -L$_p -l$LIB"
				echo "-> OK" >> config.log
				write_cache "lib" "$LIB" "yes" ""
				write_cache "libpath" "$LIB" "yes" "$_p"
				cleanup
				IFS=$_saved_ifs
				return 0
			fi
			IFS=":"
		done
		IFS=$_saved_ifs
	fi

	echo "not found"
	echo "-> FAILED" >> config.log
	echo "Failed program was:" >> config.log
	cat autotest.c >> config.log
	write_cache "lib" "$LIB" "no" ""
	cleanup
	return 1
}

check_os()
{
	_OS=`uname -s`
	_PROCESSOR=`uname -p`
	case "$_OS" in
		FreeBSD*)
				OS="freebsd"
				CFLAGS="${CFLAGS} -DFREEBSD"
				INSTALL="/usr/bin/install -C -S -v"
				MKDIR="/usr/bin/install -d -v"
				MANPATH="${PREFIX}/man"
				case `uname -r` in
				4.*)
					CFLAGS="$CFLAGS -DFREEBSD_LEGACY"
					PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread" PTHREAD_LDFLAGS="-pthread" ;;
				5.*)
					PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread" PTHREAD_LDFLAGS="-lpthread" ;;
				*)
					PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread" PTHREAD_LDFLAGS="-pthread" ;;
				esac
				;;
		Linux*)	
				OS="linux"
				CFLAGS="${CFLAGS} -I/usr/include/${_PROCESSOR}-linux-gnu/ -DLINUX -D_GNU_SOURCE" PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread" 
				PTHREAD_LDFLAGS="-pthread" 
				;;
		*)		OS="unknown" PTHREAD_LDFLAGS="" PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread" ;;
	esac
}

check_user()
{
	_user=$1
	echo -n "Checking for user $_user: "
	grep $_user /etc/passwd > /dev/null 2>&1
	if [ $? -eq 0 ] ; then
		echo "found"
		return 0
	else
		echo "not found"
		return 1
	fi
}

check_group()
{
	_group=$1
	echo -n "Checking for group $_group: "
	grep $_group /etc/group > /dev/null 2>&1
	if [ $? -eq 0 ] ; then
		echo "found"
		return 0
	else
		echo "not found"
		return 1
	fi
}

write_result()
{
	echo "Compiler: $GCC" >> config.log 
	echo "Make: $MAKE" >> config.log 
	echo "Sources: $SOURCES" >> config.log
	echo "Cflags: $CFLAGS" >> config.log
	echo "Ldflags: $LDFLAGS" >> config.log
	echo "Libs: $LIBS" >> config.log
	OBJECTS=`echo $SOURCES | sed -e 's/\.c/\.o/g'`
	cat > $MAKEFILE << END
# This is ${EXEC} Makefile
# For options edit Makefile.in, this file is autogenerated by configure

CC?=$GCC
# Optimization flags
OPT_FLAGS+=$OPT_FLAGS
# Compile time flags
CFLAGS+=$CFLAGS
# Link time flags
LDFLAGS+=$LDFLAGS
# Libraries to link
LIBS=$LIBS
# ${EXEC} sources
SOURCES=$SOURCES
# ${EXEC} objects 
OBJECTS=$OBJECTS
# Detected operation system
OS=$OS
# Version of dcc (if needed)
DCC_VER=$DCC_VER
# Lex and yacc executables
LEX=$LEX
YACC=$YACC
# Pthread specific flags
PTHREAD_CFLAGS=$PTHREAD_CFLAGS
PTHREAD_LDFLAGS=$PTHREAD_LDFLAGS
# Prefix to install
PREFIX=$PREFIX
# Where local libs and includes are located
LOCALBASE=$LOCALBASE
# Install commands
INSTALL=$INSTALL
MKDIR=$MKDIR
# Executable name
EXEC=$EXEC
# User and group
RMILTER_USER=$USER
RMILTER_GROUP=$GROUP
# All target dependenses
TARGETS=$TARGETS
# Common dependenses
DEPS=$DEPS
# Path to install manual page
MANPATH=$MANPATH

END
	# Write build targets to makefile

	cat $MAKEFILE_IN >> $MAKEFILE
	cat >> $MAKEFILE << END
${EXEC}: \$(OBJECTS)
	\$(CC) \$(PTHREAD_LDFLAGS) \$(LDFLAGS) \$(OBJECTS) \$(LIBS) -o \$(EXEC)
END
	for o in $OBJECTS ; do
		SO=`echo $o | sed -e 's/\.o/\.c/g'`
		cat >> $MAKEFILE << END
${o}: \$(DEPS) ${SO}
	\$(CC) \$(OPT_FLAGS) \$(CFLAGS) \$(PTHREAD_CFLAGS) -c ${SO}

END
	done
	cat >> $MAKEFILE << END
${LEX_OUTPUT}: cfg_file.h ${LEX_SRC} ${YACC_OUTPUT}
	\$(LEX) -o${LEX_OUTPUT} ${LEX_SRC}

${YACC_OUTPUT}: cfg_file.h ${YACC_SRC}
	\$(YACC) -d -o ${YACC_OUTPUT} ${YACC_SRC}
END

}


for option
do
    case "$option" in
        -*=*) value=`echo "$option" | sed -e 's/[-_a-zA-Z0-9]*=//'` ;;
		 *=*) var=`echo "$option" | cut -d'=' -f1`
		 	  value=`echo "$option" | cut -d'=' -f2` 
			  eval "${var}=${value}" ;;
           *) value="" ;;
    esac

    case "$option" in
        --help)                          help=yes                  					;;
		--prefix*)						 PREFIX=$value								;;
		--user*)						 USER=$value								;;
		--group*)						 GROUP=$value								;;
		--enable-auth-strict)			 CFLAGS="$CFLAGS -DSTRICT_AUTH"             ;;
		--enable-dcc)                    dcc=yes                    				;;
		--disable-spf)                   spf=no                                     ;;
		--enable-dkim)					 dkim=yes									;;
		--enable-debug)					 CFLAGS="$CFLAGS -DWITH_DEBUG" OPT_FLAGS=""	;;
		--enable-opt)                    OPT_FLAGS="-O3 -pipe"						;;
		--enable-sendmail)               SENDMAIL=yes                               ;;
		--with-libmilter*)               LIBMILTER=$value                           ;;
		--with-libspf*)                  LIBSPF=$value                              ;;
		--with-libopendkim*)             LIBOPENDKIM=$value							;;
		*=*)																		;;
    esac
done

if [ "F$help" = "Fyes" ] ; then
	cat << END

  --help                             this message

  --prefix=PATH                      set the installation prefix
  --enable-dcc                       enable dcc support
  --enable-dkim                      enable dkim signing support
  --enable-debug                     turn on extra debug messages
  --enable-opt                       turn on extra optimization
  --enable-auth-strict               turn on strict check for authenticated users
  --enable-sendmail                  build rmilter for using with sendmail MTA
  --disable-spf                      disable spf support
  --user=USER                        set user to use
  --group=GROUP                      set group to use
  --with-libmilter=PATH              set path to libmilter
  --with-libspf=PATH                 set path to libspf2
  --with-libopendkim=PATH            set path to libopendkim
END
	exit 1
fi

if [ "F$SENDMAIL" = "Fyes" ] ; then
	CFLAGS="$CFLAGS -DSENDMAIL"
	if [ "F$USER" = "Fpostfix" ] ; then
		USER="mailnull"
		GROUP="mailnull"
	fi
fi


CFLAGS="$CFLAGS -I$PREFIX/include"
LDFLAGS="$LDFLAGS -L$PREFIX/lib"

if [ "F$LIBMILTER" != "F" ] ; then
	echo $LIBMILTER | fgrep '/lib/' > /dev/null
	if [ $? -eq 0 ] ; then
		LDFLAGS="$LDFLAGS -L$LIBMILTER"
	else
		echo $LIBMILTER | fgrep '/include/' > /dev/null
		if [ $? -eq 0 ] ; then
			CFLAGS="$CFLAGS -I$LIBMILTER"
		else
			LDFLAGS="$LDFLAGS -L$LIBMILTER/lib"
			CFLAGS="$CFLAGS -I$LIBMILTER/include"
		fi
	fi
fi
if [ "F$LIBSPF" != "F" ] ; then
	echo $LIBSPF | fgrep '/lib/' > /dev/null
	if [ $? -eq 0 ] ; then
		LDFLAGS="$LDFLAGS -L$LIBSPF"
	else
		echo $LIBSPF | fgrep '/include/' > /dev/null
		if [ $? -eq 0 ] ; then
			CFLAGS="$CFLAGS -I$LIBSPF"
		else
			LDFLAGS="$LDFLAGS -L$LIBSPF/lib"
			CFLAGS="$CFLAGS -I$LIBSPF/include"
		fi
	fi
fi

if [ "F$LIBOPENDKIM" != "F" ] ; then
	echo $LIBOPENDKIM | fgrep '/lib/' > /dev/null
	if [ $? -eq 0 ] ; then
		LDFLAGS="$LDFLAGS -L$LIBOPENDKIM"
	else
		echo $LIBOPENDKIM | fgrep '/include/' > /dev/null
		if [ $? -eq 0 ] ; then
			CFLAGS="$CFLAGS -I$LIBOPENDKIM"
		else
			LDFLAGS="$LDFLAGS -L$LIBOPENDKIM/lib"
			CFLAGS="$CFLAGS -I$LIBOPENDKIM/include"
		fi
	fi
fi

echo "Starting configure for rmilter" >config.log
echo $0 $@ >> config.log

check_os
check_compiler
check_make
check_lex
check_yacc

check_lib "--search=/usr/lib/libmilter:${PREFIX}/lib:${PREFIX}/libmilter" "milter" "libmilter/mfapi.h"
if [ $? -eq 1 ] ; then
	echo "Libmilter not found, check config.log for details"
	exit 1
fi

if [ "F$spf" = "Fno" ] ; then
	CFLAGS="$CFLAGS -DDISABLE_SPF"
else
	SOURCES="$SOURCES spf.c"
	check_lib "--search=/usr/lib/libspf2:${PREFIX}/lib:${PREFIX}/libspf2" "spf2" "netinet/in.h" "spf2/spf.h"
	if [ $? -eq 1 ] ; then
		echo "Libspf2 not found, check config.log for details"
		exit 1
	fi
fi

if [ "F$dkim" = "Fyes" ] ; then
	CFLAGS="$CFLAGS -DENABLE_DKIM"
	check_lib "--search=/usr/lib/libopendkim:${PREFIX}/lib:${PREFIX}/libopendkim" "opendkim" "netinet/in.h" "opendkim/dkim.h"
	if [ $? -eq 1 ] ; then
		echo "Libopendkim not found, check config.log for details"
		exit 1
	fi
fi

check_lib "m"
check_lib "pcre"
if [ $? -eq 1 ] ; then
	# Try to use pcre-config
	PCRE_CONFIG=`which pcre-config`
	if [ F"$PCRE_CONFIG" = "F" ] ; then
		echo "Libpcre is not found and pcre-config binary is not found as well. Please install libcpcre."
		exit 1
	fi
	PCRE_CFLAGS=`$PCRE_CONFIG --cflags`
	PCRE_LIBS=`$PCRE_CONFIG --libs`
	CFLAGS="$CFLAGS $PCRE_CFLAGS"
	LIBS="$LIBS $PCRE_LIBS"
fi
  
check_lib "md"
if [ $? -eq 1 ] ; then
	cp $COMPAT_DIR/md5.c .
	cp $COMPAT_DIR/md5.h .
	SOURCES="$SOURCES md5.c"
	CFLAGS="$CFLAGS -DHAVE_OWN_MD5"
	DEPS="$DEPS md5.h"
fi

check_function "strlcpy" "string.h"
if [ $? -eq 1 ] ; then
	cp $COMPAT_DIR/strlcpy.c .
	cp $COMPAT_DIR/strlcpy.h .
	SOURCES="$SOURCES strlcpy.c"
	CFLAGS="$CFLAGS -DHAVE_STRLCPY_H"
	DEPS="$DEPS strlcpy.h"
fi
check_function "bzero" "string.h"
check_function "srandomdev"
if [ $? -eq 0 ] ; then
	CFLAGS="$CFLAGS -DHAVE_SRANDOMDEV"
fi

check_include "endian.h"
check_include "machine/endian.h"
check_include "sys/time.h"
check_include "time.h"
check_include "stdint.h"
if [ $? -eq 1 ] ; then
	check_include "inttypes.h"
fi
check_include "stdbool.h"
check_include "strlcpy.h"
check_include "md5.h"
check_include "sys/queue.h"
if [ $? -eq 1 ] ; then 
	cp $COMPAT_DIR/queue.h .
	DEPS="$DEPS queue.h"
fi
check_macro "SLIST_FOREACH_SAFE" "sys/queue.h"
if [ $? -eq 1 ] ; then 
	cp $COMPAT_DIR/queue.h .
	CFLAGS="$CFLAGS -DOWN_QUEUE_H"
	DEPS="$DEPS queue.h"
fi

check_macro "PATH_MAX" "limits.h"
if [ $? -eq 1 ] ; then
	check_macro "MAXPATHLEN" "sys/param.h"
	if [ $? -eq 1 ] ; then
		CFLAGS="$CFLAGS -DHAVE_MAXPATHLEN -DMAXPATHLEN=4096"
	else
		CFLAGS="$CFLAGS -DHAVE_MAXPATHLEN"
	fi
else
	CFLAGS="$CFLAGS -DHAVE_PATH_MAX"
fi

if [ "F$dcc" = "Fyes" ] ; then
	CFLAGS="$CFLAGS -I./dcc-dccd-${DCC_VER}/include -DHAVE_DCC"
	LDFLAGS="$LDFLAGS -Ldcc-dccd-${DCC_VER}/dcclib"
	LIBS="$LIBS -ldcc"
	TARGETS="dcc $TARGETS"
fi

write_result