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 ${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 ${LEX_OUTPUT} ${YACC_OUTPUT}"
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=""
}

check_compiler()
{
	if [ "F${CC}" != "F" ] ; then 
		GCC=${CC}
	fi
	echo -n "Testing for ${GCC}: "
	check_cache "compiler" "${GCC}"
	if [ $? -eq 0 ] ; then
		GCC=$CACHED
		echo "found(cached) -> $GCC"
		return 0
	fi

	GCC=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which ${GCC}`
	if [ $? -eq 0 -a -x $GCC ] ; then
		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
	MAKE=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which make`
	if [ -x $MAKE ] ; then
		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

	LEX=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which lex`
	if [ -x $LEX ] ; then
		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

	YACC=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which yacc`
	echo -n "Testing for yacc: "
	if [ -x $YACC ] ; then
		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
	UTIL=`PATH="$PATH:$PREFIX/bin:$LOCALBASE/bin" which $1`
	if [ -x $UTIL ] ; then
		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 -a -n $2 ] ; do 
		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_lib()
{
	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
		LIBS="$LIBS -l$LIB"
		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) { return 0; }" >> autotest.c
	# Now try to search for a library
	_found="no"
	_add_path=""
	for _path in "" "$PREFIX/lib/lib$LIB" "$PREFIX/lib/$LIB" ; do
		if [ "F$_path" != "F" ] ; then  
			echo "$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -L$_path -l$LIB $PTHREAD_LDFLAGS autotest.c" >>config.log
			$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -L$_path -l$LIB $PTHREAD_LDFLAGS autotest.c >>config.log 2>&1
		else
			echo "$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -l$LIB $PTHREAD_LDFLAGS autotest.c" >>config.log
			$GCC $CFLAGS $PTHREAD_CFLAGS -o autotest $LDFLAGS $LIBS -l$LIB $PTHREAD_LDFLAGS autotest.c >>config.log 2>&1
		fi
		if [ $? -eq 0 ] ; then
			_found="yes"
			if [ "F$_path" != "F" ] ; then
				_add_path=$_path
			fi
			break
		fi
	done
	if [ $_found = "yes" ] ; then 
		echo "found"
		if [ "F$_add_path" != "F" ] ; then 
			LIBS="$LIBS -L$_add_path -l$LIB"
		else
			LIBS="$LIBS -l$LIB"
		fi
		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
}

check_os()
{
	_OS=`uname -s`
	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} -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-debug)					 CFLAGS="$CFLAGS -DWITH_DEBUG" OPT_FLAGS=""	;;
		--enable-opt)                    OPT_FLAGS="-O3 -pipe"						;;
		--enable-sendmail)               SENDMAIL=yes                               ;;
		*=*)																		;;
		*)
            echo "$0: error: invalid option \"$option\""
            exit 1
        ;;
    esac
done

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

  --help                             this message

  --prefix=PATH                      set the installation prefix
  --enable-dcc                       enable dcc 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
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"

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

check_compiler
check_make
check_lex
check_yacc
check_os

check_lib "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 "spf2" "netinet/in.h" "spf2/spf.h"
	if [ $? -eq 1 ] ; then
		echo "Libspf2 not found, check config.log for details"
		exit 1
	fi
fi

check_lib "m"
check_lib "pcre"
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

check_group $GROUP
if [ $? -ne 0 ] ; then 
	TARGETS="$TARGETS creategroup"
fi
check_user $USER
if [ $? -ne 0 ] ; then 
	TARGETS="$TARGETS createuser"
fi
write_result