← Back to branch summary

~ubuntu-branches/ubuntu/maverick/samba/maverick-security

« back to all changes in this revision

Viewing changes to source/configure

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2009-03-03 22:02:23 UTC
  • mfrom: (0.28.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090303220223-3bdlm2d9fwx1p1ye
Tags: 2:3.3.1-1ubuntu1
https://launchpad.net/bugs/337094
* Merge from Debian unstable (LP: #337094), remaining changes:
  + debian/patches/VERSION.patch:
    - setup SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksambapasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd.
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against ctdb.
  + debian/rules:
    - enable "native" PIE hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
* Dropped changes, merged in Debian:
  + debian/libpam-smbpass.pam-config, debian/libpam-smbpass.postinst,
    debian/libpam-smbpass.prerm, debian/libpam-smbpass.files,
    debian/rules:
    - Make libpam-smbpasswd depend on libpam-runtime to allow 
      libpam-smbpasswd for auto-configuration.
  + debian/control:
    - Provide a config block for the new PAM framework to auto-configure
      itself
  + debian/samba.postinst:
    - When populating the new sambashare group, it is not an error
      if the user simply does not exist; test for this case and let
      the install continue instead of aborting.
  + debian/winbind.files:
    - include additional files

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/configure
672
672
WINBIND_WINS_NSS
673
673
WINBIND_NSS
674
674
WINBIND_NSS_PTHREAD
 
675
CTDB_CFLAGS
675
676
LIBADDNS_SOVER
676
677
UNINSTALL_LIBADDNS
677
678
INSTALL_LIBADDNS
833
834
codepagedir
834
835
swatdir
835
836
privatedir
836
 
ctdbdir
837
837
logfilebase
838
838
piddir
839
839
lockdir
901
901
with_swatdir
902
902
with_configdir
903
903
with_logfilebase
904
 
with_ctdb
905
904
with_modulesdir
906
905
with_pammodulesdir
907
906
with_mandir
955
954
with_libsmbclient
956
955
with_libsmbsharemodes
957
956
with_libaddns
 
957
with_ctdb
958
958
with_cluster_support
959
959
with_acl_support
960
960
with_aio_support
1638
1638
  --with-swatdir=DIR      Where to put SWAT files ($ac_default_prefix/swat)
1639
1639
  --with-configdir=DIR    Where to put configuration files ($libdir)
1640
1640
  --with-logfilebase=DIR  Where to put log files ($VARDIR)
1641
 
  --with-ctdb=DIR         Where to find ctdb sources
1642
1641
  --with-modulesdir=DIR   Where to put shared modules ($libdir)
1643
1642
  --with-pammodulesdir=DIR
1644
1643
                          Which directory to use for PAM modules
1695
1694
                          shared libs supported)
1696
1695
  --with-libaddns         Build the libaddns shared library (default=no
1697
1696
                          (undefined API))
1698
 
  --with-cluster-support  Enable cluster extensions (default=no)
 
1697
  --with-ctdb=DIR         Where to find ctdb sources
 
1698
  --with-cluster-support  Enable cluster extensions (default=auto)
1699
1699
  --with-acl-support      Include ACL support (default=auto)
1700
1700
  --with-aio-support      Include asynchronous io support (default=no)
1701
1701
  --with-sendfile-support Check for sendfile support (default=yes)
2582
2582
 
2583
2583
 
2584
2584
#################################################
2585
 
# set ctdb source directory location
2586
 
 
2587
 
# Check whether --with-ctdb was given.
2588
 
if test "${with_ctdb+set}" = set; then
2589
 
  withval=$with_ctdb;  case "$withval" in
2590
 
  yes|no)
2591
 
    { $as_echo "$as_me:$LINENO: WARNING: --with-ctdb called without argument" >&5
2592
 
$as_echo "$as_me: WARNING: --with-ctdb called without argument" >&2;}
2593
 
  ;;
2594
 
  * )
2595
 
    ctdbdir="$withval"
2596
 
    ;;
2597
 
  esac
2598
 
fi
2599
 
 
2600
2585
 
2601
2586
#################################################
2602
2587
# set shared modules (internal lib) directory location
2695
2680
 
2696
2681
 
2697
2682
 
2698
 
 
2699
2683
#################################################
2700
2684
# set prefix for 'make test'
2701
2685
selftest_prefix="./st"
11976
11960
if test "x$debug" = "xyes" ; then
11977
11961
        CFLAGS="${CFLAGS} -g"
11978
11962
else
11979
 
        CFLAGS="-O"
 
11963
        CFLAGS="${CFLAGS} -O"
11980
11964
fi
11981
11965
 
11982
11966
CFLAGS="${CFLAGS} -D_SAMBA_BUILD_=3"
24368
24352
done
24369
24353
 
24370
24354
 
24371
 
 
24372
 
 
24373
 
 
24374
 
for ac_header in netinet/ip.h netinet/tcp.h netinet/in_systm.h netinet/in_ip.h
 
24355
for ac_header in netinet/in_systm.h
 
24356
do
 
24357
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
24358
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
24359
  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
 
24360
$as_echo_n "checking for $ac_header... " >&6; }
 
24361
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
24362
  $as_echo_n "(cached) " >&6
 
24363
fi
 
24364
ac_res=`eval 'as_val=${'$as_ac_Header'}
 
24365
                 $as_echo "$as_val"'`
 
24366
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
24367
$as_echo "$ac_res" >&6; }
 
24368
else
 
24369
  # Is the header compilable?
 
24370
{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
 
24371
$as_echo_n "checking $ac_header usability... " >&6; }
 
24372
cat >conftest.$ac_ext <<_ACEOF
 
24373
/* confdefs.h.  */
 
24374
_ACEOF
 
24375
cat confdefs.h >>conftest.$ac_ext
 
24376
cat >>conftest.$ac_ext <<_ACEOF
 
24377
/* end confdefs.h.  */
 
24378
$ac_includes_default
 
24379
#include <$ac_header>
 
24380
_ACEOF
 
24381
rm -f conftest.$ac_objext
 
24382
if { (ac_try="$ac_compile"
 
24383
case "(($ac_try" in
 
24384
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24385
  *) ac_try_echo=$ac_try;;
 
24386
esac
 
24387
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
24388
$as_echo "$ac_try_echo") >&5
 
24389
  (eval "$ac_compile") 2>conftest.er1
 
24390
  ac_status=$?
 
24391
  grep -v '^ *+' conftest.er1 >conftest.err
 
24392
  rm -f conftest.er1
 
24393
  cat conftest.err >&5
 
24394
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24395
  (exit $ac_status); } && {
 
24396
         test -z "$ac_c_werror_flag" ||
 
24397
         test ! -s conftest.err
 
24398
       } && test -s conftest.$ac_objext; then
 
24399
  ac_header_compiler=yes
 
24400
else
 
24401
  $as_echo "$as_me: failed program was:" >&5
 
24402
sed 's/^/| /' conftest.$ac_ext >&5
 
24403
 
 
24404
        ac_header_compiler=no
 
24405
fi
 
24406
 
 
24407
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24408
{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
24409
$as_echo "$ac_header_compiler" >&6; }
 
24410
 
 
24411
# Is the header present?
 
24412
{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
 
24413
$as_echo_n "checking $ac_header presence... " >&6; }
 
24414
cat >conftest.$ac_ext <<_ACEOF
 
24415
/* confdefs.h.  */
 
24416
_ACEOF
 
24417
cat confdefs.h >>conftest.$ac_ext
 
24418
cat >>conftest.$ac_ext <<_ACEOF
 
24419
/* end confdefs.h.  */
 
24420
#include <$ac_header>
 
24421
_ACEOF
 
