default_static_modules="$default_static_modules auth_unix"
default_static_modules="$default_static_modules auth_winbind"
default_static_modules="$default_static_modules auth_wbc"
-default_static_modules="$default_static_modules auth_server"
default_static_modules="$default_static_modules auth_domain"
default_static_modules="$default_static_modules auth_builtin"
default_static_modules="$default_static_modules vfs_default"
AC_CHECK_FUNCS(sigprocmask sigblock sigaction sigset innetgr setnetgrent getnetgrent endnetgrent)
AC_CHECK_FUNCS(initgroups select rdchk getgrnam getgrent pathconf)
AC_CHECK_FUNCS(getgrset)
-AC_CHECK_FUNCS(setpriv setgidx setuidx setgroups sysconf stat64 fstat64)
-AC_CHECK_FUNCS(lstat64 fopen64 atexit grantpt lseek64 ftruncate64 posix_fallocate posix_fallocate64)
-AC_CHECK_FUNCS(fallocate fallocate64)
-AC_CHECK_FUNCS(fseeko fseek64 fseeko64 ftell64 ftello64 setluid getpwanam)
-AC_CHECK_FUNCS(opendir64 readdir64 seekdir64 telldir64 rewinddir64 closedir64)
-AC_CHECK_FUNCS(fdopendir fdopendir64)
+AC_CHECK_FUNCS(setpriv setgidx setuidx setgroups sysconf)
+AC_CHECK_FUNCS(atexit grantpt posix_fallocate)
+AC_CHECK_FUNCS(fallocate)
+AC_CHECK_FUNCS(fseeko setluid getpwanam)
+AC_CHECK_FUNCS(fdopendir)
AC_CHECK_FUNCS(getpwent_r)
-AC_CHECK_FUNCS(getdents64)
AC_CHECK_FUNCS(setenv strcasecmp fcvt fcvtl)
AC_CHECK_FUNCS(syslog vsyslog timegm)
AC_CHECK_FUNCS(setlocale)
default_shared_modules="$default_shared_modules vfs_gpfs_hsm_notify"
fi
-#############################################
-# check if building on Isilon OneFS
-printf "%s" "checking for Isilon OneFS... "
-save_LIBS="$LIBS"
-LIBS="$LIBS -lisi_version"
-AC_TRY_LINK([#include <isi_version/isi_version.h>],
- [get_isilon_copyright()],
- samba_cv_HAVE_ONEFS=yes,
- samba_cv_HAVE_ONEFS=no)
-echo $samba_cv_HAVE_ONEFS
-if test x"$samba_cv_HAVE_ONEFS" = x"yes"; then
- AC_DEFINE(HAVE_ONEFS,1,[Whether building on Isilon OneFS])
- default_shared_modules="$default_shared_modules vfs_onefs vfs_onefs_shadow_copy perfcount_onefs"
- default_static_modules="$default_static_modules"
- ONEFS_LIBS="-lisi_acl -lisi_ecs -lisi_event -lisi_util"
- # Need to also add general libs for oplocks support
- save_LIBS="$save_LIBS -lisi_ecs -lisi_event -lisi_util -ldevstat"
-fi
-AC_SUBST(ONEFS_LIBS)
-LIBS="$save_LIBS"
-
# Note that all the libunwind symbols in the API are defined to internal
# platform-specific version, so we must include libunwind.h before checking
# any of them.
AC_CHECK_FUNCS(_close __close _fchdir __fchdir _fcntl __fcntl)
AC_CHECK_FUNCS(getdents __getdents _lseek __lseek _read __read)
AC_CHECK_FUNCS(getdirentries _write __write _fork __fork)
-AC_CHECK_FUNCS(_stat64 __stat64 _fstat64 __fstat64 _lstat64 __lstat64)
-AC_CHECK_FUNCS(__sys_llseek llseek _llseek __llseek readdir64 _readdir64 __readdir64)
-AC_CHECK_FUNCS(pread _pread __pread pread64 _pread64 __pread64)
-AC_CHECK_FUNCS(pwrite _pwrite __pwrite pwrite64 _pwrite64 __pwrite64)
-AC_CHECK_FUNCS(open64 _open64 __open64 creat64)
+AC_CHECK_FUNCS(__sys_llseek llseek _llseek __llseek)
+AC_CHECK_FUNCS(pread _pread __pread)
+AC_CHECK_FUNCS(pwrite _pwrite __pwrite)
AC_CHECK_FUNCS(prctl)
AC_TRY_COMPILE([
;;
esac
-#
-# stat64 family may need <sys/stat.h> on some systems, notably ReliantUNIX
-#
-
-if test x$ac_cv_func_stat64 = xno ; then
- AC_MSG_CHECKING([for stat64 in <sys/stat.h>])
- AC_TRY_LINK([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-], [struct stat64 st64; exit(stat64(".",&st64));], [ac_cv_func_stat64=yes])
- AC_MSG_RESULT([$ac_cv_func_stat64])
- if test x$ac_cv_func_stat64 = xyes ; then
- AC_DEFINE(HAVE_STAT64,1,[Whether stat64() is available])
- fi
-fi
-
-if test x$ac_cv_func_lstat64 = xno ; then
- AC_MSG_CHECKING([for lstat64 in <sys/stat.h>])
- AC_TRY_LINK([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-], [struct stat64 st64; exit(lstat64(".",&st64));], [ac_cv_func_lstat64=yes])
- AC_MSG_RESULT([$ac_cv_func_lstat64])
- if test x$ac_cv_func_lstat64 = xyes ; then
- AC_DEFINE(HAVE_LSTAT64,[Whether lstat64() is available])
- fi
-fi
-
-if test x$ac_cv_func_fstat64 = xno ; then
- AC_MSG_CHECKING([for fstat64 in <sys/stat.h>])
- AC_TRY_LINK([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-], [struct stat64 st64; exit(fstat64(0,&st64));], [ac_cv_func_fstat64=yes])
- AC_MSG_RESULT([$ac_cv_func_fstat64])
- if test x$ac_cv_func_fstat64 = xyes ; then
- AC_DEFINE(HAVE_FSTAT64,1,[Whether fstat64() is available])
- fi
-fi
-
#################################################
# Check whether struct stat has timestamps with sub-second resolution.
#
*)
AC_SEARCH_LIBS(getxattr, [attr])
AC_CHECK_FUNCS(getxattr,[
- AC_CHECK_FUNCS(lgetxattr fgetxattr listxattr llistxattr flistxattr removexattr lremovexattr fremovexattr setxattr lsetxattr fsetxattr)
+ AC_CHECK_FUNCS(fgetxattr listxattr flistxattr removexattr fremovexattr setxattr fsetxattr)
])
AC_CHECK_FUNCS(getea,[
- AC_CHECK_FUNCS(fgetea lgetea listea flistea llistea removeea fremoveea lremoveea setea fsetea lsetea)
+ AC_CHECK_FUNCS(fgetea listea flistea removeea fremoveea setea fsetea)
])
AC_CHECK_FUNCS(attr_get,[
AC_CHECK_FUNCS(attr_list attr_set attr_remove attr_getf attr_listf attr_setf attr_removef)
])
AC_CHECK_FUNCS(extattr_delete_file,[
- AC_CHECK_FUNCS(extattr_delete_fd extattr_delete_link extattr_get_fd extattr_get_file extattr_get_link extattr_list_fd extattr_list_file extattr_list_link extattr_set_fd extattr_set_file extattr_set_link)
+ AC_CHECK_FUNCS(extattr_delete_fd extattr_get_fd extattr_get_file extattr_list_fd extattr_list_file extattr_set_fd extattr_set_file)
])
;;
esac
fi
+#
+# As a gating factor for large file support, in order to
+# use >4GB files we must have the following minimal support
+# available: a 64 bit off_t
+# If we don't have all of these then fail the build
+#
+
+AC_MSG_CHECKING([if large file support can be enabled])
AC_CACHE_CHECK([for 64 bit off_t],samba_cv_SIZEOF_OFF_T,[
AC_TRY_RUN([#include <stdio.h>
#include <sys/stat.h>
main() { exit((sizeof(off_t) == 8) ? 0 : 1); }],
samba_cv_SIZEOF_OFF_T=yes,samba_cv_SIZEOF_OFF_T=no,samba_cv_SIZEOF_OFF_T=cross)])
-if test x"$samba_cv_SIZEOF_OFF_T" = x"yes"; then
- AC_DEFINE(SIZEOF_OFF_T,8,[The size of the 'off_t' type])
-fi
-
-AC_CACHE_CHECK([for off64_t],samba_cv_HAVE_OFF64_T,[
-AC_TRY_RUN([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <sys/stat.h>
-main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
-samba_cv_HAVE_OFF64_T=yes,samba_cv_HAVE_OFF64_T=no,samba_cv_HAVE_OFF64_T=cross)])
-if test x"$samba_cv_HAVE_OFF64_T" = x"yes"; then
- AC_DEFINE(HAVE_OFF64_T,1,[Whether off64_t is available])
+if test x"$samba_cv_SIZEOF_OFF_T" = x"no"; then
+ AC_MSG_ERROR(["large file support support not available: sizeof(off_t) != 8"])
fi
AC_CACHE_CHECK([for 64 bit ino_t],samba_cv_SIZEOF_INO_T,[
AC_DEFINE(SIZEOF_INO_T,8,[The size of the 'ino_t' type])
fi
-AC_CACHE_CHECK([for ino64_t],samba_cv_HAVE_INO64_T,[
-AC_TRY_RUN([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <sys/stat.h>
-main() { struct stat64 st; ino64_t s; if (sizeof(ino_t) == sizeof(ino64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
-samba_cv_HAVE_INO64_T=yes,samba_cv_HAVE_INO64_T=no,samba_cv_HAVE_INO64_T=cross)])
-if test x"$samba_cv_HAVE_INO64_T" = x"yes"; then
- AC_DEFINE(HAVE_INO64_T,1,[Whether the 'ino64_t' type is available])
-fi
-
AC_CACHE_CHECK([for 64 bit dev_t],samba_cv_SIZEOF_DEV_T,[
AC_TRY_RUN([
#if defined(HAVE_UNISTD_H)
AC_DEFINE(SIZEOF_DEV_T,8,[The size of the 'dev_t' type])
fi
-AC_CACHE_CHECK([for dev64_t],samba_cv_HAVE_DEV64_T,[
-AC_TRY_RUN([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <sys/stat.h>
-main() { struct stat64 st; dev64_t s; if (sizeof(dev_t) == sizeof(dev64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
-samba_cv_HAVE_DEV64_T=yes,samba_cv_HAVE_DEV64_T=no,samba_cv_HAVE_DEV64_T=cross)])
-if test x"$samba_cv_HAVE_DEV64_T" = x"yes"; then
- AC_DEFINE(HAVE_DEV64_T,1,[Whether the 'dev64_t' type is available])
-fi
-
-AC_CACHE_CHECK([for struct dirent64],samba_cv_HAVE_STRUCT_DIR64,[
-AC_TRY_COMPILE([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#include <dirent.h>],
-[DIR64 de;],
-samba_cv_HAVE_STRUCT_DIR64=yes,samba_cv_HAVE_STRUCT_DIR64=no)])
-if test x"$samba_cv_HAVE_STRUCT_DIR64" = x"yes" && test x"$ac_cv_func_readdir64" = x"yes"; then
- AC_DEFINE(HAVE_STRUCT_DIR64,1,[Whether the 'DIR64' abstract data type is available])
-fi
-
-AC_CACHE_CHECK([for struct dirent64],samba_cv_HAVE_STRUCT_DIRENT64,[
-AC_TRY_COMPILE([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#include <dirent.h>],
-[struct dirent64 de;],
-samba_cv_HAVE_STRUCT_DIRENT64=yes,samba_cv_HAVE_STRUCT_DIRENT64=no)])
-if test x"$samba_cv_HAVE_STRUCT_DIRENT64" = x"yes" && test x"$ac_cv_func_readdir64" = x"yes"; then
- AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Whether the 'dirent64' struct is available])
-fi
-
AC_CACHE_CHECK([for major macro],samba_cv_HAVE_DEVICE_MAJOR_FN,[
AC_TRY_RUN([
#if defined(HAVE_UNISTD_H)
AC_DEFINE(HAVE_LINUX_FALLOCATE,1,[Whether the Linux 'fallocate' function is available])
fi
-AC_CACHE_CHECK([for linux fallocate64],samba_cv_HAVE_LINUX_FALLOCATE64,[
-AC_TRY_COMPILE([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#define _GNU_SOURCE
-#include <fcntl.h>
-#if defined(HAVE_LINUX_FALLOC_H)
-#include <linux/falloc.h>
-#endif],
-[int ret = fallocate64(0, FALLOC_FL_KEEP_SIZE, 0, 10);],
-samba_cv_HAVE_LINUX_FALLOCATE64=yes,samba_cv_HAVE_LINUX_FALLOCATE64=no)])
-if test x"$samba_cv_HAVE_LINUX_FALLOCATE64" = x"yes" && test x"$ac_cv_func_fallocate64" = x"yes"; then
- AC_DEFINE(HAVE_LINUX_FALLOCATE64,1,[Whether the Linux 'fallocate64' function is available])
-fi
-
AC_CACHE_CHECK([for getcwd takes NULL],samba_cv_GETCWD_TAKES_NULL,[
AC_TRY_RUN([
#if defined(HAVE_UNISTD_H)
AC_DEFINE(HAVE_KERNEL_CHANGE_NOTIFY,1,[Whether kernel notifies changes])
fi
-AC_CACHE_CHECK([for inotify support],samba_cv_HAVE_INOTIFY,[
-AC_CHECK_HEADERS(linux/inotify.h asm/unistd.h sys/inotify.h)
-AC_CHECK_FUNCS(inotify_init)
-AC_HAVE_DECL(__NR_inotify_init, [#include <asm/unistd.h>])
-],
-samba_cv_HAVE_INOTIFY=yes,
-samba_cv_HAVE_INOTIFY=no,
-samba_cv_HAVE_INOTIFY=cross)
+AC_CHECK_HEADER(sys/inotify.h)
-if test x"$ac_cv_func_inotify_init" = x"yes"; then
- if test x"$ac_cv_header_sys_inotify_h" = x"yes" -o x"$ac_cv_header_linux_inotify_h" = x"yes"; then
- AC_DEFINE(HAVE_INOTIFY,1,[Whether kernel or sys has inotify support])
- fi
+if test x"ac_cv_header_sys_inotify_h" = x"yes"; then
+ AC_DEFINE(HAVE_INOTIFY,1,[For inotify support])
fi
#################################################
AC_DEFINE(HAVE_FCNTL_LOCK,1,[Whether fcntl locking is available])
fi
-AC_CACHE_CHECK([for broken (glibc2.1/x86) 64 bit fcntl locking],samba_cv_HAVE_BROKEN_FCNTL64_LOCKS,[
-AC_TRY_RUN([#include "${srcdir-.}/../tests/fcntl_lock64.c"],
- samba_cv_HAVE_BROKEN_FCNTL64_LOCKS=yes,samba_cv_HAVE_BROKEN_FCNTL64_LOCKS=no,samba_cv_HAVE_BROKEN_FCNTL64_LOCKS=cross)])
-if test x"$samba_cv_HAVE_BROKEN_FCNTL64_LOCKS" = x"yes"; then
- AC_DEFINE(HAVE_BROKEN_FCNTL64_LOCKS,1,[Whether fcntl64 locks are broken])
-
-else
-
-dnl
-dnl Don't check for 64 bit fcntl locking if we know that the
-dnl glibc2.1 broken check has succeeded.
-dnl
-
- AC_CACHE_CHECK([for 64 bit fcntl locking],samba_cv_HAVE_STRUCT_FLOCK64,[
- AC_TRY_RUN([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-
-#ifdef HAVE_SYS_FCNTL_H
-#include <sys/fcntl.h>
-#endif
-main() { struct flock64 fl64;
-#if defined(F_SETLKW64) && defined(F_SETLK64) && defined(F_GETLK64)
-exit(0);
-#else
-exit(1);
-#endif
-}],
- samba_cv_HAVE_STRUCT_FLOCK64=yes,samba_cv_HAVE_STRUCT_FLOCK64=no,samba_cv_HAVE_STRUCT_FLOCK64=cross)])
-
- if test x"$samba_cv_HAVE_STRUCT_FLOCK64" = x"yes"; then
- AC_DEFINE(HAVE_STRUCT_FLOCK64,1,[Whether the flock64 struct is available])
- fi
-fi
-
# glibc up to 2.3.6 had dangerously broken posix_fallocate(). DON'T USE IT.
AC_CACHE_CHECK([for broken posix_fallocate],samba_cv_HAVE_BROKEN_POSIX_FALLOCATE,[
AC_TRY_COMPILE([
AC_DEFINE(HAVE_STAT_ST_BLOCKS,1,[Whether the stat struct has a st_block property])
fi
-AC_CHECK_TYPES([blksize_t, blkcnt_t], [], [], [[#include <sys/stat.h>]])
+AC_CACHE_CHECK([for 32 bit blkcnt_t],samba_cv_SIZEOF_BLKCNT_T_4,[
+AC_TRY_RUN([
+#if defined(HAVE_UNISTD_H)
+#include <unistd.h>
+#endif
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+main() { exit((sizeof(blkcnt_t) == 4) ? 0 : 1); }],
+samba_cv_SIZEOF_BLKCNT_T_4=yes,samba_cv_SIZEOF_BLKCNT_T_4=no,samba_cv_SIZEOF_BLKCNT_T_4=cross)])
+if test x"$samba_cv_SIZEOF_BLKCNT_T_4" = x"yes"; then
+ AC_DEFINE(SIZEOF_BLKCNT_T_4,1,[The size of the 'blkcnt_t' type])
+fi
+
+AC_CACHE_CHECK([for 64 bit blkcnt_t],samba_cv_SIZEOF_BLKCNT_T_8,[
+AC_TRY_RUN([
+#if defined(HAVE_UNISTD_H)
+#include <unistd.h>
+#endif
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+main() { exit((sizeof(blkcnt_t) == 8) ? 0 : 1); }],
+samba_cv_SIZEOF_BLKCNT_T_8=yes,samba_cv_SIZEOF_BLKCNT_T_8=no,samba_cv_SIZEOF_BLKCNT_T_8=cross)])
+if test x"$samba_cv_SIZEOF_BLKCNT_T_8" = x"yes"; then
+ AC_DEFINE(SIZEOF_BLKCNT_T_8,1,[The size of the 'blkcnt_t' type])
+fi
AC_CACHE_CHECK([for st_blksize in struct stat],samba_cv_HAVE_STAT_ST_BLKSIZE,[
AC_TRY_COMPILE([#include <sys/types.h>
if test x"$have_gssapi" != xyes ; then
AC_MSG_WARN([Samba cannot be supported without GSSAPI])
use_ads=no
+ else
+ AC_DEFINE(HAVE_GSSAPI, , [Whether the platform has GSSAPI support])
fi
AC_CHECK_FUNC_EXT(krb5_set_real_time, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_set_default_tgs_enctypes, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_set_default_tgs_ktypes, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_principal2salt, $KRB5_LIBS)
- AC_CHECK_FUNC_EXT(krb5_use_enctype, $KRB5_LIBS)
- AC_CHECK_FUNC_EXT(krb5_string_to_key, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_c_string_to_key, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_get_pw_salt, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_string_to_key_salt, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_auth_con_setkey, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_principal_compare_any_realm, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_parse_name_norealm, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_princ_size, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_principal_get_num_comp, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_get_init_creds_opt_set_pac_request, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_get_renewed_creds, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_free_error_contents, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_get_credentials_for_user, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_get_host_realm, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(krb5_free_host_realm, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_get_init_creds_keytab, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_build_principal_alloc_va, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_cc_get_lifetime, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_cc_retrieve_cred, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_free_checksum_contents, $KRB5_LIBS)
+ AC_CHECK_FUNC_EXT(krb5_c_make_checksum, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(gss_krb5_import_cred, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(gss_get_name_attribute, $KRB5_LIBS)
AC_CHECK_FUNC_EXT(gsskrb5_extract_authz_data_from_sec_context, $KRB5_LIBS)
[Whether the type krb5_crypto exists])
fi
- AC_CACHE_CHECK([for krb5_encrypt_block type],
- samba_cv_HAVE_KRB5_ENCRYPT_BLOCK,[
- AC_TRY_COMPILE([#include <krb5.h>],
- [krb5_encrypt_block block;],
- samba_cv_HAVE_KRB5_ENCRYPT_BLOCK=yes,
- samba_cv_HAVE_KRB5_ENCRYPT_BLOCK=no)])
-
- if test x"$samba_cv_HAVE_KRB5_ENCRYPT_BLOCK" = x"yes"; then
- AC_DEFINE(HAVE_KRB5_ENCRYPT_BLOCK,1,
- [Whether the type krb5_encrypt_block exists])
- fi
-
AC_CACHE_CHECK([for addrtype in krb5_address],
samba_cv_HAVE_ADDRTYPE_IN_KRB5_ADDRESS,[
AC_TRY_COMPILE([#include <krb5.h>],
use_ads=no
fi
- if test x"$ac_cv_func_ext_krb5_string_to_key" != x"yes"
+ if test x"$ac_cv_func_ext_krb5_c_string_to_key" != x"yes"
then
- AC_MSG_WARN(krb5_string_to_key not found in -lkrb5)
+ AC_MSG_WARN(krb5_c_string_to_key not found in -lkrb5)
use_ads=no
fi
fi
fi
-# Test for statvfs64.
-if test $space = no; then
- # SVR4
- AC_CACHE_CHECK([statvfs64 function (SVR4)], fu_cv_sys_stat_statvfs64,
- [AC_TRY_RUN([
-#if defined(HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#include <sys/statvfs.h>
- main ()
- {
- struct statvfs64 fsd;
- exit (statvfs64 (".", &fsd));
- }],
- fu_cv_sys_stat_statvfs64=yes,
- fu_cv_sys_stat_statvfs64=no,
- fu_cv_sys_stat_statvfs64=cross)])
- if test $fu_cv_sys_stat_statvfs64 = yes; then
- space=yes
- AC_DEFINE(STAT_STATVFS64,1,[Whether statvfs64() is available])
- fi
-fi
-
# smbd/statvfs.c assumes that statvfs.f_fsid is an integer.
# This is not the case on ancient Linux systems.
fi
fi
-#
-# As a gating factor for large file support, in order to
-# use <4GB files we must have the following minimal support
-# available: a 64 bit off_t
-# If we don't have all of these then fail the build
-#
-AC_MSG_CHECKING([if large file support can be enabled])
-AC_TRY_COMPILE([
-#if (defined(SIZEOF_OFF_T) && (SIZEOF_OFF_T == 8))
-#include <sys/types.h>
-#else
-__COMPILE_ERROR_
-#endif
-],
-[int i],
-samba_cv_HAVE_LARGEFILE_SUPPORT=yes,samba_cv_HAVE_LARGEFILE_SUPPORT=no)
-if test x"$samba_cv_HAVE_LARGEFILE_SUPPORT" != x"yes"; then
- AC_MSG_ERROR(["large file support support not available: sizeof(off_t) != 8"])
-fi
-AC_MSG_RESULT([$samba_cv_HAVE_LARGEFILE_SUPPORT])
-
-
#################################################
# check for cluster extensions
[ struct aiocb a; return aio_read(&a);],
samba_cv_HAVE_AIO=yes,samba_cv_HAVE_AIO=no)
LIBS=$aio_LIBS])
- AC_CACHE_CHECK([for 64-bit asynchronous io support],samba_cv_HAVE_AIO64,[
- aio_LIBS=$LIBS
- LIBS=$AIO_LIBS
- AC_TRY_LINK([#include <sys/types.h>
-#include <aio.h>],
-[ struct aiocb64 a; return aio_read64(&a);],
-samba_cv_HAVE_AIO64=yes,samba_cv_HAVE_AIO64=no)
- LIBS=$aio_LIBS])
- if test x"$samba_cv_HAVE_AIO64" = x"yes"; then
- AC_DEFINE(HAVE_AIOCB64,1,[Whether 64 bit aio is available])
- AC_DEFINE(WITH_AIO, 1, [Using asynchronous io])
- LIBS=$AIO_LIBS
- elif test x"$samba_cv_HAVE_AIO" = x"yes"; then
+ if test x"$samba_cv_HAVE_AIO" = x"yes"; then
AC_DEFINE(WITH_AIO, 1, [Using asynchronous io])
LIBS=$AIO_LIBS
- fi
-
- if test x"$samba_cv_HAVE_AIO" = x"yes"; then
AC_MSG_CHECKING(for aio_read)
AC_LINK_IFELSE([#include <aio.h>
int main() { struct aiocb a; return aio_read(&a); }],
[AC_MSG_RESULT(no)])
fi
- if test x"$samba_cv_HAVE_AIO64" = x"yes"; then
- AC_MSG_CHECKING(for aio_read64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_read64(&a); }],
-[AC_DEFINE(HAVE_AIO_READ64, 1, [Have aio_read64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_write64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_write64(&a); }],
-[AC_DEFINE(HAVE_AIO_WRITE64, 1, [Have aio_write64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_fsync64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_fsync64(1, &a); }],
-[AC_DEFINE(HAVE_AIO_FSYNC64, 1, [Have aio_fsync64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_return64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_return64(&a); }],
-[AC_DEFINE(HAVE_AIO_RETURN64, 1, [Have aio_return64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_error64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_error64(&a); }],
-[AC_DEFINE(HAVE_AIO_ERROR64, 1, [Have aio_error64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_cancel64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_cancel64(1, &a); }],
-[AC_DEFINE(HAVE_AIO_CANCEL64, 1, [Have aio_cancel64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
-
- AC_MSG_CHECKING(for aio_suspend64)
- AC_LINK_IFELSE([#include <aio.h>
-int main() { struct aiocb a; return aio_suspend64(&a, 1, NULL); }],
-[AC_DEFINE(HAVE_AIO_SUSPEND64, 1, [Have aio_suspend64]) AC_MSG_RESULT(yes)],
-[AC_MSG_RESULT(no)])
- fi
;;
esac
;;
x"$samba_cv_msghdr_msg_acctright" = x"yes"; then
default_shared_modules="$default_shared_modules vfs_aio_fork"
fi
+
+# Check for Linux kernel aio support.
+ case "$host_os" in
+ *linux*)
+ AC_CHECK_LIB(aio,io_submit,[AIO_LIBS="$LIBS -laio"])
+ AC_CACHE_CHECK([for Linux kernel asynchronous io support],samba_cv_HAVE_LINUX_KERNEL_AIO,[
+ aio_LIBS=$LIBS
+ LIBS=$AIO_LIBS
+ AC_TRY_LINK([#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/eventfd.h>
+#include <libaio.h>],
+[ struct io_event ioev;
+struct iocb *ioc;
+io_context_t ctx;
+struct timespec ts;
+int fd;
+char *buf;
+fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+io_queue_init(128,&ctx);
+io_prep_pwrite(ioc, 1, buf, 1, 0);
+io_prep_pread(ioc, 1, buf, 1, 0);
+io_set_eventfd(ioc, fd);
+io_set_callback(ioc, (io_callback_t)(0));
+io_submit(ctx, 1, &ioc);
+io_getevents(ctx, 1, 1, &ioev, &ts);],
+samba_cv_HAVE_LINUX_KERNEL_AIO=yes,samba_cv_HAVE_LINUX_KERNEL_AIO=no)
+ LIBS=$aio_LIBS])
+ if test x"$samba_cv_HAVE_LINUX_KERNEL_AIO" = x"yes"; then
+ AC_DEFINE(WITH_AIO, 1, [Using asynchronous io])
+ default_shared_modules="$default_shared_modules vfs_aio_linux"
+ fi
+ ;;
+ esac
fi
#################################################
case "$host_os" in
*linux* | gnu* | k*bsd*-gnu | kopensolaris*-gnu)
- AC_CACHE_CHECK([for linux sendfile64 support],samba_cv_HAVE_SENDFILE64,[
- AC_TRY_LINK([#include <sys/sendfile.h>],
-[\
-int tofd, fromfd;
-off64_t offset;
-size_t total;
-ssize_t nwritten = sendfile64(tofd, fromfd, &offset, total);
-],
-samba_cv_HAVE_SENDFILE64=yes,samba_cv_HAVE_SENDFILE64=no)])
-
AC_CACHE_CHECK([for linux sendfile support],samba_cv_HAVE_SENDFILE,[
AC_TRY_LINK([#include <sys/sendfile.h>],
[\
],
samba_cv_HAVE_BROKEN_LINUX_SENDFILE=yes,samba_cv_HAVE_BROKEN_LINUX_SENDFILE=no)])
- if test x"$samba_cv_HAVE_SENDFILE64" = x"yes"; then
- AC_DEFINE(HAVE_SENDFILE64,1,[Whether 64-bit sendfile() is available])
- AC_DEFINE(LINUX_SENDFILE_API,1,[Whether linux sendfile() API is available])
- AC_DEFINE(WITH_SENDFILE,1,[Whether sendfile() should be used])
- elif test x"$samba_cv_HAVE_SENDFILE" = x"yes"; then
+ if test x"$samba_cv_HAVE_SENDFILE" = x"yes"; then
AC_DEFINE(HAVE_SENDFILE,1,[Whether sendfile() is available])
AC_DEFINE(LINUX_SENDFILE_API,1,[Whether linux sendfile() API is available])
AC_DEFINE(WITH_SENDFILE,1,[Whether sendfile() should be used])
;;
*hpux*)
- AC_CACHE_CHECK([for hpux sendfile64 support],samba_cv_HAVE_SENDFILE64,[
- AC_TRY_LINK([\
-#include <sys/socket.h>
-#include <sys/uio.h>],
-[\
- int fromfd, tofd;
- size_t total=0;
- struct iovec hdtrl[2];
- ssize_t nwritten;
- off64_t offset;
-
- hdtrl[0].iov_base = 0;
- hdtrl[0].iov_len = 0;
-
- nwritten = sendfile64(tofd, fromfd, offset, total, &hdtrl[0], 0);
-],
-samba_cv_HAVE_SENDFILE64=yes,samba_cv_HAVE_SENDFILE64=no)])
- if test x"$samba_cv_HAVE_SENDFILE64" = x"yes"; then
- AC_DEFINE(HAVE_SENDFILE64,1,[Whether sendfile64() is available])
- AC_DEFINE(HPUX_SENDFILE_API,1,[Whether the hpux sendfile() API is available])
- AC_DEFINE(WITH_SENDFILE,1,[Whether sendfile() support should be included])
- else
- AC_MSG_RESULT(no);
- fi
-
AC_CACHE_CHECK([for hpux sendfile support],samba_cv_HAVE_SENDFILE,[
AC_TRY_LINK([\
#include <sys/socket.h>
*solaris*)
AC_CHECK_LIB(sendfile,sendfilev)
- AC_CACHE_CHECK([for solaris sendfilev64 support],samba_cv_HAVE_SENDFILEV64,[
- AC_TRY_LINK([\
-#include <sys/sendfile.h>],
-[\
- int sfvcnt;
- size_t xferred;
- struct sendfilevec vec[2];
- ssize_t nwritten;
- int tofd;
-
- sfvcnt = 2;
-
- vec[0].sfv_fd = SFV_FD_SELF;
- vec[0].sfv_flag = 0;
- vec[0].sfv_off = 0;
- vec[0].sfv_len = 0;
-
- vec[1].sfv_fd = 0;
- vec[1].sfv_flag = 0;
- vec[1].sfv_off = 0;
- vec[1].sfv_len = 0;
- nwritten = sendfilev64(tofd, vec, sfvcnt, &xferred);
-],
-samba_cv_HAVE_SENDFILEV64=yes,samba_cv_HAVE_SENDFILEV64=no)])
-
- if test x"$samba_cv_HAVE_SENDFILEV64" = x"yes"; then
- AC_DEFINE(HAVE_SENDFILEV64,1,[Whether sendfilev64() is available])
- AC_DEFINE(SOLARIS_SENDFILE_API,1,[Whether the soloris sendfile() API is available])
- AC_DEFINE(WITH_SENDFILE,1,[Whether sendfile() support should be included])
- else
- AC_MSG_RESULT(no);
- fi
-
AC_CACHE_CHECK([for solaris sendfilev support],samba_cv_HAVE_SENDFILEV,[
AC_TRY_LINK([\
#include <sys/sendfile.h>],
size_t total=0;
struct sf_parms hdtrl;
ssize_t nwritten;
- off64_t offset;
hdtrl.header_data = 0;
hdtrl.header_length = 0;
SMB_MODULE(auth_unix, \$(AUTH_UNIX_OBJ), "bin/unix.$SHLIBEXT", AUTH)
SMB_MODULE(auth_winbind, \$(AUTH_WINBIND_OBJ), "bin/winbind.$SHLIBEXT", AUTH)
SMB_MODULE(auth_wbc, \$(AUTH_WBC_OBJ), "bin/wbc.$SHLIBEXT", AUTH)
-SMB_MODULE(auth_server, \$(AUTH_SERVER_OBJ), "bin/smbserver.$SHLIBEXT", AUTH)
SMB_MODULE(auth_domain, \$(AUTH_DOMAIN_OBJ), "bin/domain.$SHLIBEXT", AUTH)
SMB_MODULE(auth_builtin, \$(AUTH_BUILTIN_OBJ), "bin/builtin.$SHLIBEXT", AUTH)
SMB_MODULE(auth_script, \$(AUTH_SCRIPT_OBJ), "bin/script.$SHLIBEXT", AUTH)
SMB_MODULE(vfs_fileid, \$(VFS_FILEID_OBJ), "bin/fileid.$SHLIBEXT", VFS)
SMB_MODULE(vfs_aio_fork, \$(VFS_AIO_FORK_OBJ), "bin/aio_fork.$SHLIBEXT", VFS)
SMB_MODULE(vfs_aio_pthread, \$(VFS_AIO_PTHREAD_OBJ), "bin/aio_pthread.$SHLIBEXT", VFS)
+SMB_MODULE(vfs_aio_linux, \$(VFS_AIO_LINUX_OBJ), "bin/aio_linux.$SHLIBEXT", VFS)
SMB_MODULE(vfs_preopen, \$(VFS_PREOPEN_OBJ), "bin/preopen.$SHLIBEXT", VFS)
SMB_MODULE(vfs_syncops, \$(VFS_SYNCOPS_OBJ), "bin/syncops.$SHLIBEXT", VFS)
SMB_MODULE(vfs_zfsacl, \$(VFS_ZFSACL_OBJ), "bin/zfsacl.$SHLIBEXT", VFS)
SMB_MODULE(vfs_acl_xattr, \$(VFS_ACL_XATTR_OBJ), "bin/acl_xattr.$SHLIBEXT", VFS)
SMB_MODULE(vfs_acl_tdb, \$(VFS_ACL_TDB_OBJ), "bin/acl_tdb.$SHLIBEXT", VFS)
SMB_MODULE(vfs_smb_traffic_analyzer, \$(VFS_SMB_TRAFFIC_ANALYZER_OBJ), "bin/smb_traffic_analyzer.$SHLIBEXT", VFS)
-SMB_MODULE(vfs_onefs, \$(VFS_ONEFS), "bin/onefs.$SHLIBEXT", VFS)
-SMB_MODULE(vfs_onefs_shadow_copy, \$(VFS_ONEFS_SHADOW_COPY), "bin/onefs_shadow_copy.$SHLIBEXT", VFS)
SMB_MODULE(vfs_dirsort, \$(VFS_DIRSORT_OBJ), "bin/dirsort.$SHLIBEXT", VFS)
SMB_MODULE(vfs_scannedonly, \$(VFS_SCANNEDONLY_OBJ), "bin/scannedonly.$SHLIBEXT", VFS)
SMB_MODULE(vfs_crossrename, \$(VFS_CROSSRENAME_OBJ), "bin/crossrename.$SHLIBEXT", VFS)
SMB_SUBSYSTEM(VFS,smbd/vfs.o)
-SMB_MODULE(perfcount_onefs, \$(PERFCOUNT_ONEFS), "bin/pc_onefs.$SHLIBEXT", PERFCOUNT)
SMB_MODULE(perfcount_test, \$(PERFCOUNT_TEST), "bin/pc_test.$SHLIBEXT", PERFCOUNT)
SMB_SUBSYSTEM(PERFCOUNT,smbd/perfcount.o)