[BACK]Return to configure.ac CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/configure.ac between versions 1.1.1.2 and 1.1.1.4

version 1.1.1.2, 2013/10/14 07:51:14 version 1.1.1.4, 2021/03/17 00:32:36
Line 1 Line 1
 dnl Process this file with autoconf to produce a configure script.  dnl Process this file with autoconf to produce a configure script.
   
AC_INIT()AC_INIT([rsync],[ ],[https://rsync.samba.org/bug-tracking.html])
 
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([byteorder.h])  AC_CONFIG_SRCDIR([byteorder.h])
 AC_CONFIG_HEADER(config.h)  AC_CONFIG_HEADER(config.h)
AC_PREREQ(2.59)AC_PREREQ([2.69])
   
RSYNC_VERSION=3.1.0PACKAGE_VERSION=`sed 's/.*"\(.*\)".*/\1/' <$srcdir/version.h`
AC_SUBST(RSYNC_VERSION) 
AC_MSG_NOTICE([Configuring rsync $RSYNC_VERSION]) 
   
AC_DEFINE_UNQUOTED(RSYNC_VERSION, ["$RSYNC_VERSION"], [rsync release version])AC_MSG_NOTICE([Configuring rsync $PACKAGE_VERSION])
   
 LDFLAGS=${LDFLAGS-""}  LDFLAGS=${LDFLAGS-""}
   
 AC_CANONICAL_HOST  AC_CANONICAL_HOST
   
   dnl define the directory for replacement function since AC_LIBOBJ does not
   dnl officially support subdirs and fails with automake
   AC_CONFIG_LIBOBJ_DIR([lib])
   
 # We must decide this before testing the compiler.  # We must decide this before testing the compiler.
   
 # Please allow this to default to yes, so that your users have more  # Please allow this to default to yes, so that your users have more
Line 22  AC_CANONICAL_HOST Line 26  AC_CANONICAL_HOST
   
 AC_MSG_CHECKING([whether to include debugging symbols])  AC_MSG_CHECKING([whether to include debugging symbols])
 AC_ARG_ENABLE(debug,  AC_ARG_ENABLE(debug,
        AC_HELP_STRING([--disable-debug],        AS_HELP_STRING([--disable-debug],[disable debugging symbols and features]))
                [disable debugging symbols and features])) 
   
 if test x"$enable_debug" = x"no"; then  if test x"$enable_debug" = x"no"; then
     AC_MSG_RESULT(no)      AC_MSG_RESULT(no)
Line 37  fi Line 40  fi
 dnl Checks for programs.  dnl Checks for programs.
 AC_PROG_CC  AC_PROG_CC
 AC_PROG_CPP  AC_PROG_CPP
   AC_PROG_CXX
   AC_PROG_AWK
 AC_PROG_EGREP  AC_PROG_EGREP
 AC_PROG_INSTALL  AC_PROG_INSTALL
 AC_PROG_MKDIR_P  AC_PROG_MKDIR_P
 AC_PROG_CC_STDC  AC_PROG_CC_STDC
 AC_SUBST(SHELL)  AC_SUBST(SHELL)
   AC_PATH_PROG([PERL], [perl])
   AC_PATH_PROG([PYTHON3], [python3])
   
 AC_DEFINE([_GNU_SOURCE], 1,  AC_DEFINE([_GNU_SOURCE], 1,
           [Define _GNU_SOURCE so that we get all necessary prototypes])            [Define _GNU_SOURCE so that we get all necessary prototypes])
Line 50  if test x"$ac_cv_prog_cc_stdc" = x"no"; then Line 57  if test x"$ac_cv_prog_cc_stdc" = x"no"; then
         AC_MSG_WARN([rsync requires an ANSI C compiler and you do not seem to have one])          AC_MSG_WARN([rsync requires an ANSI C compiler and you do not seem to have one])
 fi  fi
   
   no_lib=''
   err_msg=''
   nl='
   '
   
 AC_ARG_ENABLE(profile,  AC_ARG_ENABLE(profile,
        AC_HELP_STRING([--enable-profile],        AS_HELP_STRING([--enable-profile],[turn on CPU profiling]))
                [turn on CPU profiling])) 
 if test x"$enable_profile" = x"yes"; then  if test x"$enable_profile" = x"yes"; then
         CFLAGS="$CFLAGS -pg"          CFLAGS="$CFLAGS -pg"
 fi  fi
   
   AC_MSG_CHECKING([if md2man can create man pages])
   if test x"$ac_cv_path_PYTHON3" = x; then
       AC_MSG_RESULT(no - python3 not found)
       md2man_works=no
   else
       md2man_out=`"$srcdir/md2man" --test "$srcdir/rsync-ssl.1.md" 2>&1`
       if test $? = 0; then
           AC_MSG_RESULT(yes)
           md2man_works=yes
       else
           AC_MSG_RESULT(no)
           md2man_works=no
           echo "$md2man_out"
       fi
   fi
   
   AC_MSG_CHECKING([if we require man-page building])
   AC_ARG_ENABLE([md2man],
           AS_HELP_STRING([--disable-md2man],[disable md2man for man page creation]))
   if test x"$enable_md2man" != x"no"; then
       if test -f "$srcdir/rsync.1"; then
           AC_MSG_RESULT(optional)
       else
           AC_MSG_RESULT(required)
           if test x"$md2man_works" = x"no"; then
               err_msg="$err_msg$nl- You need python3 and either the cmarkgfm OR commonmark python3 lib in order"
               err_msg="$err_msg$nl  to build man pages based on the git source (man pages are included in the"
               err_msg="$err_msg$nl  official release tar files)."
               no_lib="$no_lib md2man"
           fi
       fi
       MAKE_MAN=man
   else
       AC_MSG_RESULT(no)
       MAKE_MAN=''
   fi
   
 # Specifically, this turns on panic_action handling.  # Specifically, this turns on panic_action handling.
 AC_ARG_ENABLE(maintainer-mode,  AC_ARG_ENABLE(maintainer-mode,
        AC_HELP_STRING([--enable-maintainer-mode],        AS_HELP_STRING([--enable-maintainer-mode],[turn on extra debug features]))
                [turn on extra debug features])) 
 if test x"$enable_maintainer_mode" = x"yes"; then  if test x"$enable_maintainer_mode" = x"yes"; then
         CFLAGS="$CFLAGS -DMAINTAINER_MODE"          CFLAGS="$CFLAGS -DMAINTAINER_MODE"
 fi  fi
   
   
 # This is needed for our included version of popt.  Kind of silly, but  # This is needed for our included version of popt.  Kind of silly, but
 # I don't want our version too far out of sync.  # I don't want our version too far out of sync.
 CFLAGS="$CFLAGS -DHAVE_CONFIG_H"  CFLAGS="$CFLAGS -DHAVE_CONFIG_H"
Line 77  if test x"$GCC" = x"yes"; then Line 122  if test x"$GCC" = x"yes"; then
 fi  fi
   
 AC_ARG_WITH(included-popt,  AC_ARG_WITH(included-popt,
        AC_HELP_STRING([--with-included-popt], [use bundled popt library, not from system]))        AS_HELP_STRING([--with-included-popt],[use bundled popt library, not from system]))
   
 AC_ARG_WITH(included-zlib,  AC_ARG_WITH(included-zlib,
        AC_HELP_STRING([--with-included-zlib], [use bundled zlib library, not from system]))        AS_HELP_STRING([--with-included-zlib],[use bundled zlib library, not from system]))
   
 AC_ARG_WITH(protected-args,  AC_ARG_WITH(protected-args,
        AC_HELP_STRING([--with-protected-args], [make --protected-args option the default]))        AS_HELP_STRING([--with-protected-args],[make --protected-args option the default]))
 if test x"$with_protected_args" = x"yes"; then  if test x"$with_protected_args" = x"yes"; then
         AC_DEFINE_UNQUOTED(RSYNC_USE_PROTECTED_ARGS, 1, [Define to 1 if --protected-args should be the default])          AC_DEFINE_UNQUOTED(RSYNC_USE_PROTECTED_ARGS, 1, [Define to 1 if --protected-args should be the default])
 fi  fi
   
 AC_ARG_WITH(rsync-path,  AC_ARG_WITH(rsync-path,
        AC_HELP_STRING([--with-rsync-path=PATH], [set default --rsync-path to PATH (default: rsync)]),        AS_HELP_STRING([--with-rsync-path=PATH],[set default --rsync-path to PATH (default: rsync)]),
         [ RSYNC_PATH="$with_rsync_path" ],          [ RSYNC_PATH="$with_rsync_path" ],
         [ RSYNC_PATH="rsync" ])          [ RSYNC_PATH="rsync" ])
   
 AC_DEFINE_UNQUOTED(RSYNC_PATH, "$RSYNC_PATH", [location of rsync on remote machine])  AC_DEFINE_UNQUOTED(RSYNC_PATH, "$RSYNC_PATH", [location of rsync on remote machine])
   
 AC_ARG_WITH(rsyncd-conf,  AC_ARG_WITH(rsyncd-conf,
        AC_HELP_STRING([--with-rsyncd-conf=PATH], [set configuration file for rsync server to PATH (default: /etc/rsyncd.conf)]),        AS_HELP_STRING([--with-rsyncd-conf=PATH],[set configuration file for rsync server to PATH (default: /etc/rsyncd.conf)]),
         [ if test ! -z "$with_rsyncd_conf" ; then          [ if test ! -z "$with_rsyncd_conf" ; then
                 case $with_rsyncd_conf in                  case $with_rsyncd_conf in
                         yes|no)                          yes|no)
Line 117  AC_ARG_WITH(rsyncd-conf, Line 162  AC_ARG_WITH(rsyncd-conf,
 AC_DEFINE_UNQUOTED(RSYNCD_SYSCONF, "$RSYNCD_SYSCONF", [location of configuration file for rsync server])  AC_DEFINE_UNQUOTED(RSYNCD_SYSCONF, "$RSYNCD_SYSCONF", [location of configuration file for rsync server])
   
 AC_ARG_WITH(rsh,  AC_ARG_WITH(rsh,
        AC_HELP_STRING([--with-rsh=CMD], [set remote shell command to CMD (default: ssh)]))        AS_HELP_STRING([--with-rsh=CMD],[set remote shell command to CMD (default: ssh)]))
   
 AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)  AC_CHECK_PROG(HAVE_REMSH, remsh, 1, 0)
 if test x$HAVE_REMSH = x1; then  if test x$HAVE_REMSH = x1; then
Line 131  else Line 176  else
 fi  fi
 AC_DEFINE_UNQUOTED(RSYNC_RSH, "$RSYNC_RSH", [default -e command])  AC_DEFINE_UNQUOTED(RSYNC_RSH, "$RSYNC_RSH", [default -e command])
   
 AC_CHECK_PROG(HAVE_YODL2MAN, yodl2man, 1, 0)  
 if test x$HAVE_YODL2MAN = x1; then  
     MAKE_MAN=man  
 else  
     MAKE_MAN=man-copy  
 fi  
   
 # Some programs on solaris are only found in /usr/xpg4/bin (or work better than others versions).  # Some programs on solaris are only found in /usr/xpg4/bin (or work better than others versions).
 AC_PATH_PROG(SHELL_PATH, sh, /bin/sh, [/usr/xpg4/bin$PATH_SEPARATOR$PATH])  AC_PATH_PROG(SHELL_PATH, sh, /bin/sh, [/usr/xpg4/bin$PATH_SEPARATOR$PATH])
 AC_PATH_PROG(FAKEROOT_PATH, fakeroot, /usr/bin/fakeroot, [/usr/xpg4/bin$PATH_SEPARATOR$PATH])  AC_PATH_PROG(FAKEROOT_PATH, fakeroot, /usr/bin/fakeroot, [/usr/xpg4/bin$PATH_SEPARATOR$PATH])
   
 AC_ARG_WITH(nobody-group,  AC_ARG_WITH(nobody-group,
    AC_HELP_STRING([--with-nobody-group=GROUP],    AS_HELP_STRING([--with-nobody-group=GROUP],[set the default unprivileged group (default nobody or nogroup)]),
                   [set the default unprivileged group (default nobody or nogroup)]), 
     [ NOBODY_GROUP="$with_nobody_group" ])      [ NOBODY_GROUP="$with_nobody_group" ])
   
 if test x"$with_nobody_group" = x; then  if test x"$with_nobody_group" = x; then
Line 162  fi Line 199  fi
 AC_DEFINE_UNQUOTED(NOBODY_USER, "nobody", [unprivileged user--e.g. nobody])  AC_DEFINE_UNQUOTED(NOBODY_USER, "nobody", [unprivileged user--e.g. nobody])
 AC_DEFINE_UNQUOTED(NOBODY_GROUP, "$NOBODY_GROUP", [unprivileged group for unprivileged user])  AC_DEFINE_UNQUOTED(NOBODY_GROUP, "$NOBODY_GROUP", [unprivileged group for unprivileged user])
   
   # SIMD optimizations
   SIMD=
   
   AC_MSG_CHECKING([whether to enable SIMD optimizations])
   AC_ARG_ENABLE(simd,
       AS_HELP_STRING([--disable-simd],[disable SIMD optimizations (requires c++)]))
   
   # Clag is crashing with -g -O2, so we'll get rid of -g for now.
   CXXFLAGS=`echo "$CXXFLAGS" | sed 's/-g //'`
   
   if test x"$enable_simd" != x"no"; then
       # For x86-64 SIMD, g++ >=5 or clang++ >=7 is required
       if test x"$build_cpu" = x"x86_64"; then
           AC_LANG(C++)
           AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>
   #include <immintrin.h>
   __attribute__ ((target("default"))) int test_ssse3(int x) { return x; }
   __attribute__ ((target("default"))) int test_sse2(int x) { return x; }
   __attribute__ ((target("default"))) int test_avx2(int x) { return x; }
   __attribute__ ((target("ssse3"))) int test_ssse3(int x) { return x; }
   __attribute__ ((target("sse2"))) int test_sse2(int x) { return x; }
   __attribute__ ((target("avx2"))) int test_avx2(int x) { return x; }
   typedef long long __m128i_u __attribute__((__vector_size__(16), __may_alias__, __aligned__(1)));
   typedef long long __m256i_u __attribute__((__vector_size__(32), __may_alias__, __aligned__(1)));
   __attribute__ ((target("default"))) void more_testing(char* buf, int len) { }
   __attribute__ ((target("ssse3"))) void more_testing(char* buf, int len)
   {
       int i;
       for (i = 0; i < (len-32); i+=32) {
           __m128i in8_1, in8_2;
           in8_1 = _mm_lddqu_si128((__m128i_u*)&buf[i]);
           in8_2 = _mm_lddqu_si128((__m128i_u*)&buf[i + 16]);
       }
   }
   ]], [[if (test_ssse3(42) != 42 || test_sse2(42) != 42 || test_avx2(42) != 42) exit(1);]])],[CXX_OK=yes],[CXX_OK=no])
           AC_LANG(C)
           if test x"$CXX_OK" = x"yes"; then
               # AC_MSG_RESULT() is called below.
               SIMD="x86_64"
           elif test x"$enable_simd" = x"yes"; then
               AC_MSG_RESULT(error)
               AC_MSG_ERROR(The SIMD compilation test failed.
   Omit --enable-simd to continue without it.)
           fi
       elif test x"$enable_simd" = x"yes"; then
           AC_MSG_RESULT(unavailable)
           AC_MSG_ERROR(The SIMD optimizations are currently x86_64 only.
   Omit --enable-simd to continue without it.)
       fi
   fi
   
   if test x"$SIMD" != x""; then
       AC_MSG_RESULT([yes ($SIMD)])
       AC_DEFINE(HAVE_SIMD, 1, [Define to 1 to enable SIMD optimizations])
       SIMD='$(SIMD_'"$SIMD)"
       # We only use c++ for its target attribute dispatching, disable unneeded bulky features
       CXXFLAGS="$CXXFLAGS -fno-exceptions -fno-rtti"
       # Apple often has "g++" as a symlink for clang. Try to find out the truth.
       CXX_VERSION=`$CXX --version 2>/dev/null | head -n 2`
       case "$CXX_VERSION" in
       *clang*) CXXFLAGS="$CXXFLAGS -fno-slp-vectorize" ;; # avoid a performance hit
       esac
   else
       AC_MSG_RESULT(no)
   fi
   
   AC_SUBST(SIMD)
   
   AC_MSG_CHECKING([if assembler accepts noexecstack])
   OLD_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -Wa,--noexecstack"
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[return 0;]])],
   [ NOEXECSTACK='-Wa,--noexecstack' ; AC_MSG_RESULT(yes) ],
   [ NOEXECSTACK='' ; AC_MSG_RESULT(no) ])
   CFLAGS="$OLD_CFLAGS"
   AC_SUBST(NOEXECSTACK)
   
   ASM=
   
   AC_MSG_CHECKING([whether to enable ASM optimizations])
   AC_ARG_ENABLE(asm,
       AS_HELP_STRING([--disable-asm],[disable ASM optimizations]))
   
   if test x"$enable_asm" != x"no"; then
       if test x"$build_cpu" = x"x86_64"; then
           ASM="$build_cpu"
       elif test x"$enable_asm" = x"yes"; then
           AC_MSG_RESULT(unavailable)
           AC_MSG_ERROR(The ASM optimizations are currently x86_64 only.
   Omit --enable-asm to continue without it.)
       fi
   fi
   
   if test x"$ASM" != x""; then
       AC_MSG_RESULT([yes ($ASM)])
       AC_DEFINE(HAVE_ASM, 1, [Define to 1 to enable ASM optimizations])
       ASM='$(ASM_'"$ASM)"
   else
       AC_MSG_RESULT(no)
   fi
   
   AC_SUBST(ASM)
   
 # arrgh. libc in some old debian version screwed up the largefile  # arrgh. libc in some old debian version screwed up the largefile
 # stuff, getting byte range locking wrong  # stuff, getting byte range locking wrong
 AC_CACHE_CHECK([for broken largefile support],rsync_cv_HAVE_BROKEN_LARGEFILE,[  AC_CACHE_CHECK([for broken largefile support],rsync_cv_HAVE_BROKEN_LARGEFILE,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #define _FILE_OFFSET_BITS 64  #define _FILE_OFFSET_BITS 64
 #include <stdio.h>  #include <stdio.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/wait.h>  #include <sys/wait.h>
   #if HAVE_UNISTD_H
   #include <unistd.h>
   #endif
   
 int main(void)  int main(void)
 {  {
Line 195  int main(void) Line 338  int main(void)
         }          }
         wait(&status);          wait(&status);
         unlink(tpl);          unlink(tpl);
        exit(WEXITSTATUS(status));        return WEXITSTATUS(status);
 }  }
],]])],[rsync_cv_HAVE_BROKEN_LARGEFILE=yes],[rsync_cv_HAVE_BROKEN_LARGEFILE=no],[rsync_cv_HAVE_BROKEN_LARGEFILE=cross])])
rsync_cv_HAVE_BROKEN_LARGEFILE=yes,rsync_cv_HAVE_BROKEN_LARGEFILE=no,rsync_cv_HAVE_BROKEN_LARGEFILE=cross)]) 
 if test x"$rsync_cv_HAVE_BROKEN_LARGEFILE" != x"yes"; then  if test x"$rsync_cv_HAVE_BROKEN_LARGEFILE" != x"yes"; then
    AC_SYS_LARGEFILE     AC_SYS_LARGEFILE
 fi  fi