24422
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
24423
case "(($ac_try" in
 
24424
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24425
  *) ac_try_echo=$ac_try;;
 
24426
esac
 
24427
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
24428
$as_echo "$ac_try_echo") >&5
 
24429
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
24430
  ac_status=$?
 
24431
  grep -v '^ *+' conftest.er1 >conftest.err
 
24432
  rm -f conftest.er1
 
24433
  cat conftest.err >&5
 
24434
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24435
  (exit $ac_status); } >/dev/null && {
 
24436
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
24437
         test ! -s conftest.err
 
24438
       }; then
 
24439
  ac_header_preproc=yes
 
24440
else
 
24441
  $as_echo "$as_me: failed program was:" >&5
 
24442
sed 's/^/| /' conftest.$ac_ext >&5
 
24443
 
 
24444
  ac_header_preproc=no
 
24445
fi
 
24446
 
 
24447
rm -f conftest.err conftest.$ac_ext
 
24448
{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
24449
$as_echo "$ac_header_preproc" >&6; }
 
24450
 
 
24451
# So?  What about this header?
 
24452
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
24453
  yes:no: )
 
24454
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
 
24455
$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
24456
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
 
24457
$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
 
24458
    ac_header_preproc=yes
 
24459
    ;;
 
24460
  no:yes:* )
 
24461
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
 
24462
$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
 
24463
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
 
24464
$as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
 
24465
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
 
24466
$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
 
24467
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
 
24468
$as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
 
24469
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
 
24470
$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
 
24471
    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
 
24472
$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
 
24473
    ( cat <<\_ASBOX
 
24474
## ---------------------------------------- ##
 
24475
## Report this to samba-technical@samba.org ##
 
24476
## ---------------------------------------- ##
 
24477
_ASBOX
 
24478
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
24479
    ;;
 
24480
esac
 
24481
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
 
24482
$as_echo_n "checking for $ac_header... " >&6; }
 
24483
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
24484
  $as_echo_n "(cached) " >&6
 
24485
else
 
24486
  eval "$as_ac_Header=\$ac_header_preproc"
 
24487
fi
 
24488
ac_res=`eval 'as_val=${'$as_ac_Header'}
 
24489
                 $as_echo "$as_val"'`
 
24490
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
24491
$as_echo "$ac_res" >&6; }
 
24492
 
 
24493
fi
 
24494
as_val=`eval 'as_val=${'$as_ac_Header'}
 
24495
                 $as_echo "$as_val"'`
 
24496
   if test "x$as_val" = x""yes; then
 
24497
  cat >>confdefs.h <<_ACEOF
 
24498
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
24499
_ACEOF
 
24500
 
 
24501
fi
 
24502
 
 
24503
done
 
24504
 
 
24505
 
 
24506
for ac_header in netinet/ip.h
 
24507
do
 
24508
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
24509
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
 
24510
$as_echo_n "checking for $ac_header... " >&6; }
 
24511
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
24512
  $as_echo_n "(cached) " >&6
 
24513
else
 
24514
  cat >conftest.$ac_ext <<_ACEOF
 
24515
/* confdefs.h.  */
 
24516
_ACEOF
 
24517
cat confdefs.h >>conftest.$ac_ext
 
24518
cat >>conftest.$ac_ext <<_ACEOF
 
24519
/* end confdefs.h.  */
 
24520
#ifdef HAVE_NETINET_IN_H
 
24521
#include <netinet/in.h>
 
24522
#endif
 
24523
#ifdef HAVE_NETINET_IN_SYSTM_H
 
24524
#include <netinet/in_systm.h>
 
24525
#endif
 
24526
 
 
24527
#include <$ac_header>
 
24528
_ACEOF
 
24529
rm -f conftest.$ac_objext
 
24530
if { (ac_try="$ac_compile"
 
24531
case "(($ac_try" in
 
24532
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
24533
  *) ac_try_echo=$ac_try;;
 
24534
esac
 
24535
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
24536
$as_echo "$ac_try_echo") >&5
 
24537
  (eval "$ac_compile") 2>conftest.er1
 
24538
  ac_status=$?
 
24539
  grep -v '^ *+' conftest.er1 >conftest.err
 
24540
  rm -f conftest.er1
 
24541
  cat conftest.err >&5
 
24542
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
24543
  (exit $ac_status); } && {
 
24544
         test -z "$ac_c_werror_flag" ||
 
24545
         test ! -s conftest.err
 
24546
       } && test -s conftest.$ac_objext; then
 
24547
  eval "$as_ac_Header=yes"
 
24548
else
 
24549
  $as_echo "$as_me: failed program was:" >&5
 
24550
sed 's/^/| /' conftest.$ac_ext >&5
 
24551
 
 
24552
        eval "$as_ac_Header=no"
 
24553
fi
 
24554
 
 
24555
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
24556
fi
 
24557
ac_res=`eval 'as_val=${'$as_ac_Header'}
 
24558
                 $as_echo "$as_val"'`
 
24559
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
24560
$as_echo "$ac_res" >&6; }
 
24561
as_val=`eval 'as_val=${'$as_ac_Header'}
 
24562
                 $as_echo "$as_val"'`
 
24563
   if test "x$as_val" = x""yes; then
 
24564
  cat >>confdefs.h <<_ACEOF
 
24565
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
24566
_ACEOF
 
24567
 
 
24568
fi
 
24569
 
 
24570
done
 
24571
 
 
24572
 
 
24573
 
 
24574
for ac_header in netinet/tcp.h netinet/in_ip.h
24375
24575
do
24376
24576
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
24377
24577
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
28648
28848
#include <sys/socket.h>
28649
28849
#include <sys/types.h>
28650
28850
#include <netdb.h>
 
28851
#include <netinet/in.h>
28651
28852
 
28652
28853
int
28653
28854
main ()
44244
44445
 
44245
44446
#################################################
44246
44447
# Check whether struct stat has timestamps with sub-second resolution.
44247
 
# At least IRIX and Solaris have these.
 
44448
# At least IRIX and Solaris have these.  FREEBSD does as well,
 
44449
# but with different members
44248
44450
#
44249
44451
# We check that
44250
44452
#       all of st_mtim, st_atim and st_ctim exist
44253
44455
# There is some conflicting standards weirdness about whether we should use
44254
44456
# "struct timespec" or "timespec_t". Linux doesn't have timespec_t, so we
44255
44457
# prefer struct timespec.
 
44458
{ $as_echo "$as_me:$LINENO: checking whether struct stat has timespec timestamps" >&5
 
44459
$as_echo_n "checking whether struct stat has timespec timestamps... " >&6; }
 
44460
if test "${samba_cv_stat_timespec_hires+set}" = set; then
 
44461
  $as_echo_n "(cached) " >&6
 
44462
else
 
44463
 
 
44464
      cat >conftest.$ac_ext <<_ACEOF
 
44465
/* confdefs.h.  */
 
44466
_ACEOF
 
44467
cat confdefs.h >>conftest.$ac_ext
 
44468
cat >>conftest.$ac_ext <<_ACEOF
 
44469
/* end confdefs.h.  */
 
44470
 
 
44471
#if TIME_WITH_SYS_TIME
 
44472
# include <sys/time.h>
 
44473
# include <time.h>
 
44474
#else
 
44475
# if HAVE_SYS_TIME_H
 
44476
#  include <sys/time.h>
 
44477
# else
 
44478
#  include <time.h>
 
44479
# endif
 
44480
#endif
 
44481
#ifdef HAVE_SYS_STAT_H
 
44482
#include <sys/stat.h>
 
44483
#endif
 
44484
 
 
44485
int
 
44486
main ()
 
44487
{
 
44488
 
 
44489
          struct timespec t;
 
44490
          struct stat s = {0};
 
44491
          t = s.st_mtimespec;
 
44492
          t = s.st_ctimespec;
 
44493
          t = s.st_atimespec;
 
44494
 
 
44495
  ;
 
44496
  return 0;
 
44497
}
 
44498
_ACEOF
 
44499
rm -f conftest.$ac_objext
 
44500
if { (ac_try="$ac_compile"
 
44501
case "(($ac_try" in
 
44502
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
44503
  *) ac_try_echo=$ac_try;;
 
44504
esac
 
44505
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
44506
$as_echo "$ac_try_echo") >&5
 
44507
  (eval "$ac_compile") 2>conftest.er1
 
44508
  ac_status=$?
 
44509
  grep -v '^ *+' conftest.er1 >conftest.err
 
44510
  rm -f conftest.er1
 
44511
  cat conftest.err >&5
 
44512
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
44513
  (exit $ac_status); } && {
 
44514
         test -z "$ac_c_werror_flag" ||
 
44515
         test ! -s conftest.err
 
44516
       } && test -s conftest.$ac_objext; then
 
44517
  samba_cv_stat_timespec_hires=yes
 
44518
else
 
44519
  $as_echo "$as_me: failed program was:" >&5
 
44520
sed 's/^/| /' conftest.$ac_ext >&5
 
44521
 
 
44522
        samba_cv_stat_timespec_hires=no
 
44523
fi
 
44524
 
 
44525
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
44526
 
 
44527
fi
 
44528
{ $as_echo "$as_me:$LINENO: result: $samba_cv_stat_timespec_hires" >&5
 
44529
$as_echo "$samba_cv_stat_timespec_hires" >&6; }
 
44530
 
 
44531
if test x"$samba_cv_stat_timespec_hires" = x"yes" ; then
 
44532
 
 
44533
cat >>confdefs.h <<\_ACEOF
 
44534
#define HAVE_STAT_ST_MTIMESPEC 1
 
44535
_ACEOF
 
44536
 
 
44537
 
 
44538
cat >>confdefs.h <<\_ACEOF
 
44539
#define HAVE_STAT_ST_ATIMESPEC 1
 
44540
_ACEOF
 
44541
 
 
44542
 
 
44543
cat >>confdefs.h <<\_ACEOF
 
44544
#define HAVE_STAT_ST_CTIMESPEC 1
 
44545
_ACEOF
 
44546
 
 
44547
 
 
44548
cat >>confdefs.h <<\_ACEOF
 
44549
#define HAVE_STAT_HIRES_TIMESTAMPS 1
 
44550
_ACEOF
 
44551
 
 
44552
fi
 
44553
 
 
44554
 
44256
44555
 
44257
44556
{ $as_echo "$as_me:$LINENO: checking whether struct stat has sub-second timestamps" >&5
44258
44557
$as_echo_n "checking whether struct stat has sub-second timestamps... " >&6; }
44353
44652
 
44354
44653
fi
44355
44654
 
44356
 
{ $as_echo "$as_me:$LINENO: checking whether struct stat has sub-second timestamps without struct timespec" >&5
44357
 
$as_echo_n "checking whether struct stat has sub-second timestamps without struct timespec... " >&6; }
 
44655
{ $as_echo "$as_me:$LINENO: checking whether struct stat has sub-second timestamps without struct timespec suffixed nsec" >&5
 
44656
$as_echo_n "checking whether struct stat has sub-second timestamps without struct timespec suffixed nsec... " >&6; }
44358
44657
if test "${samba_cv_stat_hires_notimespec+set}" = set; then
44359
44658
  $as_echo_n "(cached) " >&6
44360
44659
else
44415
44714
         test -z "$ac_c_werror_flag" ||
44416
44715
         test ! -s conftest.err
44417
44716
       } && test -s conftest.$ac_objext; then
44418
 
  samba_cv_stat_hires=yes
 
44717
  samba_cv_stat_hires_notimespec=yes
44419
44718
else
44420
44719
  $as_echo "$as_me: failed program was:" >&5
44421
44720
sed 's/^/| /' conftest.$ac_ext >&5
44422
44721
 
44423
 
        samba_cv_stat_hires=no
 
44722
        samba_cv_stat_hires_notimespec=no
44424
44723
fi
44425
44724
 
44426
44725
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
44452
44751
 
44453
44752
fi
44454
44753
 
 
44754
{ $as_echo "$as_me:$LINENO: checking whether struct stat has sub-second timestamps without struct timespec suffixed _n" >&5
 
44755
$as_echo_n "checking whether struct stat has sub-second timestamps without struct timespec suffixed _n... " >&6; }
 
44756
if test "${samba_cv_stat_hires_notimespec_n+set}" = set; then
 
44757
  $as_echo_n "(cached) " >&6
 
44758
else
 
44759
 
 
44760
        cat >conftest.$ac_ext <<_ACEOF
 
44761
/* confdefs.h.  */
 
44762
_ACEOF
 
44763
cat confdefs.h >>conftest.$ac_ext
 
44764
cat >>conftest.$ac_ext <<_ACEOF
 
44765
/* end confdefs.h.  */
 
44766
 
 
44767
#if TIME_WITH_SYS_TIME
 
44768
# include <sys/time.h>
 
44769
# include <time.h>
 
44770
#else
 
44771
# if HAVE_SYS_TIME_H
 
44772
#  include <sys/time.h>
 
44773
# else
 
44774
#  include <time.h>
 
44775
# endif
 
44776
#endif
 
44777
#ifdef HAVE_SYS_STAT_H
 
44778
#include <sys/stat.h>
 
44779
#endif
 
44780
 
 
44781
int
 
44782
main ()
 
44783
{
 
44784
 
 
44785
                struct timespec t;
 
44786
                struct stat s = {0};
 
44787
                t.tv_sec = s.st_mtime;
 
44788
                t.tv_nsec = s.st_mtime_n;
 
44789
                t.tv_sec = s.st_ctime;
 
44790
                t.tv_nsec = s.st_ctime_n;
 
44791
                t.tv_sec = s.st_atime;
 
44792
                t.tv_nsec = s.st_atime_n;
 
44793
 
 
44794
  ;
 
44795
  return 0;
 
44796
}
 
44797
_ACEOF
 
44798
rm -f conftest.$ac_objext
 
44799
if { (ac_try="$ac_compile"
 
44800
case "(($ac_try" in
 
44801
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
44802
  *) ac_try_echo=$ac_try;;
 
44803
esac
 
44804
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
44805
$as_echo "$ac_try_echo") >&5
 
44806
  (eval "$ac_compile") 2>conftest.er1
 
44807
  ac_status=$?
 
44808
  grep -v '^ *+' conftest.er1 >conftest.err
 
44809
  rm -f conftest.er1
 
44810
  cat conftest.err >&5
 
44811
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
44812
  (exit $ac_status); } && {
 
44813
         test -z "$ac_c_werror_flag" ||
 
44814
         test ! -s conftest.err
 
44815
       } && test -s conftest.$ac_objext; then
 
44816
  samba_cv_stat_hires_notimespec_n=yes
 
44817
else
 
44818
  $as_echo "$as_me: failed program was:" >&5
 
44819
sed 's/^/| /' conftest.$ac_ext >&5
 
44820
 
 
44821
        samba_cv_stat_hires_notimespec_n=no
 
44822
fi
 
44823
 
 
44824
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
44825
 
 
44826
fi
 
44827
{ $as_echo "$as_me:$LINENO: result: $samba_cv_stat_hires_notimespec_n" >&5
 
44828
$as_echo "$samba_cv_stat_hires_notimespec_n" >&6; }
 