Line 208  ipv6lib=none Line 350  ipv6lib=none
 ipv6trylibc=yes  ipv6trylibc=yes
   
 AC_ARG_ENABLE(ipv6,  AC_ARG_ENABLE(ipv6,
        AC_HELP_STRING([--disable-ipv6],        AS_HELP_STRING([--disable-ipv6],[turn off IPv6 support]))
                [do not even try to use IPv6])) 
 if test x"$enable_ipv6" != x"no"; then  if test x"$enable_ipv6" != x"no"; then
         AC_MSG_CHECKING([ipv6 stack type])          AC_MSG_CHECKING([ipv6 stack type])
        for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta cygwin; do        for i in inria kame linux-glibc linux-inet6 solaris toshiba v6d zeta cygwin TANDEM; do
                 case $i in                  case $i in
                 inria)                  inria)
                         # http://www.kame.net/                          # http://www.kame.net/
Line 308  yes Line 449  yes
                                 [ipv6type=$i;                                  [ipv6type=$i;
                                 AC_DEFINE(INET6, 1, [true if you have IPv6])])                                  AC_DEFINE(INET6, 1, [true if you have IPv6])])
                         ;;                          ;;
                   TANDEM)
                           AC_EGREP_CPP(yes, [
   #include <netinet/ip6.h>
   #ifdef __TANDEM
   yes
   #endif],
                                   [ipv6type=$i;
                                   AC_DEFINE(INET6, 1, [true if you have IPv6])])
                           ;;
                 esac                  esac
                 if test "$ipv6type" != "unknown"; then                  if test "$ipv6type" != "unknown"; then
                         break                          break
Line 320  fi Line 470  fi
   
 dnl Do you want to disable use of locale functions  dnl Do you want to disable use of locale functions
 AC_ARG_ENABLE([locale],  AC_ARG_ENABLE([locale],
        AC_HELP_STRING([--disable-locale],        AS_HELP_STRING([--disable-locale],[disable locale features]))
                [disable locale features])) 
 AH_TEMPLATE([CONFIG_LOCALE],  AH_TEMPLATE([CONFIG_LOCALE],
 [Undefine if you do not want locale features.  By default this is defined.])  [Undefine if you do not want locale features.  By default this is defined.])
 if test x"$enable_locale" != x"no"; then  if test x"$enable_locale" != x"no"; then
Line 345  AC_CHECK_HEADERS(sys/fcntl.h sys/select.h fcntl.h sys/ Line 494  AC_CHECK_HEADERS(sys/fcntl.h sys/select.h fcntl.h sys/
     unistd.h utime.h grp.h compat.h sys/param.h ctype.h sys/wait.h \      unistd.h utime.h grp.h compat.h sys/param.h ctype.h sys/wait.h \
     sys/ioctl.h sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h \      sys/ioctl.h sys/filio.h string.h stdlib.h sys/socket.h sys/mode.h \
     sys/un.h sys/attr.h mcheck.h arpa/inet.h arpa/nameser.h locale.h \      sys/un.h sys/attr.h mcheck.h arpa/inet.h arpa/nameser.h locale.h \
       mysql/mysql.h sqlite3.h \
     netdb.h malloc.h float.h limits.h iconv.h libcharset.h langinfo.h \      netdb.h malloc.h float.h limits.h iconv.h libcharset.h langinfo.h \
    sys/acl.h acl/libacl.h attr/xattr.h sys/xattr.h sys/extattr.h \    sys/acl.h acl/libacl.h attr/xattr.h sys/xattr.h sys/extattr.h dl.h \
     popt.h popt/popt.h linux/falloc.h netinet/in_systm.h netinet/ip.h \      popt.h popt/popt.h linux/falloc.h netinet/in_systm.h netinet/ip.h \
    zlib.h)    zlib.h xxhash.h openssl/md4.h openssl/md5.h zstd.h lz4.h sys/file.h)
AC_HEADER_MAJORAC_HEADER_MAJOR_FIXED
   
   AC_MSG_CHECKING([whether to enable use of openssl crypto library])
   AC_ARG_ENABLE([openssl],
           AS_HELP_STRING([--disable-openssl],[disable openssl crypto library]))
   AH_TEMPLATE([USE_OPENSSL],
   [Undefine if you do not want to use openssl crypto library.  By default this is defined.])
   if test x"$enable_openssl" != x"no"; then
       if test x"$ac_cv_header_openssl_md4_h" = x"yes" && test x"$ac_cv_header_openssl_md5_h" = x"yes"; then
         AC_MSG_RESULT(yes)
         AC_SEARCH_LIBS(MD5_Init, crypto,
             [AC_DEFINE(USE_OPENSSL)],
             [err_msg="$err_msg$nl- Failed to find MD5_Init function in openssl crypto lib.";
              no_lib="$no_lib openssl"])
       else
           AC_MSG_RESULT(no)
           err_msg="$err_msg$nl- Failed to find openssl/md4.h and openssl/md5.h for openssl crypto lib support."
           no_lib="$no_lib openssl"
       fi
   else
       AC_MSG_RESULT(no)
   fi
   
   AC_MSG_CHECKING([whether to enable xxhash checksum support])
   AC_ARG_ENABLE([xxhash],
           AS_HELP_STRING([--disable-xxhash],[disable xxhash checksums]))
   AH_TEMPLATE([SUPPORT_XXHASH],
   [Undefine if you do not want xxhash checksums.  By default this is defined.])
   if test x"$enable_xxhash" != x"no"; then
       if test x"$ac_cv_header_xxhash_h" = x"yes"; then
           AC_MSG_RESULT(yes)
           AC_SEARCH_LIBS(XXH64_createState, xxhash,
               [AC_DEFINE(SUPPORT_XXHASH)],
               [err_msg="$err_msg$nl- Failed to find XXH64_createState function in xxhash lib.";
                no_lib="$no_lib xxhash"])
       else
           AC_MSG_RESULT(no)
           err_msg="$err_msg$nl- Failed to find xxhash.h for xxhash checksum support.";
           no_lib="$no_lib xxhash"
       fi
   else
       AC_MSG_RESULT(no)
   fi
   
   AC_MSG_CHECKING([whether to enable zstd compression])
   AC_ARG_ENABLE([zstd],
           AC_HELP_STRING([--disable-zstd], [disable zstd compression]))
   AH_TEMPLATE([SUPPORT_ZSTD],
   [Undefine if you do not want zstd compression.  By default this is defined.])
   if test x"$enable_zstd" != x"no"; then
       if test x"$ac_cv_header_zstd_h" = x"yes"; then
           AC_MSG_RESULT(yes)
           AC_SEARCH_LIBS(ZSTD_minCLevel, zstd,
               [AC_DEFINE(SUPPORT_ZSTD)],
               [err_msg="$err_msg$nl- Failed to find ZSTD_minCLevel function in zstd lib.";
                no_lib="$no_lib zstd"])
       else
           AC_MSG_RESULT(no)
           err_msg="$err_msg$nl- Failed to find zstd.h for zstd compression support.";
           no_lib="$no_lib zstd"
       fi
   else
       AC_MSG_RESULT(no)
   fi
   
   AC_MSG_CHECKING([whether to enable LZ4 compression])
   AC_ARG_ENABLE([lz4],
           AC_HELP_STRING([--disable-lz4], [disable LZ4 compression]))
   AH_TEMPLATE([SUPPORT_LZ4],
   [Undefine if you do not want LZ4 compression.  By default this is defined.])
   if test x"$enable_lz4" != x"no"; then
       if test x"$ac_cv_header_lz4_h" = x"yes"; then
           AC_MSG_RESULT(yes)
           AC_SEARCH_LIBS(LZ4_compress_default, lz4,
               [AC_DEFINE(SUPPORT_LZ4)],
               [err_msg="$err_msg$nl- Failed to find LZ4_compress_default function in lz4 lib.";
                no_lib="$no_lib lz4"])
       else
           AC_MSG_RESULT(no)
           err_msg="$err_msg$nl- Failed to find lz4.h for lz4 compression support."
           no_lib="$no_lib lz4"
       fi
   else
       AC_MSG_RESULT(no)
   fi
   
   if test x"$no_lib" != x; then
       echo ""
       echo "Configure found the following issues:"
       echo "$err_msg"
       echo ""
       echo "See the INSTALL file for hints on how to install the missing libraries and/or"
       echo "how to generate (or fetch) man pages:"
       echo "    https://github.com/WayneD/rsync/blob/master/INSTALL.md"
       echo ""
       echo "To disable one or more features, the relevant configure options are:"
       for lib in $no_lib; do
           echo "    --disable-$lib"
       done
       echo ""
       AC_MSG_ERROR(Aborting configure run)
   fi
   
 AC_CACHE_CHECK([if makedev takes 3 args],rsync_cv_MAKEDEV_TAKES_3_ARGS,[  AC_CACHE_CHECK([if makedev takes 3 args],rsync_cv_MAKEDEV_TAKES_3_ARGS,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <sys/types.h>  #include <sys/types.h>
 #ifdef MAJOR_IN_MKDEV  #ifdef MAJOR_IN_MKDEV
 #include <sys/mkdev.h>  #include <sys/mkdev.h>
Line 367  int main(void) Line 618  int main(void)
 {  {
         dev_t dev = makedev(0, 5, 7);          dev_t dev = makedev(0, 5, 7);
         if (major(dev) != 5 || minor(dev) != 7)          if (major(dev) != 5 || minor(dev) != 7)
                exit(1);                return 1;
         return 0;          return 0;
 }  }
],]])],[rsync_cv_MAKEDEV_TAKES_3_ARGS=yes],[rsync_cv_MAKEDEV_TAKES_3_ARGS=no],[rsync_cv_MAKEDEV_TAKES_3_ARGS=no])])
rsync_cv_MAKEDEV_TAKES_3_ARGS=yes,rsync_cv_MAKEDEV_TAKES_3_ARGS=no,rsync_cv_MAKEDEV_TAKES_3_ARGS=no)]) 
 if test x"$rsync_cv_MAKEDEV_TAKES_3_ARGS" = x"yes"; then  if test x"$rsync_cv_MAKEDEV_TAKES_3_ARGS" = x"yes"; then
    AC_DEFINE(MAKEDEV_TAKES_3_ARGS, 1, [Define to 1 if makedev() takes 3 args])     AC_DEFINE(MAKEDEV_TAKES_3_ARGS, 1, [Define to 1 if makedev() takes 3 args])
 fi  fi