44829
 
 
44830
if test x"$samba_cv_stat_hires_notimespec_n" = x"yes" ; then
 
44831
 
 
44832
cat >>confdefs.h <<\_ACEOF
 
44833
#define HAVE_STAT_ST_MTIME_N 1
 
44834
_ACEOF
 
44835
 
 
44836
 
 
44837
cat >>confdefs.h <<\_ACEOF
 
44838
#define HAVE_STAT_ST_ATIME_N 1
 
44839
_ACEOF
 
44840
 
 
44841
 
 
44842
cat >>confdefs.h <<\_ACEOF
 
44843
#define HAVE_STAT_ST_CTIME_N 1
 
44844
_ACEOF
 
44845
 
 
44846
 
 
44847
cat >>confdefs.h <<\_ACEOF
 
44848
#define HAVE_STAT_HIRES_TIMESTAMPS 1
 
44849
_ACEOF
 
44850
 
 
44851
fi
 
44852
 
 
44853
{ $as_echo "$as_me:$LINENO: checking whether struct stat has sub-second timestamps in st_uXtime" >&5
 
44854
$as_echo_n "checking whether struct stat has sub-second timestamps in st_uXtime... " >&6; }
 
44855
if test "${samba_cv_stat_hires_uxtime+set}" = set; then
 
44856
  $as_echo_n "(cached) " >&6
 
44857
else
 
44858
 
 
44859
        cat >conftest.$ac_ext <<_ACEOF
 
44860
/* confdefs.h.  */
 
44861
_ACEOF
 
44862
cat confdefs.h >>conftest.$ac_ext
 
44863
cat >>conftest.$ac_ext <<_ACEOF
 
44864
/* end confdefs.h.  */
 
44865
 
 
44866
#if TIME_WITH_SYS_TIME
 
44867
# include <sys/time.h>
 
44868
# include <time.h>
 
44869
#else
 
44870
# if HAVE_SYS_TIME_H
 
44871
#  include <sys/time.h>
 
44872
# else
 
44873
#  include <time.h>
 
44874
# endif
 
44875
#endif
 
44876
#ifdef HAVE_SYS_STAT_H
 
44877
#include <sys/stat.h>
 
44878
#endif
 
44879
 
 
44880
int
 
44881
main ()
 
44882
{
 
44883
 
 
44884
                struct timespec t;
 
44885
                struct stat s = {0};
 
44886
                t.tv_sec = s.st_mtime;
 
44887
                t.tv_nsec = s.st_umtime * 1000;
 
44888
                t.tv_sec = s.st_ctime;
 
44889
                t.tv_nsec = s.st_uctime * 1000;
 
44890
                t.tv_sec = s.st_atime;
 
44891
                t.tv_nsec = s.st_uatime * 1000;
 
44892
 
 
44893
  ;
 
44894
  return 0;
 
44895
}
 
44896
_ACEOF
 
44897
rm -f conftest.$ac_objext
 
44898
if { (ac_try="$ac_compile"
 
44899
case "(($ac_try" in
 
44900
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
44901
  *) ac_try_echo=$ac_try;;
 
44902
esac
 
44903
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
44904
$as_echo "$ac_try_echo") >&5
 
44905
  (eval "$ac_compile") 2>conftest.er1
 
44906
  ac_status=$?
 
44907
  grep -v '^ *+' conftest.er1 >conftest.err
 
44908
  rm -f conftest.er1
 
44909
  cat conftest.err >&5
 
44910
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
44911
  (exit $ac_status); } && {
 
44912
         test -z "$ac_c_werror_flag" ||
 
44913
         test ! -s conftest.err
 
44914
       } && test -s conftest.$ac_objext; then
 
44915
  samba_cv_stat_hires_uxtime=yes
 
44916
else
 
44917
  $as_echo "$as_me: failed program was:" >&5
 
44918
sed 's/^/| /' conftest.$ac_ext >&5
 
44919
 
 
44920
        samba_cv_stat_hires_uxtime=no
 
44921
fi
 
44922
 
 
44923
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
44924
 
 
44925
fi
 
44926
{ $as_echo "$as_me:$LINENO: result: $samba_cv_stat_hires_uxtime" >&5
 
44927
$as_echo "$samba_cv_stat_hires_uxtime" >&6; }
 
44928
 
 
44929
if test x"$samba_cv_stat_hires_uxtime" = x"yes" ; then
 
44930
 
 
44931
cat >>confdefs.h <<\_ACEOF
 
44932
#define HAVE_STAT_ST_UMTIME 1
 
44933
_ACEOF
 
44934
 
 
44935
 
 
44936
cat >>confdefs.h <<\_ACEOF
 
44937
#define HAVE_STAT_ST_UATIME 1
 
44938
_ACEOF
 
44939
 
 
44940
 
 
44941
cat >>confdefs.h <<\_ACEOF
 
44942
#define HAVE_STAT_ST_UCTIME 1
 
44943
_ACEOF
 
44944
 
 
44945
 
 
44946
cat >>confdefs.h <<\_ACEOF
 
44947
#define HAVE_STAT_HIRES_TIMESTAMPS 1
 
44948
_ACEOF
 
44949
 
 
44950
fi
 
44951
 
44455
44952
{ $as_echo "$as_me:$LINENO: checking whether struct stat has st_birthtimespec" >&5
44456
44953
$as_echo_n "checking whether struct stat has st_birthtimespec... " >&6; }
44457
44954
if test "${samba_cv_stat_st_birthtimespec+set}" = set; then
44514
45011
  $as_echo "$as_me: failed program was:" >&5
44515
45012
sed 's/^/| /' conftest.$ac_ext >&5
44516
45013
 
44517
 
        samba_cv_stat_birthtimespec=no
 
45014
        samba_cv_stat_st_birthtimespec=no
44518
45015
fi
44519
45016
 
44520
45017
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
44593
45090
  $as_echo "$as_me: failed program was:" >&5
44594
45091
sed 's/^/| /' conftest.$ac_ext >&5
44595
45092
 
44596
 
        samba_cv_stat_birthtimensec=no
 
45093
        samba_cv_stat_st_birthtimensec=no
44597
45094
fi
44598
45095
 
44599
45096
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
44672
45169
  $as_echo "$as_me: failed program was:" >&5
44673
45170
sed 's/^/| /' conftest.$ac_ext >&5
44674
45171
 
44675
 
        samba_cv_stat_birthtime=no
 
45172
        samba_cv_stat_st_birthtime=no
44676
45173
fi
44677
45174
 
44678
45175
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
49871
50368
                *linux*)
49872
50369
                        LIB_PATH_VAR=LD_LIBRARY_PATH
49873
50370
                ;;
49874
 
                *netbsd*)
 
50371
                *bsd*)
49875
50372
                        LIB_PATH_VAR=LD_LIBRARY_PATH
49876
50373
                ;;
49877
50374
                *solaris*)
72211
72708
 
72212
72709
fi
72213
72710
 
 
72711
# Some systems use f_flag in struct statvfs while others use f_flags
 
72712
{ $as_echo "$as_me:$LINENO: checking that statvfs.statvfs_f_flag works" >&5
 
72713
$as_echo_n "checking that statvfs.statvfs_f_flag works... " >&6; }
 
72714
if test "${samba_cv_statvfs_f_flag+set}" = set; then
 
72715
  $as_echo_n "(cached) " >&6
 
72716
else
 
72717
 
 
72718
    cat >conftest.$ac_ext <<_ACEOF
 
72719
/* confdefs.h.  */
 
72720
_ACEOF
 
72721
cat confdefs.h >>conftest.$ac_ext
 
72722
cat >>conftest.$ac_ext <<_ACEOF
 
72723
/* end confdefs.h.  */
 
72724
#include <sys/types.h>
 
72725
#include <sys/statvfs.h>
 
72726
int
 
72727
main ()
 
72728
{
 
72729
struct statvfs buf; buf.f_flag = 0
 
72730
  ;
 
72731
  return 0;
 
72732
}
 
72733
_ACEOF
 
72734
rm -f conftest.$ac_objext
 
72735
if { (ac_try="$ac_compile"
 
72736
case "(($ac_try" in
 
72737
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
72738
  *) ac_try_echo=$ac_try;;
 
72739
esac
 
72740
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
72741
$as_echo "$ac_try_echo") >&5
 
72742
  (eval "$ac_compile") 2>conftest.er1
 
72743
  ac_status=$?
 
72744
  grep -v '^ *+' conftest.er1 >conftest.err
 
72745
  rm -f conftest.er1
 
72746
  cat conftest.err >&5
 
72747
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
72748
  (exit $ac_status); } && {
 
72749
         test -z "$ac_c_werror_flag" ||
 
72750
         test ! -s conftest.err
 
72751
       } && test -s conftest.$ac_objext; then
 
72752
  samba_cv_statvfs_f_flag=yes
 
72753
else
 
72754
  $as_echo "$as_me: failed program was:" >&5
 
72755
sed 's/^/| /' conftest.$ac_ext >&5
 
72756
 
 
72757
        samba_cv_statvfs_f_flag=no
 
72758
fi
 
72759
 
 
72760
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
72761
fi
 
72762
{ $as_echo "$as_me:$LINENO: result: $samba_cv_statvfs_f_flag" >&5
 
72763
$as_echo "$samba_cv_statvfs_f_flag" >&6; }
 
72764
if test x"$samba_cv_statvfs_f_flag" = x"yes"; then
 
72765
 
 
72766
cat >>confdefs.h <<\_ACEOF
 
72767
#define HAVE_STATVFS_F_FLAG 1
 
72768
_ACEOF
 
72769
 
 
72770
fi
 
72771
 
 
72772
{ $as_echo "$as_me:$LINENO: checking that statvfs.statvfs_f_flags works" >&5
 
72773
$as_echo_n "checking that statvfs.statvfs_f_flags works... " >&6; }
 
72774
if test "${samba_cv_statvfs_f_flags+set}" = set; then
 
72775
  $as_echo_n "(cached) " >&6
 
72776
else
 
72777
 
 
72778
    cat >conftest.$ac_ext <<_ACEOF
 
72779
/* confdefs.h.  */
 
72780
_ACEOF
 
72781
cat confdefs.h >>conftest.$ac_ext
 
72782
cat >>conftest.$ac_ext <<_ACEOF
 
72783
/* end confdefs.h.  */
 
72784
#include <sys/types.h>
 
72785
#include <sys/statvfs.h>
 
72786
int
 
72787
main ()
 
72788
{
 
72789
struct statvfs buf; buf.f_flags = 0
 
72790
  ;
 
72791
  return 0;
 
72792
}
 
72793
_ACEOF
 
72794
rm -f conftest.$ac_objext
 
72795
if { (ac_try="$ac_compile"
 
72796
case "(($ac_try" in
 
72797
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
72798
  *) ac_try_echo=$ac_try;;
 
72799
esac
 
72800
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
72801
$as_echo "$ac_try_echo") >&5
 
72802
  (eval "$ac_compile") 2>conftest.er1
 
72803
  ac_status=$?
 
72804
  grep -v '^ *+' conftest.er1 >conftest.err
 
72805
  rm -f conftest.er1
 
72806
  cat conftest.err >&5
 
72807
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
72808
  (exit $ac_status); } && {
 
72809
         test -z "$ac_c_werror_flag" ||
 
72810
         test ! -s conftest.err
 
72811
       } && test -s conftest.$ac_objext; then
 
72812
  samba_cv_statvfs_f_flags=yes
 
72813
else
 
72814
  $as_echo "$as_me: failed program was:" >&5
 
72815
sed 's/^/| /' conftest.$ac_ext >&5
 
72816
 
 
72817
        samba_cv_statvfs_f_flags=no
 
72818
fi
 
72819
 
 
72820
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
72821
fi
 
72822
{ $as_echo "$as_me:$LINENO: result: $samba_cv_statvfs_f_flags" >&5
 
72823
$as_echo "$samba_cv_statvfs_f_flags" >&6; }
 
72824
if test x"$samba_cv_statvfs_f_flags" = x"yes"; then
 
72825
 
 
72826
cat >>confdefs.h <<\_ACEOF
 
72827
#define HAVE_STATVFS_F_FLAGS 1
 
72828
_ACEOF
 
72829
 
 
72830
fi
 
72831
 
 
72832
 
72214
72833
if test $space = no; then
72215
72834
  # DEC Alpha running OSF/1
72216
72835
  { $as_echo "$as_me:$LINENO: checking for 3-argument statfs function (DEC OSF/1)" >&5
72680
73299
#################################################
72681
73300
# check for cluster extensions
72682
73301
 
72683
 
{ $as_echo "$as_me:$LINENO: checking whether to include cluster support" >&5
72684
 
$as_echo_n "checking whether to include cluster support... " >&6; }
 
73302
CTDB_CFLAGS=""
 
73303
 
 
73304
 
 
73305
# Check whether --with-ctdb was given.
 
73306
if test "${with_ctdb+set}" = set; then
 
73307
  withval=$with_ctdb;  case "$withval" in
 
73308
  yes|no)
 
73309
    { $as_echo "$as_me:$LINENO: WARNING: --with-ctdb called without argument" >&5
 
73310
$as_echo "$as_me: WARNING: --with-ctdb called without argument" >&2;}
 
73311
    ;;
 
73312
  *)
 
73313
    CTDB_CPPFLAGS="-I$withval/include"
 
73314
    ;;
 
73315
  esac
 
73316
fi
 
73317
 
 
73318
 
 
73319
SAVED_CPPFLAGS="$CPPFLAGS"
 
73320
CPPFLAGS="$CPPFLAGS $CTDB_CPPFLAGS"
 
73321
ctdb_broken="missing or broken headers"
 
73322
 
 
73323
 
 
73324
 
 
73325
for ac_header in ctdb.h ctdb_private.h
 
73326
do
 
73327
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
73328
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
 
73329
$as_echo_n "checking for $ac_header... " >&6; }
 
73330
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
 
73331
  $as_echo_n "(cached) " >&6
 
73332
else
 
73333
  cat >conftest.$ac_ext <<_ACEOF
 
73334
/* confdefs.h.  */
 
73335
_ACEOF
 
73336
cat confdefs.h >>conftest.$ac_ext
 
73337
cat >>conftest.$ac_ext <<_ACEOF
 
73338
/* end confdefs.h.  */
 
73339
 
 
73340
#include "confdefs.h"
 
73341
#define NO_CONFIG_H
 
73342
#include "replace.h"
 
73343
#include "system/wait.h"
 
73344
#include "system/network.h"
 
73345
#define private #error __USED_RESERVED_WORD_private__
 
73346
#include <talloc.h>
 
73347
#include <tdb.h>
 
73348
#include <ctdb.h>
 
73349
 
 
73350
 
 
73351
#include <$ac_header>
 
73352
_ACEOF
 
73353
rm -f conftest.$ac_objext
 
73354
if { (ac_try="$ac_compile"
 
73355
case "(($ac_try" in
 
73356
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73357
  *) ac_try_echo=$ac_try;;
 
73358
esac
 
73359
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73360
$as_echo "$ac_try_echo") >&5
 
73361
  (eval "$ac_compile") 2>conftest.er1
 
73362
  ac_status=$?
 
73363
  grep -v '^ *+' conftest.er1 >conftest.err
 