Line 388  AC_CHECK_SIZEOF(int64_t) Line 638  AC_CHECK_SIZEOF(int64_t)
 AC_CHECK_SIZEOF(off_t)  AC_CHECK_SIZEOF(off_t)
 AC_CHECK_SIZEOF(off64_t)  AC_CHECK_SIZEOF(off64_t)
 AC_CHECK_SIZEOF(time_t)  AC_CHECK_SIZEOF(time_t)
   AC_CHECK_SIZEOF(char*)
   
 AC_C_INLINE  AC_C_INLINE
 AC_C_LONG_DOUBLE  
   
AC_TYPE_SIGNALAC_TYPE_LONG_DOUBLE_WIDER
 ac_cv_c_long_double=$ac_cv_type_long_double_wider
 if test $ac_cv_c_long_double = yes; then
   AC_DEFINE([HAVE_LONG_DOUBLE],[1],[Define to 1 if the type `long double' works and has more range or precision than `double'.])
 fi
 
 AC_TYPE_UID_T  AC_TYPE_UID_T
 AC_CHECK_TYPES([mode_t,off_t,size_t,pid_t,id_t])  AC_CHECK_TYPES([mode_t,off_t,size_t,pid_t,id_t])
 AC_TYPE_GETGROUPS  AC_TYPE_GETGROUPS
 AC_CHECK_MEMBERS([struct stat.st_rdev,  AC_CHECK_MEMBERS([struct stat.st_rdev,
                   struct stat.st_mtimensec,                    struct stat.st_mtimensec,
                     struct stat.st_mtimespec.tv_nsec,
                   struct stat.st_mtim.tv_nsec],,,[                    struct stat.st_mtim.tv_nsec],,,[
 #ifdef HAVE_SYS_TYPES_H  #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>  #include <sys/types.h>
Line 412  AC_CHECK_MEMBERS([struct stat.st_rdev, Line 668  AC_CHECK_MEMBERS([struct stat.st_rdev,
 TYPE_SOCKLEN_T  TYPE_SOCKLEN_T
   
 AC_CACHE_CHECK([for errno in errno.h],rsync_cv_errno, [  AC_CACHE_CHECK([for errno in errno.h],rsync_cv_errno, [
    AC_TRY_COMPILE([#include <errno.h>],[int i = errno],    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], [[int i = errno]])],[rsync_cv_errno=yes],[rsync_cv_have_errno_decl=no])])
        rsync_cv_errno=yes,rsync_cv_have_errno_decl=no)]) 
 if test x"$rsync_cv_errno" = x"yes"; then  if test x"$rsync_cv_errno" = x"yes"; then
    AC_DEFINE(HAVE_ERRNO_DECL, 1, [Define to 1 if errno is declared in errno.h])     AC_DEFINE(HAVE_ERRNO_DECL, 1, [Define to 1 if errno is declared in errno.h])
 fi  fi
Line 464  AC_SEARCH_LIBS(libiconv_open, iconv) Line 719  AC_SEARCH_LIBS(libiconv_open, iconv)
   
 AC_MSG_CHECKING([for iconv declaration])  AC_MSG_CHECKING([for iconv declaration])
 AC_CACHE_VAL(am_cv_proto_iconv, [  AC_CACHE_VAL(am_cv_proto_iconv, [
    AC_TRY_COMPILE([    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 #include <stdlib.h>  #include <stdlib.h>
 #include <iconv.h>  #include <iconv.h>
 extern  extern
Line 476  size_t iconv (iconv_t cd, char * *inbuf, size_t *inbyt Line 731  size_t iconv (iconv_t cd, char * *inbuf, size_t *inbyt
 #else  #else
 size_t iconv();  size_t iconv();
 #endif  #endif
], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")]], [[]])],[am_cv_proto_iconv_arg1=""],[am_cv_proto_iconv_arg1="const"])
       am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])        am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
    am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`    am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed 's/( /(/'`
 AC_MSG_RESULT([$]{ac_t:-  AC_MSG_RESULT([$]{ac_t:-
          }[$]am_cv_proto_iconv)           }[$]am_cv_proto_iconv)
 AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,  AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
Line 486  AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg Line 741  AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg
   
 dnl AC_MSG_NOTICE([Looking in libraries: $LIBS])  dnl AC_MSG_NOTICE([Looking in libraries: $LIBS])
   
AC_CHECK_FUNCS(inet_ntop, , [AC_LIBOBJ(lib/inet_ntop)])AC_REPLACE_FUNCS([inet_ntop inet_pton])
AC_CHECK_FUNCS(inet_pton, , [AC_LIBOBJ(lib/inet_pton)]) 
   
 AC_HAVE_TYPE([struct addrinfo], [#include <netdb.h>])  AC_HAVE_TYPE([struct addrinfo], [#include <netdb.h>])
 AC_HAVE_TYPE([struct sockaddr_storage], [#include <sys/types.h>  AC_HAVE_TYPE([struct sockaddr_storage], [#include <sys/types.h>
Line 506  AC_CACHE_CHECK([whether defines needed by getaddrinfo  Line 760  AC_CACHE_CHECK([whether defines needed by getaddrinfo 
                         #endif],                          #endif],
                         rsync_cv_HAVE_GETADDR_DEFINES=yes,                          rsync_cv_HAVE_GETADDR_DEFINES=yes,
                         rsync_cv_HAVE_GETADDR_DEFINES=no)])                          rsync_cv_HAVE_GETADDR_DEFINES=no)])
if test x"$rsync_cv_HAVE_GETADDR_DEFINES" = x"yes" -a x"$ac_cv_type_struct_addrinfo" = x"yes"; thenAS_IF([test x"$rsync_cv_HAVE_GETADDR_DEFINES" = x"yes" -a x"$ac_cv_type_struct_addrinfo" = x"yes"],[
         # Tru64 UNIX has getaddrinfo() but has it renamed in libc as          # Tru64 UNIX has getaddrinfo() but has it renamed in libc as
         # something else so we must include <netdb.h> to get the          # something else so we must include <netdb.h> to get the
         # redefinition.          # redefinition.
         AC_CHECK_FUNCS(getaddrinfo, ,          AC_CHECK_FUNCS(getaddrinfo, ,
                 [AC_MSG_CHECKING([for getaddrinfo by including <netdb.h>])                  [AC_MSG_CHECKING([for getaddrinfo by including <netdb.h>])
                AC_TRY_LINK([#include <sys/types.h>                AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
                 #include <sys/socket.h>                  #include <sys/socket.h>
                #include <netdb.h>],[getaddrinfo(NULL, NULL, NULL, NULL);],                #include <netdb.h>]], [[getaddrinfo(NULL, NULL, NULL, NULL);]])],[AC_MSG_RESULT([yes])
                        [AC_MSG_RESULT([yes]) 
                         AC_DEFINE(HAVE_GETADDRINFO, 1,                          AC_DEFINE(HAVE_GETADDRINFO, 1,
                                [Define to 1 if you have the "getaddrinfo" function and required types.])],                                [Define to 1 if you have the "getaddrinfo" function and required types.])],[AC_MSG_RESULT([no])
                        [AC_MSG_RESULT([no])                        AC_LIBOBJ([getaddrinfo])])])
                        AC_LIBOBJ(lib/getaddrinfo)])])    ],[AC_LIBOBJ([getaddrinfo])])
else 
        AC_LIBOBJ(lib/getaddrinfo) 
fi 
   
 AC_CHECK_MEMBER([struct sockaddr.sa_len],  AC_CHECK_MEMBER([struct sockaddr.sa_len],
                 [ AC_DEFINE(HAVE_SOCKADDR_LEN, 1, [Do we have sockaddr.sa_len?]) ],                  [ AC_DEFINE(HAVE_SOCKADDR_LEN, 1, [Do we have sockaddr.sa_len?]) ],
Line 595  dnl AC_FUNC_MEMCMP Line 845  dnl AC_FUNC_MEMCMP
   
 AC_FUNC_UTIME_NULL  AC_FUNC_UTIME_NULL
 AC_FUNC_ALLOCA  AC_FUNC_ALLOCA
AC_CHECK_FUNCS(waitpid wait4 getcwd strdup chown chmod lchmod mknod mkfifo \AC_CHECK_FUNCS(waitpid wait4 getcwd chown chmod lchmod mknod mkfifo \
     fchmod fstat ftruncate strchr readlink link utime utimes lutimes strftime \      fchmod fstat ftruncate strchr readlink link utime utimes lutimes strftime \
       chflags getattrlist mktime innetgr linkat \
     memmove lchown vsnprintf snprintf vasprintf asprintf setsid strpbrk \      memmove lchown vsnprintf snprintf vasprintf asprintf setsid strpbrk \
     strlcat strlcpy strtol mallinfo getgroups setgroups geteuid getegid \      strlcat strlcpy strtol mallinfo getgroups setgroups geteuid getegid \
     setlocale setmode open64 lseek64 mkstemp64 mtrace va_copy __va_copy \      setlocale setmode open64 lseek64 mkstemp64 mtrace va_copy __va_copy \
     seteuid strerror putenv iconv_open locale_charset nl_langinfo getxattr \      seteuid strerror putenv iconv_open locale_charset nl_langinfo getxattr \
     extattr_get_link sigaction sigprocmask setattrlist getgrouplist \      extattr_get_link sigaction sigprocmask setattrlist getgrouplist \
    initgroups utimensat posix_fallocate attropen setvbuf)    initgroups utimensat posix_fallocate attropen setvbuf nanosleep usleep)
   
 dnl cygwin iconv.h defines iconv_open as libiconv_open  dnl cygwin iconv.h defines iconv_open as libiconv_open
 if test x"$ac_cv_func_iconv_open" != x"yes"; then  if test x"$ac_cv_func_iconv_open" != x"yes"; then
Line 612  fi Line 863  fi
 dnl Preallocation stuff (also fallocate, posix_fallocate function tests above):  dnl Preallocation stuff (also fallocate, posix_fallocate function tests above):
   
 AC_CACHE_CHECK([for useable fallocate],rsync_cv_have_fallocate,[  AC_CACHE_CHECK([for useable fallocate],rsync_cv_have_fallocate,[
AC_TRY_LINK([#include <fcntl.h>AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <fcntl.h>
#include <sys/types.h>],#include <sys/types.h>]], [[fallocate(0, 0, 0, 0);]])],[rsync_cv_have_fallocate=yes],[rsync_cv_have_fallocate=no])])
[fallocate(0, 0, 0, 0);], 
rsync_cv_have_fallocate=yes,rsync_cv_have_fallocate=no)]) 
 if test x"$rsync_cv_have_fallocate" = x"yes"; then  if test x"$rsync_cv_have_fallocate" = x"yes"; then
     AC_DEFINE(HAVE_FALLOCATE, 1, [Define to 1 if you have the fallocate function and it compiles and links without error])      AC_DEFINE(HAVE_FALLOCATE, 1, [Define to 1 if you have the fallocate function and it compiles and links without error])
 fi  fi
   
   AC_MSG_CHECKING([for FALLOC_FL_PUNCH_HOLE])
   AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
           #define _GNU_SOURCE 1
           #include <linux/falloc.h>
           #ifndef FALLOC_FL_PUNCH_HOLE
           #error FALLOC_FL_PUNCH_HOLE is missing
           #endif
       ]])], [
           AC_MSG_RESULT([yes])
           AC_DEFINE([HAVE_FALLOC_FL_PUNCH_HOLE], [1], [Define if FALLOC_FL_PUNCH_HOLE is available.])
       ], [
           AC_MSG_RESULT([no])
       ]
   )
   
   AC_MSG_CHECKING([for FALLOC_FL_ZERO_RANGE])
   AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
           #define _GNU_SOURCE 1
           #include <linux/falloc.h>
           #ifndef FALLOC_FL_ZERO_RANGE
           #error FALLOC_FL_ZERO_RANGE is missing
           #endif
       ]])], [
           AC_MSG_RESULT([yes])
           AC_DEFINE([HAVE_FALLOC_FL_ZERO_RANGE], [1], [Define if FALLOC_FL_ZERO_RANGE is available.])
       ], [
           AC_MSG_RESULT([no])
       ]
   )
   
 AC_CACHE_CHECK([for SYS_fallocate],rsync_cv_have_sys_fallocate,[  AC_CACHE_CHECK([for SYS_fallocate],rsync_cv_have_sys_fallocate,[
AC_TRY_COMPILE([#include <sys/syscall.h>AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/syscall.h>
#include <sys/types.h>],#include <unistd.h>
[syscall(SYS_fallocate, 0, 0, (loff_t)0, (loff_t)0);],#include <sys/types.h>]], [[syscall(SYS_fallocate, 0, 0, (loff_t)0, (loff_t)0);]])],[rsync_cv_have_sys_fallocate=yes],[rsync_cv_have_sys_fallocate=no])])
rsync_cv_have_sys_fallocate=yes,rsync_cv_have_sys_fallocate=no)]) 
 if test x"$rsync_cv_have_sys_fallocate" = x"yes"; then  if test x"$rsync_cv_have_sys_fallocate" = x"yes"; then
     AC_DEFINE(HAVE_SYS_FALLOCATE, 1, [Define to 1 if you have the SYS_fallocate syscall number])      AC_DEFINE(HAVE_SYS_FALLOCATE, 1, [Define to 1 if you have the SYS_fallocate syscall number])
 fi  fi
Line 651  if test $ac_cv_func_getpgrp = yes; then Line 929  if test $ac_cv_func_getpgrp = yes; then
 fi  fi
   
 AC_ARG_ENABLE(iconv-open,  AC_ARG_ENABLE(iconv-open,
    AC_HELP_STRING([--disable-iconv-open],    AS_HELP_STRING([--disable-iconv-open],[disable all use of iconv_open() function]),
            [disable all use of iconv_open() function]), 
     [], [enable_iconv_open=$ac_cv_func_iconv_open])      [], [enable_iconv_open=$ac_cv_func_iconv_open])
   
 if test x"$enable_iconv_open" != x"no"; then  if test x"$enable_iconv_open" != x"no"; then
Line 660  if test x"$enable_iconv_open" != x"no"; then Line 937  if test x"$enable_iconv_open" != x"no"; then
 fi  fi
   
 AC_ARG_ENABLE(iconv,  AC_ARG_ENABLE(iconv,
    AC_HELP_STRING([--disable-iconv],    AS_HELP_STRING([--disable-iconv],[disable rsync's --iconv option]),
            [disable rsync's --iconv option]), 
     [], [enable_iconv=$enable_iconv_open])      [], [enable_iconv=$enable_iconv_open])
 AH_TEMPLATE([ICONV_OPTION],  AH_TEMPLATE([ICONV_OPTION],
[Define if you want the --iconv option.  Specifing a value will set the[Define if you want the --iconv option.  Specifying a value will set the
 default iconv setting (a NULL means no --iconv processing by default).])  default iconv setting (a NULL means no --iconv processing by default).])
 if test x"$enable_iconv" != x"no"; then  if test x"$enable_iconv" != x"no"; then
         if test x"$enable_iconv" = x"yes"; then          if test x"$enable_iconv" = x"yes"; then
Line 675  if test x"$enable_iconv" != x"no"; then Line 951  if test x"$enable_iconv" != x"no"; then
         AC_DEFINE(UTF8_CHARSET, "UTF-8", [String to pass to iconv() for the UTF-8 charset.])          AC_DEFINE(UTF8_CHARSET, "UTF-8", [String to pass to iconv() for the UTF-8 charset.])
 fi  fi
   
   AC_ARG_WITH([gssapi],
     [AS_HELP_STRING([--with-gssapi],
       [support GSSAPI authentication @<:@default=check@:>@])],
     [],
     [with_gssapi=check])
   
   AH_TEMPLATE([GSSAPI_OPTION],
   [Define if you want GSSAPI authentication. Specifing a value will set the search path.])
   
   AS_IF([test "x$with_gssapi" != xno],
       [AC_SEARCH_LIBS([gss_import_name], gss gssapi_krb5 ,
         [AC_CHECK_HEADERS(gssapi/gssapi_generic.h gssapi/gssapi.h) ]
         [ AC_DEFINE([GSSAPI_OPTION], [1]) ]
         ,
         [if test "x$with_gssapi" = xcheck; then
           AC_MSG_FAILURE(
             [--with-gssapi was given, but test for function failed])
          fi
          ])
        ])
   
   if test x"$enable_gssapi" != x"no"; then
      AC_DEFINE(GSSAPI_OPTION, 1)
   fi
   
 AC_CACHE_CHECK([whether chown() modifies symlinks],rsync_cv_chown_modifies_symlink,[  AC_CACHE_CHECK([whether chown() modifies symlinks],rsync_cv_chown_modifies_symlink,[
  AC_TRY_RUN([  AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #if HAVE_UNISTD_H  #if HAVE_UNISTD_H
 # include <unistd.h>  # include <unistd.h>
 #endif  #endif
 #include <stdlib.h>  #include <stdlib.h>
 #include <errno.h>  #include <errno.h>
    main() {int main(void) {
         char const *dangling_symlink = "conftest.dangle";          char const *dangling_symlink = "conftest.dangle";
         unlink(dangling_symlink);          unlink(dangling_symlink);
         if (symlink("conftest.no-such", dangling_symlink) < 0) abort();          if (symlink("conftest.no-such", dangling_symlink) < 0) abort();
        if (chown(dangling_symlink, getuid(), getgid()) < 0 && errno == ENOENT) exit(1);        if (chown(dangling_symlink, getuid(), getgid()) < 0 && errno == ENOENT) return 1;
        exit(0);        return 0;
    }],    }]])],[rsync_cv_chown_modifies_symlink=yes],[rsync_cv_chown_modifies_symlink=no],[rsync_cv_chown_modifies_symlink=no])])
  rsync_cv_chown_modifies_symlink=yes,rsync_cv_chown_modifies_symlink=no,rsync_cv_chown_modifies_symlink=no)]) 
 if test $rsync_cv_chown_modifies_symlink = yes; then  if test $rsync_cv_chown_modifies_symlink = yes; then
   AC_DEFINE(CHOWN_MODIFIES_SYMLINK, 1, [Define to 1 if chown modifies symlinks.])    AC_DEFINE(CHOWN_MODIFIES_SYMLINK, 1, [Define to 1 if chown modifies symlinks.])
 fi  fi
   
 AC_CACHE_CHECK([whether link() can hard-link symlinks],rsync_cv_can_hardlink_symlink,[  AC_CACHE_CHECK([whether link() can hard-link symlinks],rsync_cv_can_hardlink_symlink,[
  AC_TRY_RUN([  AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #ifdef HAVE_FCNTL_H
 # include <fcntl.h>
 #elif defined HAVE_SYS_FCNTL_H
 # include <sys/fcntl.h>
 #endif
 #if HAVE_UNISTD_H  #if HAVE_UNISTD_H
 # include <unistd.h>  # include <unistd.h>
 #endif  #endif
 #include <stdlib.h>  #include <stdlib.h>
 #include <errno.h>  #include <errno.h>
 #define FILENAME "conftest.dangle"  #define FILENAME "conftest.dangle"
    main() {int main(void) {
         unlink(FILENAME);          unlink(FILENAME);
         if (symlink("conftest.no-such", FILENAME) < 0) abort();          if (symlink("conftest.no-such", FILENAME) < 0) abort();
        if (link(FILENAME, FILENAME "2") < 0) exit(1);        unlink(FILENAME "2");
        exit(0);#ifdef HAVE_LINKAT
    }],        if (linkat(AT_FDCWD, FILENAME, AT_FDCWD, FILENAME "2", 0) < 0) return 1;
  rsync_cv_can_hardlink_symlink=yes,rsync_cv_can_hardlink_symlink=no,rsync_cv_can_hardlink_symlink=no)])#else
         if (link(FILENAME, FILENAME "2") < 0) return 1;
 #endif
         return 0;
     }]])],[rsync_cv_can_hardlink_symlink=yes],[rsync_cv_can_hardlink_symlink=no],[rsync_cv_can_hardlink_symlink=no])])
 if test $rsync_cv_can_hardlink_symlink = yes; then  if test $rsync_cv_can_hardlink_symlink = yes; then
   AC_DEFINE(CAN_HARDLINK_SYMLINK, 1, [Define to 1 if link() can hard-link symlinks.])    AC_DEFINE(CAN_HARDLINK_SYMLINK, 1, [Define to 1 if link() can hard-link symlinks.])
 fi  fi
   
 AC_CACHE_CHECK([whether link() can hard-link special files],rsync_cv_can_hardlink_special,[  AC_CACHE_CHECK([whether link() can hard-link special files],rsync_cv_can_hardlink_special,[
  AC_TRY_RUN([  AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #if HAVE_UNISTD_H  #if HAVE_UNISTD_H
 # include <unistd.h>  # include <unistd.h>
 #endif  #endif
   #ifdef HAVE_SYS_STAT_H
   #include <sys/stat.h>
   #endif
 #include <stdlib.h>  #include <stdlib.h>
 #include <errno.h>  #include <errno.h>
 #define FILENAME "conftest.fifi"  #define FILENAME "conftest.fifi"
    main() {int main(void) {
         unlink(FILENAME);          unlink(FILENAME);
         if (mkfifo(FILENAME, 0777) < 0) abort();          if (mkfifo(FILENAME, 0777) < 0) abort();
        if (link(FILENAME, FILENAME "2") < 0) exit(1);        unlink(FILENAME "2");
        exit(0);        if (link(FILENAME, FILENAME "2") < 0) return 1;
    }],        return 0;
  rsync_cv_can_hardlink_special=yes,rsync_cv_can_hardlink_special=no,rsync_cv_can_hardlink_special=no)])    }]])],[rsync_cv_can_hardlink_special=yes],[rsync_cv_can_hardlink_special=no],[rsync_cv_can_hardlink_special=no])])
 if test $rsync_cv_can_hardlink_special = yes; then  if test $rsync_cv_can_hardlink_special = yes; then
     AC_DEFINE(CAN_HARDLINK_SPECIAL, 1, [Define to 1 if link() can hard-link special files.])      AC_DEFINE(CAN_HARDLINK_SPECIAL, 1, [Define to 1 if link() can hard-link special files.])
 fi  fi
   
   AC_ARG_ENABLE(slp, [  --disable-slp           turn off SLP support, defaults to on])
   AC_ARG_WITH(openslp-libs, [  --with-openslp-libs     set directory for OpenSLP library],
       LDFLAGS="-L$withval $LDFLAGS"
       DSOFLAGS="-L$withval $DSOFLAGS",)
   AC_ARG_WITH(openslp-includes, [  --with-openslp-includes set directory for OpenSLP includes],
       CFLAGS="-I$withval $CFLAGS"
       CXXFLAGS="-I$withval $CXXFLAGS"
       CPPFLAGS="-I$withval $CPPFLAGS",)
   
   LIBSLP=""
   SLPOBJ=""
   
   if test x$enable_slp != xno; then
       AC_CHECK_HEADER(slp.h,
           AC_CHECK_LIB(slp, SLPOpen,
               AC_DEFINE(HAVE_LIBSLP, 1, [Define to 1 for SLP support])
               SLPOBJ="srvreg.o srvloc.o"
               LIBSLP="-lslp"))
   fi
   
   AC_SUBST(LIBSLP)
   AC_SUBST(SLPOBJ)
   
 AC_CACHE_CHECK([for working socketpair],rsync_cv_HAVE_SOCKETPAIR,[  AC_CACHE_CHECK([for working socketpair],rsync_cv_HAVE_SOCKETPAIR,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/socket.h>  #include <sys/socket.h>
   
main() {int main(void) {
        int fd[2];         int fd[2];
#ifdef __CYGWIN__       return (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1) ? 0 : 1;
       exit(1);}]])],[rsync_cv_HAVE_SOCKETPAIR=yes],[rsync_cv_HAVE_SOCKETPAIR=no],[rsync_cv_HAVE_SOCKETPAIR=cross])])
#else 
       exit((socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1) ? 0 : 1); 
#endif 
}], 
rsync_cv_HAVE_SOCKETPAIR=yes,rsync_cv_HAVE_SOCKETPAIR=no,rsync_cv_HAVE_SOCKETPAIR=cross)]) 
 if test x"$rsync_cv_HAVE_SOCKETPAIR" = x"yes"; then  if test x"$rsync_cv_HAVE_SOCKETPAIR" = x"yes"; then
     AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define to 1 if you have the "socketpair" function])      AC_DEFINE(HAVE_SOCKETPAIR, 1, [Define to 1 if you have the "socketpair" function])
 fi  fi
   