73364
  rm -f conftest.er1
 
73365
  cat conftest.err >&5
 
73366
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73367
  (exit $ac_status); } && {
 
73368
         test -z "$ac_c_werror_flag" ||
 
73369
         test ! -s conftest.err
 
73370
       } && test -s conftest.$ac_objext; then
 
73371
  eval "$as_ac_Header=yes"
 
73372
else
 
73373
  $as_echo "$as_me: failed program was:" >&5
 
73374
sed 's/^/| /' conftest.$ac_ext >&5
 
73375
 
 
73376
        eval "$as_ac_Header=no"
 
73377
fi
 
73378
 
 
73379
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73380
fi
 
73381
ac_res=`eval 'as_val=${'$as_ac_Header'}
 
73382
                 $as_echo "$as_val"'`
 
73383
               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
 
73384
$as_echo "$ac_res" >&6; }
 
73385
as_val=`eval 'as_val=${'$as_ac_Header'}
 
73386
                 $as_echo "$as_val"'`
 
73387
   if test "x$as_val" = x""yes; then
 
73388
  cat >>confdefs.h <<_ACEOF
 
73389
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
73390
_ACEOF
 
73391
 
 
73392
fi
 
73393
 
 
73394
done
 
73395
 
 
73396
 
 
73397
 
 
73398
 { $as_echo "$as_me:$LINENO: checking for CTDB_CONTROL_TRANS2_COMMIT_RETRY declaration" >&5
 
73399
$as_echo_n "checking for CTDB_CONTROL_TRANS2_COMMIT_RETRY declaration... " >&6; }
 
73400
if test "${ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl+set}" = set; then
 
73401
  $as_echo_n "(cached) " >&6
 
73402
else
 
73403
 
 
73404
    cat >conftest.$ac_ext <<_ACEOF
 
73405
/* confdefs.h.  */
 
73406
_ACEOF
 
73407
cat confdefs.h >>conftest.$ac_ext
 
73408
cat >>conftest.$ac_ext <<_ACEOF
 
73409
/* end confdefs.h.  */
 
73410
 
 
73411
#include "confdefs.h"
 
73412
#define NO_CONFIG_H
 
73413
#include "replace.h"
 
73414
#include "system/wait.h"
 
73415
#include "system/network.h"
 
73416
#include <talloc.h>
 
73417
#include <tdb.h>
 
73418
#include <ctdb.h>
 
73419
#include <ctdb_private.h>
 
73420
 
 
73421
int
 
73422
main ()
 
73423
{
 
73424
int i = (int)CTDB_CONTROL_TRANS2_COMMIT_RETRY
 
73425
  ;
 
73426
  return 0;
 
73427
}
 
73428
_ACEOF
 
73429
rm -f conftest.$ac_objext
 
73430
if { (ac_try="$ac_compile"
 
73431
case "(($ac_try" in
 
73432
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73433
  *) ac_try_echo=$ac_try;;
 
73434
esac
 
73435
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73436
$as_echo "$ac_try_echo") >&5
 
73437
  (eval "$ac_compile") 2>conftest.er1
 
73438
  ac_status=$?
 
73439
  grep -v '^ *+' conftest.er1 >conftest.err
 
73440
  rm -f conftest.er1
 
73441
  cat conftest.err >&5
 
73442
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73443
  (exit $ac_status); } && {
 
73444
         test -z "$ac_c_werror_flag" ||
 
73445
         test ! -s conftest.err
 
73446
       } && test -s conftest.$ac_objext; then
 
73447
  ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl=yes
 
73448
else
 
73449
  $as_echo "$as_me: failed program was:" >&5
 
73450
sed 's/^/| /' conftest.$ac_ext >&5
 
73451
 
 
73452
        ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl=no
 
73453
fi
 
73454
 
 
73455
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73456
fi
 
73457
{ $as_echo "$as_me:$LINENO: result: $ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl" >&5
 
73458
$as_echo "$ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl" >&6; }
 
73459
 if test x"$ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl" = x"yes"; then
 
73460
 
 
73461
cat >>confdefs.h <<\_ACEOF
 
73462
#define HAVE_CTDB_CONTROL_TRANS2_COMMIT_RETRY_DECL 1
 
73463
_ACEOF
 
73464
 
 
73465
 fi
 
73466
 
 
73467
if test x"$ac_cv_have_CTDB_CONTROL_TRANS2_COMMIT_RETRY_decl" = x"yes"; then
 
73468
        ctdb_broken=no
 
73469
else
 
73470
        ctdb_broken="missing transaction support"
 
73471
fi
 
73472
 
 
73473
# in ctdb 1.0.57 ctdb_control_tcp was temparary renamed to ctdb_tcp_client
 
73474
{ $as_echo "$as_me:$LINENO: checking for struct ctdb_tcp_client" >&5
 
73475
$as_echo_n "checking for struct ctdb_tcp_client... " >&6; }
 
73476
if test "${ac_cv_type_struct_ctdb_tcp_client+set}" = set; then
 
73477
  $as_echo_n "(cached) " >&6
 
73478
else
 
73479
  ac_cv_type_struct_ctdb_tcp_client=no
 
73480
cat >conftest.$ac_ext <<_ACEOF
 
73481
/* confdefs.h.  */
 
73482
_ACEOF
 
73483
cat confdefs.h >>conftest.$ac_ext
 
73484
cat >>conftest.$ac_ext <<_ACEOF
 
73485
/* end confdefs.h.  */
 
73486
 
 
73487
#include "confdefs.h"
 
73488
#define NO_CONFIG_H
 
73489
#include "replace.h"
 
73490
#include "system/wait.h"
 
73491
#include "system/network.h"
 
73492
#include <talloc.h>
 
73493
#include <tdb.h>
 
73494
#include <ctdb.h>
 
73495
#include <ctdb_private.h>
 
73496
 
 
73497
 
 
73498
int
 
73499
main ()
 
73500
{
 
73501
if (sizeof (struct ctdb_tcp_client))
 
73502
       return 0;
 
73503
  ;
 
73504
  return 0;
 
73505
}
 
73506
_ACEOF
 
73507
rm -f conftest.$ac_objext
 
73508
if { (ac_try="$ac_compile"
 
73509
case "(($ac_try" in
 
73510
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73511
  *) ac_try_echo=$ac_try;;
 
73512
esac
 
73513
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73514
$as_echo "$ac_try_echo") >&5
 
73515
  (eval "$ac_compile") 2>conftest.er1
 
73516
  ac_status=$?
 
73517
  grep -v '^ *+' conftest.er1 >conftest.err
 
73518
  rm -f conftest.er1
 
73519
  cat conftest.err >&5
 
73520
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73521
  (exit $ac_status); } && {
 
73522
         test -z "$ac_c_werror_flag" ||
 
73523
         test ! -s conftest.err
 
73524
       } && test -s conftest.$ac_objext; then
 
73525
  cat >conftest.$ac_ext <<_ACEOF
 
73526
/* confdefs.h.  */
 
73527
_ACEOF
 
73528
cat confdefs.h >>conftest.$ac_ext
 
73529
cat >>conftest.$ac_ext <<_ACEOF
 
73530
/* end confdefs.h.  */
 
73531
 
 
73532
#include "confdefs.h"
 
73533
#define NO_CONFIG_H
 
73534
#include "replace.h"
 
73535
#include "system/wait.h"
 
73536
#include "system/network.h"
 
73537
#include <talloc.h>
 
73538
#include <tdb.h>
 
73539
#include <ctdb.h>
 
73540
#include <ctdb_private.h>
 
73541
 
 
73542
 
 
73543
int
 
73544
main ()
 