AC_CHECK_FUNCS(getpass, , [AC_LIBOBJ(lib/getpass)])AC_REPLACE_FUNCS([getpass])
   
 if test x"$with_included_popt" != x"yes"; then  if test x"$with_included_popt" != x"yes"; then
     AC_CHECK_LIB(popt, poptGetContext, , [with_included_popt=yes])      AC_CHECK_LIB(popt, poptGetContext, , [with_included_popt=yes])
Line 769  AC_MSG_CHECKING([whether to use included libpopt]) Line 1099  AC_MSG_CHECKING([whether to use included libpopt])
 if test x"$with_included_popt" = x"yes"; then  if test x"$with_included_popt" = x"yes"; then
     AC_MSG_RESULT($srcdir/popt)      AC_MSG_RESULT($srcdir/popt)
     BUILD_POPT='$(popt_OBJS)'      BUILD_POPT='$(popt_OBJS)'
    CFLAGS="$CFLAGS -I$srcdir/popt"    CFLAGS="-I$srcdir/popt $CFLAGS"
     if test x"$ALLOCA" != x      if test x"$ALLOCA" != x
     then      then
         # this can be removed when/if we add an included alloca.c;          # this can be removed when/if we add an included alloca.c;
Line 794  AC_MSG_CHECKING([whether to use included zlib]) Line 1124  AC_MSG_CHECKING([whether to use included zlib])
 if test x"$with_included_zlib" = x"yes"; then  if test x"$with_included_zlib" = x"yes"; then
     AC_MSG_RESULT($srcdir/zlib)      AC_MSG_RESULT($srcdir/zlib)
     BUILD_ZLIB='$(zlib_OBJS)'      BUILD_ZLIB='$(zlib_OBJS)'
    CFLAGS="$CFLAGS -I$srcdir/zlib"    CFLAGS="-I$srcdir/zlib $CFLAGS"
 else  else
       AC_DEFINE(EXTERNAL_ZLIB, 1, [Define to 1 if using external zlib])
     AC_MSG_RESULT(no)      AC_MSG_RESULT(no)
 fi  fi
   
 AC_CACHE_CHECK([for unsigned char],rsync_cv_SIGNED_CHAR_OK,[  AC_CACHE_CHECK([for unsigned char],rsync_cv_SIGNED_CHAR_OK,[
AC_TRY_COMPILE([],[signed char *s = ""],AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[signed char *s = ""]])],[rsync_cv_SIGNED_CHAR_OK=yes],[rsync_cv_SIGNED_CHAR_OK=no])])
rsync_cv_SIGNED_CHAR_OK=yes,rsync_cv_SIGNED_CHAR_OK=no)]) 
 if test x"$rsync_cv_SIGNED_CHAR_OK" = x"yes"; then  if test x"$rsync_cv_SIGNED_CHAR_OK" = x"yes"; then
     AC_DEFINE(SIGNED_CHAR_OK, 1, [Define to 1 if "signed char" is a valid type])      AC_DEFINE(SIGNED_CHAR_OK, 1, [Define to 1 if "signed char" is a valid type])
 fi  fi
   
 AC_CACHE_CHECK([for broken readdir],rsync_cv_HAVE_BROKEN_READDIR,[  AC_CACHE_CHECK([for broken readdir],rsync_cv_HAVE_BROKEN_READDIR,[
AC_TRY_RUN([#include <sys/types.h>AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <sys/types.h>
 #include <dirent.h>  #include <dirent.h>
main() { struct dirent *di; DIR *d = opendir("."); di = readdir(d);int main(void) { struct dirent *di; DIR *d = opendir("."); di = readdir(d);
 if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&  if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&
di->d_name[0] == 0) exit(0); exit(1);} ],di->d_name[0] == 0) return 0; return 1;} ]])],[rsync_cv_HAVE_BROKEN_READDIR=yes],[rsync_cv_HAVE_BROKEN_READDIR=no],[rsync_cv_HAVE_BROKEN_READDIR=cross])])
rsync_cv_HAVE_BROKEN_READDIR=yes,rsync_cv_HAVE_BROKEN_READDIR=no,rsync_cv_HAVE_BROKEN_READDIR=cross)]) 
 if test x"$rsync_cv_HAVE_BROKEN_READDIR" = x"yes"; then  if test x"$rsync_cv_HAVE_BROKEN_READDIR" = x"yes"; then
     AC_DEFINE(HAVE_BROKEN_READDIR, 1, [Define to 1 if readdir() is broken])      AC_DEFINE(HAVE_BROKEN_READDIR, 1, [Define to 1 if readdir() is broken])
 fi  fi
   
 AC_CACHE_CHECK([for utimbuf],rsync_cv_HAVE_STRUCT_UTIMBUF,[  AC_CACHE_CHECK([for utimbuf],rsync_cv_HAVE_STRUCT_UTIMBUF,[
AC_TRY_COMPILE([#include <sys/types.h>AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
#include <utime.h>],#include <utime.h>]], [[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; return utime("foo.c",&tbuf);]])],[rsync_cv_HAVE_STRUCT_UTIMBUF=yes],[rsync_cv_HAVE_STRUCT_UTIMBUF=no])])
[struct utimbuf tbuf;  tbuf.actime = 0; tbuf.modtime = 1; exit(utime("foo.c",&tbuf));], 
rsync_cv_HAVE_STRUCT_UTIMBUF=yes,rsync_cv_HAVE_STRUCT_UTIMBUF=no)]) 
 if test x"$rsync_cv_HAVE_STRUCT_UTIMBUF" = x"yes"; then  if test x"$rsync_cv_HAVE_STRUCT_UTIMBUF" = x"yes"; then
     AC_DEFINE(HAVE_STRUCT_UTIMBUF, 1, [Define to 1 if you have the "struct utimbuf" type])      AC_DEFINE(HAVE_STRUCT_UTIMBUF, 1, [Define to 1 if you have the "struct utimbuf" type])
 fi  fi
   
 AC_CACHE_CHECK([if gettimeofday takes tz argument],rsync_cv_HAVE_GETTIMEOFDAY_TZ,[  AC_CACHE_CHECK([if gettimeofday takes tz argument],rsync_cv_HAVE_GETTIMEOFDAY_TZ,[
AC_TRY_COMPILE([#include <sys/time.h>AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/time.h>
#include <unistd.h>],#include <unistd.h>]], [[struct timeval tv; return gettimeofday(&tv, NULL);]])],[rsync_cv_HAVE_GETTIMEOFDAY_TZ=yes],[rsync_cv_HAVE_GETTIMEOFDAY_TZ=no])])
[struct timeval tv; exit(gettimeofday(&tv, NULL));], 
rsync_cv_HAVE_GETTIMEOFDAY_TZ=yes,rsync_cv_HAVE_GETTIMEOFDAY_TZ=no)]) 
 if test x"$rsync_cv_HAVE_GETTIMEOFDAY_TZ" != x"no"; then  if test x"$rsync_cv_HAVE_GETTIMEOFDAY_TZ" != x"no"; then
     AC_DEFINE(HAVE_GETTIMEOFDAY_TZ, 1, [Define to 1 if gettimeofday() takes a time-zone arg])      AC_DEFINE(HAVE_GETTIMEOFDAY_TZ, 1, [Define to 1 if gettimeofday() takes a time-zone arg])
 fi  fi
   
 AC_CACHE_CHECK([for C99 vsnprintf],rsync_cv_HAVE_C99_VSNPRINTF,[  AC_CACHE_CHECK([for C99 vsnprintf],rsync_cv_HAVE_C99_VSNPRINTF,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <sys/types.h>  #include <sys/types.h>
 #include <stdarg.h>  #include <stdarg.h>
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
 void foo(const char *format, ...) {  void foo(const char *format, ...) {
        va_list ap;         va_list ap;
        int len;         int len;
       char buf[5];       static char buf[] = "12345678901234567890";
   
        va_start(ap, format);         va_start(ap, format);
        len = vsnprintf(0, 0, format, ap);         len = vsnprintf(0, 0, format, ap);
Line 850  void foo(const char *format, ...) { Line 1178  void foo(const char *format, ...) {
        if (len != 5) exit(1);         if (len != 5) exit(1);
   
        if (snprintf(buf, 3, "hello") != 5 || strcmp(buf, "he") != 0) exit(1);         if (snprintf(buf, 3, "hello") != 5 || strcmp(buf, "he") != 0) exit(1);
   
        exit(0);  
 }  }
main() { foo("hello"); }int main(void) { foo("hello"); return 0; }
],]])],[rsync_cv_HAVE_C99_VSNPRINTF=yes],[rsync_cv_HAVE_C99_VSNPRINTF=no],[rsync_cv_HAVE_C99_VSNPRINTF=cross])])
rsync_cv_HAVE_C99_VSNPRINTF=yes,rsync_cv_HAVE_C99_VSNPRINTF=no,rsync_cv_HAVE_C99_VSNPRINTF=cross)]) 
 if test x"$rsync_cv_HAVE_C99_VSNPRINTF" = x"yes"; then  if test x"$rsync_cv_HAVE_C99_VSNPRINTF" = x"yes"; then
     AC_DEFINE(HAVE_C99_VSNPRINTF, 1, [Define to 1 if vsprintf has a C99-compatible return value])      AC_DEFINE(HAVE_C99_VSNPRINTF, 1, [Define to 1 if vsprintf has a C99-compatible return value])
 fi  fi
   
   
 AC_CACHE_CHECK([for secure mkstemp],rsync_cv_HAVE_SECURE_MKSTEMP,[  AC_CACHE_CHECK([for secure mkstemp],rsync_cv_HAVE_SECURE_MKSTEMP,[
AC_TRY_RUN([#include <stdlib.h>AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <unistd.h>  #include <unistd.h>
main() {int main(void) {
   struct stat st;    struct stat st;
   char tpl[20]="/tmp/test.XXXXXX";    char tpl[20]="/tmp/test.XXXXXX";
   int fd = mkstemp(tpl);    int fd = mkstemp(tpl);
  if (fd == -1) exit(1);  if (fd == -1) return 1;
   unlink(tpl);    unlink(tpl);
  if (fstat(fd, &st) != 0) exit(1);  if (fstat(fd, &st) != 0) return 1;
  if ((st.st_mode & 0777) != 0600) exit(1);  if ((st.st_mode & 0777) != 0600) return 1;
  exit(0);  return 0;
}],}]])],[rsync_cv_HAVE_SECURE_MKSTEMP=yes],[rsync_cv_HAVE_SECURE_MKSTEMP=no],[rsync_cv_HAVE_SECURE_MKSTEMP=cross])])
rsync_cv_HAVE_SECURE_MKSTEMP=yes, 
rsync_cv_HAVE_SECURE_MKSTEMP=no, 
rsync_cv_HAVE_SECURE_MKSTEMP=cross)]) 
 if test x"$rsync_cv_HAVE_SECURE_MKSTEMP" = x"yes"; then  if test x"$rsync_cv_HAVE_SECURE_MKSTEMP" = x"yes"; then
     case $host_os in      case $host_os in
     hpux*)      hpux*)