73545
{
 
73546
if (sizeof ((struct ctdb_tcp_client)))
 
73547
          return 0;
 
73548
  ;
 
73549
  return 0;
 
73550
}
 
73551
_ACEOF
 
73552
rm -f conftest.$ac_objext
 
73553
if { (ac_try="$ac_compile"
 
73554
case "(($ac_try" in
 
73555
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73556
  *) ac_try_echo=$ac_try;;
 
73557
esac
 
73558
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73559
$as_echo "$ac_try_echo") >&5
 
73560
  (eval "$ac_compile") 2>conftest.er1
 
73561
  ac_status=$?
 
73562
  grep -v '^ *+' conftest.er1 >conftest.err
 
73563
  rm -f conftest.er1
 
73564
  cat conftest.err >&5
 
73565
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73566
  (exit $ac_status); } && {
 
73567
         test -z "$ac_c_werror_flag" ||
 
73568
         test ! -s conftest.err
 
73569
       } && test -s conftest.$ac_objext; then
 
73570
  :
 
73571
else
 
73572
  $as_echo "$as_me: failed program was:" >&5
 
73573
sed 's/^/| /' conftest.$ac_ext >&5
 
73574
 
 
73575
        ac_cv_type_struct_ctdb_tcp_client=yes
 
73576
fi
 
73577
 
 
73578
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73579
else
 
73580
  $as_echo "$as_me: failed program was:" >&5
 
73581
sed 's/^/| /' conftest.$ac_ext >&5
 
73582
 
 
73583
 
 
73584
fi
 
73585
 
 
73586
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73587
fi
 
73588
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_struct_ctdb_tcp_client" >&5
 
73589
$as_echo "$ac_cv_type_struct_ctdb_tcp_client" >&6; }
 
73590
if test "x$ac_cv_type_struct_ctdb_tcp_client" = x""yes; then
 
73591
 
 
73592
 
 
73593
cat >>confdefs.h <<\_ACEOF
 
73594
#define ctdb_control_tcp ctdb_tcp_client
 
73595
_ACEOF
 
73596
 
 
73597
 
 
73598
fi
 
73599
 
 
73600
 
 
73601
{ $as_echo "$as_me:$LINENO: checking for struct ctdb_control_tcp" >&5
 
73602
$as_echo_n "checking for struct ctdb_control_tcp... " >&6; }
 
73603
if test "${ac_cv_type_struct_ctdb_control_tcp+set}" = set; then
 
73604
  $as_echo_n "(cached) " >&6
 
73605
else
 
73606
  ac_cv_type_struct_ctdb_control_tcp=no
 
73607
cat >conftest.$ac_ext <<_ACEOF
 
73608
/* confdefs.h.  */
 
73609
_ACEOF
 
73610
cat confdefs.h >>conftest.$ac_ext
 
73611
cat >>conftest.$ac_ext <<_ACEOF
 
73612
/* end confdefs.h.  */
 
73613
 
 
73614
#include "confdefs.h"
 
73615
#define NO_CONFIG_H
 
73616
#include "replace.h"
 
73617
#include "system/wait.h"
 
73618
#include "system/network.h"
 
73619
#include <talloc.h>
 
73620
#include <tdb.h>
 
73621
#include <ctdb.h>
 
73622
#include <ctdb_private.h>
 
73623
 
 
73624
 
 
73625
int
 
73626
main ()
 
73627
{
 
73628
if (sizeof (struct ctdb_control_tcp))
 
73629
       return 0;
 
73630
  ;
 
73631
  return 0;
 
73632
}
 
73633
_ACEOF
 
73634
rm -f conftest.$ac_objext
 
73635
if { (ac_try="$ac_compile"
 
73636
case "(($ac_try" in
 
73637
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73638
  *) ac_try_echo=$ac_try;;
 
73639
esac
 
73640
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73641
$as_echo "$ac_try_echo") >&5
 
73642
  (eval "$ac_compile") 2>conftest.er1
 
73643
  ac_status=$?
 
73644
  grep -v '^ *+' conftest.er1 >conftest.err
 
73645
  rm -f conftest.er1
 
73646
  cat conftest.err >&5
 
73647
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73648
  (exit $ac_status); } && {
 
73649
         test -z "$ac_c_werror_flag" ||
 
73650
         test ! -s conftest.err
 
73651
       } && test -s conftest.$ac_objext; then
 
73652
  cat >conftest.$ac_ext <<_ACEOF
 
73653
/* confdefs.h.  */
 
73654
_ACEOF
 
73655
cat confdefs.h >>conftest.$ac_ext
 
73656
cat >>conftest.$ac_ext <<_ACEOF
 
73657
/* end confdefs.h.  */
 
73658
 
 
73659
#include "confdefs.h"
 
73660
#define NO_CONFIG_H
 
73661
#include "replace.h"
 
73662
#include "system/wait.h"
 
73663
#include "system/network.h"
 
73664
#include <talloc.h>
 
73665
#include <tdb.h>
 
73666
#include <ctdb.h>
 
73667
#include <ctdb_private.h>
 
73668
 
 
73669
 
 
73670
int
 
73671
main ()
 
73672
{
 
73673
if (sizeof ((struct ctdb_control_tcp)))
 
73674
          return 0;
 
73675
  ;
 
73676
  return 0;
 
73677
}
 
73678
_ACEOF
 
73679
rm -f conftest.$ac_objext
 
73680
if { (ac_try="$ac_compile"
 
73681
case "(($ac_try" in
 
73682
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73683
  *) ac_try_echo=$ac_try;;
 
73684
esac
 
73685
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73686
$as_echo "$ac_try_echo") >&5
 
73687
  (eval "$ac_compile") 2>conftest.er1
 
73688
  ac_status=$?
 
73689
  grep -v '^ *+' conftest.er1 >conftest.err
 
73690
  rm -f conftest.er1
 
73691
  cat conftest.err >&5
 
73692
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73693
  (exit $ac_status); } && {
 
73694
         test -z "$ac_c_werror_flag" ||
 
73695
         test ! -s conftest.err
 
73696
       } && test -s conftest.$ac_objext; then
 
73697
  :
 
73698
else
 
73699
  $as_echo "$as_me: failed program was:" >&5
 
73700
sed 's/^/| /' conftest.$ac_ext >&5
 
73701
 
 
73702
        ac_cv_type_struct_ctdb_control_tcp=yes
 
73703
fi
 
73704
 
 
73705
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73706
else
 
73707
  $as_echo "$as_me: failed program was:" >&5
 
73708
sed 's/^/| /' conftest.$ac_ext >&5
 
73709
 
 
73710
 
 
73711
fi
 
73712
 
 
73713
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73714
fi
 
73715
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_struct_ctdb_control_tcp" >&5
 
73716
$as_echo "$ac_cv_type_struct_ctdb_control_tcp" >&6; }
 
73717
if test "x$ac_cv_type_struct_ctdb_control_tcp" = x""yes; then
 
73718
 
 
73719
 
 
73720
cat >>confdefs.h <<\_ACEOF
 
73721
#define HAVE_STRUCT_CTDB_CONTROL_TCP 1
 
73722
_ACEOF
 
73723
 
 
73724
 
 
73725
else
 
73726
 
 
73727
        ctdb_broken="missing struct ctdb_control_tcp"
 
73728
 
 
73729
fi
 
73730
 
 
73731
 
 
73732
{ $as_echo "$as_me:$LINENO: checking for struct ctdb_control_tcp_addr" >&5
 
73733
$as_echo_n "checking for struct ctdb_control_tcp_addr... " >&6; }
 
73734
if test "${ac_cv_type_struct_ctdb_control_tcp_addr+set}" = set; then
 
73735
  $as_echo_n "(cached) " >&6
 
73736
else
 