Line 895  fi Line 1217  fi
   
   
 AC_CACHE_CHECK([if mknod creates FIFOs],rsync_cv_MKNOD_CREATES_FIFOS,[  AC_CACHE_CHECK([if mknod creates FIFOs],rsync_cv_MKNOD_CREATES_FIFOS,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>  #include <stdio.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <errno.h>  #include <errno.h>
main() { int rc, ec; char *fn = "fifo-test";#if HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 int main(void) { int rc, ec; char *fn = "fifo-test";
 unlink(fn); rc = mknod(fn,S_IFIFO,0600); ec = errno; unlink(fn);  unlink(fn); rc = mknod(fn,S_IFIFO,0600); ec = errno; unlink(fn);
 if (rc) {printf("(%d %d) ",rc,ec); return ec;}  if (rc) {printf("(%d %d) ",rc,ec); return ec;}
return 0;}],return 0;}]])],[rsync_cv_MKNOD_CREATES_FIFOS=yes],[rsync_cv_MKNOD_CREATES_FIFOS=no],[rsync_cv_MKNOD_CREATES_FIFOS=cross])])
           rsync_cv_MKNOD_CREATES_FIFOS=yes,rsync_cv_MKNOD_CREATES_FIFOS=no,rsync_cv_MKNOD_CREATES_FIFOS=cross)]) 
 if test x"$rsync_cv_MKNOD_CREATES_FIFOS" = x"yes"; then  if test x"$rsync_cv_MKNOD_CREATES_FIFOS" = x"yes"; then
     AC_DEFINE(MKNOD_CREATES_FIFOS, 1, [Define to 1 if mknod() can create FIFOs.])      AC_DEFINE(MKNOD_CREATES_FIFOS, 1, [Define to 1 if mknod() can create FIFOs.])
 fi  fi
   
 AC_CACHE_CHECK([if mknod creates sockets],rsync_cv_MKNOD_CREATES_SOCKETS,[  AC_CACHE_CHECK([if mknod creates sockets],rsync_cv_MKNOD_CREATES_SOCKETS,[
AC_TRY_RUN([AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <stdio.h>  #include <stdio.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #include <errno.h>  #include <errno.h>
main() { int rc, ec; char *fn = "sock-test";#if HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 int main(void) { int rc, ec; char *fn = "sock-test";
 unlink(fn); rc = mknod(fn,S_IFSOCK,0600); ec = errno; unlink(fn);  unlink(fn); rc = mknod(fn,S_IFSOCK,0600); ec = errno; unlink(fn);
 if (rc) {printf("(%d %d) ",rc,ec); return ec;}  if (rc) {printf("(%d %d) ",rc,ec); return ec;}
return 0;}],return 0;}]])],[rsync_cv_MKNOD_CREATES_SOCKETS=yes],[rsync_cv_MKNOD_CREATES_SOCKETS=no],[rsync_cv_MKNOD_CREATES_SOCKETS=cross])])
           rsync_cv_MKNOD_CREATES_SOCKETS=yes,rsync_cv_MKNOD_CREATES_SOCKETS=no,rsync_cv_MKNOD_CREATES_SOCKETS=cross)]) 
 if test x"$rsync_cv_MKNOD_CREATES_SOCKETS" = x"yes"; then  if test x"$rsync_cv_MKNOD_CREATES_SOCKETS" = x"yes"; then
     AC_DEFINE(MKNOD_CREATES_SOCKETS, 1, [Define to 1 if mknod() can create sockets.])      AC_DEFINE(MKNOD_CREATES_SOCKETS, 1, [Define to 1 if mknod() can create sockets.])
 fi  fi
Line 928  fi Line 1254  fi
 AC_CACHE_CHECK([whether -c -o works],rsync_cv_DASHC_WORKS_WITH_DASHO,[  AC_CACHE_CHECK([whether -c -o works],rsync_cv_DASHC_WORKS_WITH_DASHO,[
 rm -rf conftest*  rm -rf conftest*
 cat > conftest.$ac_ext <<EOF  cat > conftest.$ac_ext <<EOF
int main() { return 0; }int main(void) { return 0; }
 EOF  EOF
 ${CC-cc} -c -o conftest..o conftest.$ac_ext  ${CC-cc} -c -o conftest..o conftest.$ac_ext
 if test -f conftest..o; then  if test -f conftest..o; then
Line 955  AC_SUBST(BUILD_POPT) Line 1281  AC_SUBST(BUILD_POPT)
 AC_SUBST(BUILD_ZLIB)  AC_SUBST(BUILD_ZLIB)
 AC_SUBST(MAKE_MAN)  AC_SUBST(MAKE_MAN)
   
 AC_PATH_PROG([STUNNEL], [stunnel], [stunnel], [$PATH$PATH_SEPARATOR/usr/sbin$PATH_SEPARATOR/sbin])  
 AC_PATH_PROG([STUNNEL4], [stunnel4], [$STUNNEL], [$PATH$PATH_SEPARATOR/usr/sbin$PATH_SEPARATOR/sbin])  
   
 AC_CHECK_FUNCS(_acl __acl _facl __facl)  AC_CHECK_FUNCS(_acl __acl _facl __facl)
 #################################################  #################################################
 # check for ACL support  # check for ACL support
   
 AC_MSG_CHECKING([whether to support ACLs])  AC_MSG_CHECKING([whether to support ACLs])
 AC_ARG_ENABLE(acl-support,  AC_ARG_ENABLE(acl-support,
        AC_HELP_STRING([--disable-acl-support],        AS_HELP_STRING([--disable-acl-support],[disable ACL support]))
                       [disable ACL support])) 
   
 if test x"$enable_acl_support" = x"no"; then  if test x"$enable_acl_support" = x"no"; then
     AC_MSG_RESULT(no)      AC_MSG_RESULT(no)
Line 976  else Line 1298  else
         AC_DEFINE(HAVE_UNIXWARE_ACLS, 1, [true if you have UnixWare ACLs])          AC_DEFINE(HAVE_UNIXWARE_ACLS, 1, [true if you have UnixWare ACLs])
         AC_DEFINE(SUPPORT_ACLS, 1, [Define to 1 to add support for ACLs])          AC_DEFINE(SUPPORT_ACLS, 1, [Define to 1 to add support for ACLs])
         ;;          ;;
    solaris*|*cygwin*)    solaris*)
         AC_MSG_RESULT(Using solaris ACLs)          AC_MSG_RESULT(Using solaris ACLs)
         AC_DEFINE(HAVE_SOLARIS_ACLS, 1, [true if you have solaris ACLs])          AC_DEFINE(HAVE_SOLARIS_ACLS, 1, [true if you have solaris ACLs])
         AC_DEFINE(SUPPORT_ACLS, 1)          AC_DEFINE(SUPPORT_ACLS, 1)
         ;;          ;;
     *hpux*)  
         AC_MSG_RESULT(Using HPUX ACLs)  
         AC_DEFINE(HAVE_HPUX_ACLS, 1, [true if you have HPUX ACLs])  
         AC_DEFINE(SUPPORT_ACLS, 1)  
         ;;  
     *irix*)      *irix*)
         AC_MSG_RESULT(Using IRIX ACLs)          AC_MSG_RESULT(Using IRIX ACLs)
         AC_DEFINE(HAVE_IRIX_ACLS, 1, [true if you have IRIX ACLs])          AC_DEFINE(HAVE_IRIX_ACLS, 1, [true if you have IRIX ACLs])