73737
  ac_cv_type_struct_ctdb_control_tcp_addr=no
 
73738
cat >conftest.$ac_ext <<_ACEOF
 
73739
/* confdefs.h.  */
 
73740
_ACEOF
 
73741
cat confdefs.h >>conftest.$ac_ext
 
73742
cat >>conftest.$ac_ext <<_ACEOF
 
73743
/* end confdefs.h.  */
 
73744
 
 
73745
#include "confdefs.h"
 
73746
#define NO_CONFIG_H
 
73747
#include "replace.h"
 
73748
#include "system/wait.h"
 
73749
#include "system/network.h"
 
73750
#include <talloc.h>
 
73751
#include <tdb.h>
 
73752
#include <ctdb.h>
 
73753
#include <ctdb_private.h>
 
73754
 
 
73755
 
 
73756
int
 
73757
main ()
 
73758
{
 
73759
if (sizeof (struct ctdb_control_tcp_addr))
 
73760
       return 0;
 
73761
  ;
 
73762
  return 0;
 
73763
}
 
73764
_ACEOF
 
73765
rm -f conftest.$ac_objext
 
73766
if { (ac_try="$ac_compile"
 
73767
case "(($ac_try" in
 
73768
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73769
  *) ac_try_echo=$ac_try;;
 
73770
esac
 
73771
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73772
$as_echo "$ac_try_echo") >&5
 
73773
  (eval "$ac_compile") 2>conftest.er1
 
73774
  ac_status=$?
 
73775
  grep -v '^ *+' conftest.er1 >conftest.err
 
73776
  rm -f conftest.er1
 
73777
  cat conftest.err >&5
 
73778
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73779
  (exit $ac_status); } && {
 
73780
         test -z "$ac_c_werror_flag" ||
 
73781
         test ! -s conftest.err
 
73782
       } && test -s conftest.$ac_objext; then
 
73783
  cat >conftest.$ac_ext <<_ACEOF
 
73784
/* confdefs.h.  */
 
73785
_ACEOF
 
73786
cat confdefs.h >>conftest.$ac_ext
 
73787
cat >>conftest.$ac_ext <<_ACEOF
 
73788
/* end confdefs.h.  */
 
73789
 
 
73790
#include "confdefs.h"
 
73791
#define NO_CONFIG_H
 
73792
#include "replace.h"
 
73793
#include "system/wait.h"
 
73794
#include "system/network.h"
 
73795
#include <talloc.h>
 
73796
#include <tdb.h>
 
73797
#include <ctdb.h>
 
73798
#include <ctdb_private.h>
 
73799
 
 
73800
 
 
73801
int
 
73802
main ()
 
73803
{
 
73804
if (sizeof ((struct ctdb_control_tcp_addr)))
 
73805
          return 0;
 
73806
  ;
 
73807
  return 0;
 
73808
}
 
73809
_ACEOF
 
73810
rm -f conftest.$ac_objext
 
73811
if { (ac_try="$ac_compile"
 
73812
case "(($ac_try" in
 
73813
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
73814
  *) ac_try_echo=$ac_try;;
 
73815
esac
 
73816
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
 
73817
$as_echo "$ac_try_echo") >&5
 
73818
  (eval "$ac_compile") 2>conftest.er1
 
73819
  ac_status=$?
 
73820
  grep -v '^ *+' conftest.er1 >conftest.err
 
73821
  rm -f conftest.er1
 
73822
  cat conftest.err >&5
 
73823
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
73824
  (exit $ac_status); } && {
 
73825
         test -z "$ac_c_werror_flag" ||
 
73826
         test ! -s conftest.err
 
73827
       } && test -s conftest.$ac_objext; then
 
73828
  :
 
73829
else
 
73830
  $as_echo "$as_me: failed program was:" >&5
 
73831
sed 's/^/| /' conftest.$ac_ext >&5
 
73832
 
 
73833
        ac_cv_type_struct_ctdb_control_tcp_addr=yes
 
73834
fi
 
73835
 
 
73836
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73837
else
 
73838
  $as_echo "$as_me: failed program was:" >&5
 
73839
sed 's/^/| /' conftest.$ac_ext >&5
 
73840
 
 
73841
 
 
73842
fi
 
73843
 
 
73844
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
73845
fi
 
73846
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_struct_ctdb_control_tcp_addr" >&5
 
73847
$as_echo "$ac_cv_type_struct_ctdb_control_tcp_addr" >&6; }
 
73848
if test "x$ac_cv_type_struct_ctdb_control_tcp_addr" = x""yes; then
 
73849
 
 
73850
 
 
73851
cat >>confdefs.h <<\_ACEOF
 
73852
#define HAVE_STRUCT_CTDB_CONTROL_TCP_ADDR 1
 
73853
_ACEOF
 
73854
 
 
73855
 
 
73856
fi
 
73857
 
 
73858
CPPFLAGS="$SAVED_CPPFLAGS"
 
73859
 
 
73860
{ $as_echo "$as_me:$LINENO: checking cluster support" >&5
 
73861
$as_echo_n "checking cluster support... " >&6; }
72685
73862
 
72686
73863
# Check whether --with-cluster-support was given.
72687
73864
if test "${with_cluster_support+set}" = set; then
72688
73865
  withval=$with_cluster_support;
72689
73866
fi
72690
73867
 
72691
 
if test "x$with_cluster_support" = "xyes"; then
 
73868
 
 
73869
if test x"$with_cluster_support" = x ; then
 
73870
        with_cluster_support="auto"
 
73871
fi
 
73872
 
 
73873
if test x"$ac_cv_header_ctdb_private_h" != x"yes"; then
 
73874
        if test "x$with_cluster_support" = "xyes"; then
 
73875
                { { $as_echo "$as_me:$LINENO: error: \"ctdb_private.h is required for cluster support\"" >&5
 
73876
$as_echo "$as_me: error: \"ctdb_private.h is required for cluster support\"" >&2;}
 
73877
   { (exit 1); exit 1; }; }
 
73878
        fi
 
73879
        with_cluster_support=no
 
73880
fi
 
73881
 
 
73882
if test x"$ctdb_broken" != x"no"; then
 
73883
        if test "x$with_cluster_support" = "xyes"; then
 
73884
                { { $as_echo "$as_me:$LINENO: error: \"cluster support: $ctdb_broken\"" >&5
 
73885
$as_echo "$as_me: error: \"cluster support: $ctdb_broken\"" >&2;}
 
73886
   { (exit 1); exit 1; }; }
 
73887
        fi
 
73888
        with_cluster_support=no
 
73889
fi
 
73890
 
 
73891
if test "x$with_cluster_support" != "xno"; then
72692
73892
 
72693
73893
cat >>confdefs.h <<\_ACEOF
72694
73894
#define CLUSTER_SUPPORT 1
72695
73895
_ACEOF
72696
73896
 
 
73897
    SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} ${CTDB_CPPFLAGS}"
72697
73898
    { $as_echo "$as_me:$LINENO: result: yes" >&5
72698
73899
$as_echo "yes" >&6; }
72699
73900
else
72701
73902
$as_echo "no" >&6; }
72702
73903
fi
72703
73904
 
72704
 
 
72705
73905
#################################################
72706
73906
# check for ACL support
72707
73907
 
76661
77861
fi
76662
77862
 
76663
77863
    if test x"$ac_cv_func_DNSServiceRegister" != x"yes" -a \
76664
 
            x"$ac_cv_lib_ext_DNSServiceRegister" != x"yes"; then
 
77864
            x"$ac_cv_lib_ext_dns_sd_DNSServiceRegister" != x"yes"; then
76665
77865
        have_dnssd_support=no
76666
77866
    fi
76667
77867