Line 1007  else Line 1324  else
         AC_DEFINE(HAVE_OSX_ACLS, 1, [true if you have Mac OS X ACLs])          AC_DEFINE(HAVE_OSX_ACLS, 1, [true if you have Mac OS X ACLs])
         AC_DEFINE(SUPPORT_ACLS, 1)          AC_DEFINE(SUPPORT_ACLS, 1)
         ;;          ;;
       *hpux*|*nsk*)
           AC_MSG_RESULT(Using HPUX ACLs)
           AC_DEFINE(HAVE_HPUX_ACLS, 1, [true if you have HPUX ACLs])
           AC_DEFINE(SUPPORT_ACLS, 1)
           ;;
     *)      *)
         AC_MSG_RESULT(running tests:)          AC_MSG_RESULT(running tests:)
         AC_CHECK_LIB(acl,acl_get_file)          AC_CHECK_LIB(acl,acl_get_file)
            AC_CACHE_CHECK([for ACL support],samba_cv_HAVE_POSIX_ACLS,[        AC_CACHE_CHECK([for ACL support],samba_cv_HAVE_POSIX_ACLS,[
            AC_TRY_LINK([#include <sys/types.h>            AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
#include <sys/acl.h>],#include <sys/acl.h>]], [[ acl_t acl; int entry_id; acl_entry_t *entry_p; return acl_get_entry( acl, entry_id, entry_p);]])],[samba_cv_HAVE_POSIX_ACLS=yes],[samba_cv_HAVE_POSIX_ACLS=no])])
[ acl_t acl; int entry_id; acl_entry_t *entry_p; return acl_get_entry( acl, entry_id, entry_p);], 
samba_cv_HAVE_POSIX_ACLS=yes,samba_cv_HAVE_POSIX_ACLS=no)]) 
         AC_MSG_CHECKING(ACL test results)          AC_MSG_CHECKING(ACL test results)
         if test x"$samba_cv_HAVE_POSIX_ACLS" = x"yes"; then          if test x"$samba_cv_HAVE_POSIX_ACLS" = x"yes"; then
             AC_MSG_RESULT(Using posix ACLs)              AC_MSG_RESULT(Using posix ACLs)
             AC_DEFINE(HAVE_POSIX_ACLS, 1, [true if you have posix ACLs])              AC_DEFINE(HAVE_POSIX_ACLS, 1, [true if you have posix ACLs])
             AC_DEFINE(SUPPORT_ACLS, 1)              AC_DEFINE(SUPPORT_ACLS, 1)
             AC_CACHE_CHECK([for acl_get_perm_np],samba_cv_HAVE_ACL_GET_PERM_NP,[              AC_CACHE_CHECK([for acl_get_perm_np],samba_cv_HAVE_ACL_GET_PERM_NP,[
                AC_TRY_LINK([#include <sys/types.h>                AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
#include <sys/acl.h>],#include <sys/acl.h>]], [[ acl_permset_t permset_d; acl_perm_t perm; return acl_get_perm_np( permset_d, perm);]])],[samba_cv_HAVE_ACL_GET_PERM_NP=yes],[samba_cv_HAVE_ACL_GET_PERM_NP=no])])
[ acl_permset_t permset_d; acl_perm_t perm; return acl_get_perm_np( permset_d, perm);], 
samba_cv_HAVE_ACL_GET_PERM_NP=yes,samba_cv_HAVE_ACL_GET_PERM_NP=no)]) 
             if test x"$samba_cv_HAVE_ACL_GET_PERM_NP" = x"yes"; then              if test x"$samba_cv_HAVE_ACL_GET_PERM_NP" = x"yes"; then
                 AC_DEFINE(HAVE_ACL_GET_PERM_NP, 1, [true if you have acl_get_perm_np])                  AC_DEFINE(HAVE_ACL_GET_PERM_NP, 1, [true if you have acl_get_perm_np])
             fi              fi
Line 1043  fi Line 1361  fi
 # check for extended attribute support  # check for extended attribute support
 AC_MSG_CHECKING(whether to support extended attributes)  AC_MSG_CHECKING(whether to support extended attributes)
 AC_ARG_ENABLE(xattr-support,  AC_ARG_ENABLE(xattr-support,
    AC_HELP_STRING([--disable-xattr-support],    AS_HELP_STRING([--disable-xattr-support],[disable extended attributes]),
            [disable extended attributes]), 
     [], [case "$ac_cv_func_getxattr$ac_cv_func_extattr_get_link$ac_cv_func_attropen" in      [], [case "$ac_cv_func_getxattr$ac_cv_func_extattr_get_link$ac_cv_func_attropen" in
         *yes*) enable_xattr_support=maybe ;;          *yes*) enable_xattr_support=maybe ;;
         *) enable_xattr_support=no ;;          *) enable_xattr_support=no ;;
Line 1055  if test x"$enable_xattr_support" = x"no"; then Line 1372  if test x"$enable_xattr_support" = x"no"; then
     AC_MSG_RESULT(no)      AC_MSG_RESULT(no)
 else  else
     case "$host_os" in      case "$host_os" in
    *linux*)    *linux*|*netbsd*|*cygwin*)
         AC_MSG_RESULT(Using Linux xattrs)          AC_MSG_RESULT(Using Linux xattrs)
        AC_DEFINE(HAVE_LINUX_XATTRS, 1, [True if you have Linux xattrs])        AC_DEFINE(HAVE_LINUX_XATTRS, 1, [True if you have Linux xattrs (or equivalent)])
         AC_DEFINE(SUPPORT_XATTRS, 1)          AC_DEFINE(SUPPORT_XATTRS, 1)
         AC_DEFINE(NO_SYMLINK_USER_XATTRS, 1, [True if symlinks do not support user xattrs])          AC_DEFINE(NO_SYMLINK_USER_XATTRS, 1, [True if symlinks do not support user xattrs])
           AC_CHECK_LIB(attr,getxattr)
         ;;          ;;
     darwin*)      darwin*)
         AC_MSG_RESULT(Using OS X xattrs)          AC_MSG_RESULT(Using OS X xattrs)
Line 1093  if test x"$enable_acl_support" = x"no" -o x"$enable_xa Line 1411  if test x"$enable_acl_support" = x"no" -o x"$enable_xa
     AC_MSG_CHECKING([whether $CC supports -Wno-unused-parameter])      AC_MSG_CHECKING([whether $CC supports -Wno-unused-parameter])
     OLD_CFLAGS="$CFLAGS"      OLD_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS -Wno-unused-parameter"      CFLAGS="$CFLAGS -Wno-unused-parameter"
    AC_TRY_LINK([#include <stdio.h>], [printf("hello\n");], [rsync_warn_flag=yes], [rsync_warn_flag=no])    AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[printf("hello\n");]])],[rsync_warn_flag=yes],[rsync_warn_flag=no])
     AC_MSG_RESULT([$rsync_warn_flag])      AC_MSG_RESULT([$rsync_warn_flag])
     if test x"$rsync_warn_flag" = x"no"; then      if test x"$rsync_warn_flag" = x"no"; then
         CFLAGS="$OLD_CFLAGS"          CFLAGS="$OLD_CFLAGS"
     fi      fi
 fi  fi
   
   AC_MSG_CHECKING([whether to include mysql DB support])
   AC_ARG_ENABLE(mysql,
           AC_HELP_STRING([--disable-mysql],
                   [disable mysql DB support]))
   
   if test x"$enable_mysql" = x"no"; then
       AC_MSG_RESULT(no)
   else
       AC_MSG_RESULT([yes])
       AC_CHECK_PROG(MYSQL_CONFIG, mysql_config, 1, 0)
       if test x$MYSQL_CONFIG = x1; then
           AC_MSG_CHECKING(for mysql version >= 4)
           mysql_version=`mysql_config --version`
           mysql_major_version=`echo $mysql_version | sed 's/\..*//'`
           if test $mysql_major_version -lt 4; then
               AC_MSG_RESULT(no.. skipping MySQL)
           else
               AC_MSG_RESULT(yes)
   
               MYSQL_CFLAGS=`mysql_config --cflags`
               MYSQL_LIBS=`mysql_config --libs`
   
               CPPFLAGS="$CPPFLAGS $MYSQL_CFLAGS"
               LIBS="$MYSQL_LIBS $LIBS"
   
               AC_CHECK_LIB(mysqlclient, mysql_init)
           fi
       fi
   fi
   
   AC_MSG_CHECKING([whether to include sqlite DB support])
   AC_ARG_ENABLE(sqlite,
           AC_HELP_STRING([--disable-sqlite],
                   [disable sqlite DB support]))
   
   if test x"$enable_sqlite" = x"no"; then
       AC_MSG_RESULT(no)
   else
       AC_CHECK_LIB(sqlite3, sqlite3_open)
       AC_CHECK_FUNCS(sqlite3_open_v2 sqlite3_prepare_v2)
   fi
   
 case "$CC" in  case "$CC" in
 ' checker'*|checker*)  ' checker'*|checker*)
     AC_DEFINE(FORCE_FD_ZERO_MEMSET, 1, [Used to make "checker" understand that FD_ZERO() clears memory.])      AC_DEFINE(FORCE_FD_ZERO_MEMSET, 1, [Used to make "checker" understand that FD_ZERO() clears memory.])
Line 1110  AC_CONFIG_FILES([Makefile lib/dummy zlib/dummy popt/du Line 1470  AC_CONFIG_FILES([Makefile lib/dummy zlib/dummy popt/du
 AC_OUTPUT  AC_OUTPUT
   
 AC_MSG_RESULT()  AC_MSG_RESULT()
AC_MSG_RESULT([    rsync ${RSYNC_VERSION} configuration successful])AC_MSG_RESULT([    rsync $PACKAGE_VERSION configuration successful])
 AC_MSG_RESULT()  AC_MSG_RESULT()
Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>