mirror of
https://github.com/MidnightCommander/mc
synced 2024-12-23 04:46:55 +03:00
907 lines
24 KiB
Plaintext
907 lines
24 KiB
Plaintext
dnl MC_UNDELFS_CHECKS
|
|
dnl Check for ext2fs undel support.
|
|
dnl Set shell variable ext2fs_undel to "yes" if we have it,
|
|
dnl "no" otherwise. May define USE_EXT2FSLIB for cpp.
|
|
dnl Will set EXT2FS_UNDEL_LIBS to required libraries.
|
|
|
|
AC_DEFUN([MC_UNDELFS_CHECKS], [
|
|
ext2fs_undel=no
|
|
EXT2FS_UNDEL_LIBS=
|
|
AC_CHECK_HEADERS([ext2fs/ext2_fs.h linux/ext2_fs.h], [ext2_fs_h=yes; break])
|
|
if test x$ext2_fs_h = xyes; then
|
|
AC_CHECK_HEADERS([ext2fs/ext2fs.h], [ext2fs_ext2fs_h=yes], ,
|
|
[
|
|
#include <stdio.h>
|
|
#ifdef HAVE_EXT2FS_EXT2_FS_H
|
|
#include <ext2fs/ext2_fs.h>
|
|
#else
|
|
#undef umode_t
|
|
#include <linux/ext2_fs.h>
|
|
#endif
|
|
])
|
|
if test x$ext2fs_ext2fs_h = xyes; then
|
|
AC_DEFINE(USE_EXT2FSLIB, 1,
|
|
[Define to enable undelete support on ext2])
|
|
ext2fs_undel=yes
|
|
EXT2FS_UNDEL_LIBS="-lext2fs -lcom_err"
|
|
AC_CHECK_TYPE(ext2_ino_t, ,
|
|
[AC_DEFINE(ext2_ino_t, ino_t,
|
|
[Define to ino_t if undefined.])],
|
|
[
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_EXT2FS_EXT2_FS_H
|
|
#include <ext2fs/ext2_fs.h>
|
|
#else
|
|
#undef umode_t
|
|
#include <linux/ext2_fs.h>
|
|
#endif
|
|
#include <ext2fs/ext2fs.h>
|
|
])
|
|
fi
|
|
fi
|
|
])
|
|
|
|
|
|
|
|
dnl MC_EXTFS_CHECKS
|
|
dnl Check for tools used in extfs scripts.
|
|
AC_DEFUN([MC_EXTFS_CHECKS], [
|
|
AC_PATH_PROG([ZIP], [zip], [/usr/bin/zip])
|
|
AC_PATH_PROG([UNZIP], [unzip], [/usr/bin/unzip])
|
|
AC_CACHE_CHECK([for zipinfo code in unzip], [mc_cv_have_zipinfo],
|
|
[mc_cv_have_zipinfo=no
|
|
if $UNZIP -Z </dev/null >/dev/null 2>&1; then
|
|
mc_cv_have_zipinfo=yes
|
|
fi])
|
|
if test "x$mc_cv_have_zipinfo" = xyes; then
|
|
HAVE_ZIPINFO=1
|
|
else
|
|
HAVE_ZIPINFO=0
|
|
fi
|
|
AC_SUBST([HAVE_ZIPINFO])
|
|
AC_PATH_PROG([PERL], [perl], [/usr/bin/perl])
|
|
])
|
|
|
|
|
|
|
|
dnl MC_MCSERVER_CHECKS
|
|
dnl Check how mcserver should check passwords.
|
|
dnl Possible methods are PAM, pwdauth and crypt.
|
|
dnl The later works with both /etc/shadow and /etc/passwd.
|
|
dnl If PAM is found, other methods are not checked.
|
|
|
|
AC_DEFUN([MC_MCSERVER_CHECKS], [
|
|
|
|
dnl Check if PAM can be used for mcserv
|
|
AC_CHECK_LIB(dl, dlopen, [LIB_DL="-ldl"])
|
|
AC_CHECK_LIB(pam, pam_start, [
|
|
AC_DEFINE(HAVE_PAM, 1,
|
|
[Define if PAM (Pluggable Authentication Modules) is available])
|
|
MCSERVLIBS="-lpam $LIB_DL"
|
|
mcserv_pam=yes], [], [$LIB_DL])
|
|
|
|
dnl Check for crypt() - needed for both /etc/shadow and /etc/passwd.
|
|
if test -z "$mcserv_pam"; then
|
|
|
|
dnl Check for pwdauth() - used on SunOS.
|
|
AC_CHECK_FUNCS([pwdauth])
|
|
|
|
dnl Check for crypt()
|
|
AC_CHECK_HEADERS([crypt.h], [crypt_header=yes])
|
|
if test -n "$crypt_header"; then
|
|
save_LIBS="$LIBS"
|
|
LIBS=
|
|
AC_SEARCH_LIBS(crypt, [crypt crypt_i], [mcserv_auth=crypt])
|
|
MCSERVLIBS="$LIBS"
|
|
LIBS="$save_LIBS"
|
|
if test -n "$mcserv_auth"; then
|
|
AC_DEFINE(HAVE_CRYPT, 1,
|
|
[Define to use crypt function in mcserv])
|
|
|
|
dnl Check for shadow passwords
|
|
AC_CHECK_HEADERS([shadow.h shadow/shadow.h],
|
|
[shadow_header=yes; break])
|
|
if test -n "$shadow_header"; then
|
|
save_LIBS="$LIBS"
|
|
LIBS="$MCSERVLIBS"
|
|
AC_SEARCH_LIBS(getspnam, [shadow], [mcserv_auth=shadow])
|
|
MCSERVLIBS="$LIBS"
|
|
LIBS="$save_LIBS"
|
|
if test -n "$mcserv_auth"; then
|
|
AC_DEFINE(HAVE_SHADOW, 1,
|
|
[Define to use shadow passwords for mcserv])
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(MCSERVLIBS)
|
|
])
|
|
|
|
|
|
|
|
dnl MC_VFS_CHECKS
|
|
dnl Check for various functions needed by libvfs.
|
|
dnl This has various effects:
|
|
dnl Sets MC_VFS_LIBS to libraries required
|
|
dnl Sets vfs_flags to "pretty" list of vfs implementations we include.
|
|
dnl Sets shell variable use_vfs to yes (default, --with-vfs) or
|
|
dnl "no" (--without-vfs).
|
|
|
|
dnl Private define
|
|
AC_DEFUN([MC_WITH_VFS],[
|
|
MC_EXTFS_CHECKS
|
|
|
|
vfs_flags="cpiofs, extfs, tarfs"
|
|
use_net_code=false
|
|
|
|
AC_ARG_ENABLE([netcode],
|
|
[ --enable-netcode Support for networking [[yes]]])
|
|
|
|
if test "x$enable_netcode" != xno; then
|
|
dnl FIXME: network checks should probably be in their own macro.
|
|
AC_CHECK_LIB(nsl, main)
|
|
AC_SEARCH_LIBS(socket, [xnet bsd socket inet], [have_socket=yes])
|
|
if test x$have_socket = xyes; then
|
|
AC_SEARCH_LIBS(gethostbyname, [bsd socket inet netinet])
|
|
AC_CHECK_MEMBERS([struct linger.l_linger], , , [
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
])
|
|
AC_CHECK_FUNCS(pmap_set, , [
|
|
AC_CHECK_LIB(rpc, pmap_set, [
|
|
LIBS="-lrpc $LIBS"
|
|
AC_DEFINE(HAVE_PMAP_SET)
|
|
])])
|
|
AC_CHECK_FUNCS(pmap_getport pmap_getmaps rresvport)
|
|
dnl add for source routing support setsockopt
|
|
AC_CHECK_HEADERS(rpc/pmap_clnt.h, , , [
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <rpc/rpc.h>
|
|
#include <rpc/pmap_prot.h>
|
|
])
|
|
dnl
|
|
dnl mcfs support
|
|
dnl
|
|
AC_ARG_WITH(mcfs,
|
|
[ --with-mcfs Support mc-specific networking file system [[no]]],
|
|
[if test "x$withval" != "xno"; then
|
|
AC_DEFINE(WITH_MCFS, 1, [Define to enable mc-specific networking file system])
|
|
vfs_flags="$vfs_flags, mcfs"
|
|
use_mcfs=yes
|
|
MC_MCSERVER_CHECKS
|
|
fi]
|
|
)
|
|
vfs_flags="$vfs_flags, ftpfs, fish"
|
|
use_net_code=true
|
|
fi
|
|
fi
|
|
|
|
dnl
|
|
dnl Samba support
|
|
dnl
|
|
use_smbfs=
|
|
AC_ARG_WITH(samba,
|
|
[ --with-samba Support smb virtual file system [[no]]],
|
|
[if test "x$withval" != "xno"; then
|
|
AC_DEFINE(WITH_SMBFS, 1, [Define to enable VFS over SMB])
|
|
vfs_flags="$vfs_flags, smbfs"
|
|
use_smbfs=yes
|
|
fi
|
|
])
|
|
|
|
if test -n "$use_smbfs"; then
|
|
#################################################
|
|
# set Samba configuration directory location
|
|
configdir="/etc"
|
|
AC_ARG_WITH(configdir,
|
|
[ --with-configdir=DIR Where the Samba configuration files are [[/etc]]],
|
|
[ case "$withval" in
|
|
yes|no)
|
|
#
|
|
# Just in case anybody does it
|
|
#
|
|
AC_MSG_WARN([--with-configdir called without argument - will use default])
|
|
;;
|
|
* )
|
|
configdir="$withval"
|
|
;;
|
|
esac]
|
|
)
|
|
AC_SUBST(configdir)
|
|
|
|
AC_ARG_WITH(codepagedir,
|
|
[ --with-codepagedir=DIR Where the Samba codepage files are],
|
|
[ case "$withval" in
|
|
yes|no)
|
|
#
|
|
# Just in case anybody does it
|
|
#
|
|
AC_MSG_WARN([--with-codepagedir called without argument - will use default])
|
|
;;
|
|
esac]
|
|
)
|
|
fi
|
|
|
|
dnl
|
|
dnl Ext2fs undelete support
|
|
dnl
|
|
AC_ARG_WITH(ext2undel,
|
|
[ --with-ext2undel Compile with ext2 undelete code [[yes if found]]],
|
|
[if test x$withval != xno; then
|
|
if test x$withval != xyes; then
|
|
LDFLAGS="$LDFLAGS -L$withval/lib"
|
|
CPPFLAGS="$CPPFLAGS -I$withval/include"
|
|
fi
|
|
AC_EXT2_UNDEL
|
|
fi],[
|
|
dnl Default: detect
|
|
AC_CHECK_LIB(ext2fs, ext2fs_close, [AC_EXT2_UNDEL], , [-lcom_err])
|
|
])
|
|
|
|
AC_DEFINE(USE_VFS, 1, [Define to enable VFS support])
|
|
if $use_net_code; then
|
|
AC_DEFINE(USE_NETCODE, 1, [Define to use networked VFS])
|
|
fi
|
|
])
|
|
|
|
|
|
|
|
AC_DEFUN([MC_VFS_CHECKS],[
|
|
use_vfs=yes
|
|
AC_ARG_WITH(vfs,
|
|
[ --with-vfs Compile with the VFS code [[yes]]],
|
|
use_vfs=$withval
|
|
)
|
|
case $use_vfs in
|
|
yes) MC_WITH_VFS;;
|
|
no) use_vfs=no;;
|
|
*) use_vfs=no;;
|
|
dnl Should we issue a warning?
|
|
esac
|
|
])
|
|
|
|
|
|
|
|
dnl
|
|
dnl Filesystem information detection
|
|
dnl
|
|
dnl To get information about the disk, mount points, etc.
|
|
dnl
|
|
|
|
AC_DEFUN([AC_GET_FS_INFO], [
|
|
AC_CHECK_HEADERS(fcntl.h sys/dustat.h sys/param.h sys/statfs.h sys/fstyp.h)
|
|
AC_CHECK_HEADERS(mnttab.h mntent.h utime.h sys/statvfs.h sys/vfs.h)
|
|
AC_CHECK_HEADERS(sys/filsys.h sys/fs_types.h)
|
|
AC_CHECK_HEADERS(sys/mount.h, , , [
|
|
#include <sys/param.h>
|
|
#include <sys/stat.h>
|
|
])
|
|
AC_CHECK_FUNCS(getmntinfo)
|
|
|
|
dnl This configure.in code has been stolen from GNU fileutils-3.12. Its
|
|
dnl job is to detect a method to get list of mounted filesystems.
|
|
|
|
AC_MSG_CHECKING([for d_ino member in directory struct])
|
|
AC_CACHE_VAL(fu_cv_sys_d_ino_in_dirent,
|
|
[AC_TRY_LINK([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_DIRENT_H
|
|
# include <dirent.h>
|
|
#else /* not HAVE_DIRENT_H */
|
|
# define dirent direct
|
|
# ifdef HAVE_SYS_NDIR_H
|
|
# include <sys/ndir.h>
|
|
# endif /* HAVE_SYS_NDIR_H */
|
|
# ifdef HAVE_SYS_DIR_H
|
|
# include <sys/dir.h>
|
|
# endif /* HAVE_SYS_DIR_H */
|
|
# ifdef HAVE_NDIR_H
|
|
# include <ndir.h>
|
|
# endif /* HAVE_NDIR_H */
|
|
#endif /* HAVE_DIRENT_H */
|
|
],
|
|
[struct dirent dp; dp.d_ino = 0;],
|
|
fu_cv_sys_d_ino_in_dirent=yes,
|
|
fu_cv_sys_d_ino_in_dirent=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_d_ino_in_dirent])
|
|
if test $fu_cv_sys_d_ino_in_dirent = yes; then
|
|
AC_DEFINE(D_INO_IN_DIRENT, 1,
|
|
[Define if `d_ino' is member of `struct directory'])
|
|
fi
|
|
|
|
# Determine how to get the list of mounted filesystems.
|
|
list_mounted_fs=
|
|
|
|
# If the getmntent function is available but not in the standard library,
|
|
# make sure LIBS contains -lsun (on Irix4) or -lseq (on PTX).
|
|
AC_FUNC_GETMNTENT
|
|
|
|
if test $ac_cv_func_getmntent = yes; then
|
|
|
|
# This system has the getmntent function.
|
|
# Determine whether it's the one-argument variant or the two-argument one.
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# SVR4
|
|
AC_MSG_CHECKING([for two-argument getmntent function])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_getmntent2,
|
|
[AC_EGREP_HEADER(getmntent, sys/mnttab.h,
|
|
fu_cv_sys_mounted_getmntent2=yes,
|
|
fu_cv_sys_mounted_getmntent2=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_getmntent2])
|
|
if test $fu_cv_sys_mounted_getmntent2 = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_GETMNTENT2, 1,
|
|
[Define if function `getmntent' takes 2 arguments])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# 4.3BSD, SunOS, HP-UX, Dynix, Irix
|
|
AC_MSG_CHECKING([for one-argument getmntent function])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_getmntent1,
|
|
[test $ac_cv_header_mntent_h = yes \
|
|
&& fu_cv_sys_mounted_getmntent1=yes \
|
|
|| fu_cv_sys_mounted_getmntent1=no])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_getmntent1])
|
|
if test $fu_cv_sys_mounted_getmntent1 = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_GETMNTENT1, 1,
|
|
[Define if function `getmntent' takes 1 argument])
|
|
fi
|
|
fi
|
|
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# DEC Alpha running OSF/1.
|
|
AC_MSG_CHECKING([for getfsstat function])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_getsstat,
|
|
[AC_TRY_LINK([
|
|
#include <sys/types.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/fs_types.h>],
|
|
[struct statfs *stats;
|
|
numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT); ],
|
|
fu_cv_sys_mounted_getsstat=yes,
|
|
fu_cv_sys_mounted_getsstat=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_getsstat])
|
|
if test $fu_cv_sys_mounted_getsstat = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_GETFSSTAT, 1,
|
|
[Define if function `getfsstat' can be used])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# AIX.
|
|
AC_MSG_CHECKING([for mntctl function and struct vmount])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_vmount,
|
|
[AC_TRY_CPP([#include <fshelp.h>],
|
|
fu_cv_sys_mounted_vmount=yes,
|
|
fu_cv_sys_mounted_vmount=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_vmount])
|
|
if test $fu_cv_sys_mounted_vmount = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_VMOUNT, 1,
|
|
[Define if function `mntctl' and `struct vmount' can be used])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# SVR3
|
|
AC_MSG_CHECKING([for existence of three headers])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_fread_fstyp,
|
|
[AC_TRY_CPP([
|
|
#include <sys/statfs.h>
|
|
#include <sys/fstyp.h>
|
|
#include <mnttab.h>],
|
|
fu_cv_sys_mounted_fread_fstyp=yes,
|
|
fu_cv_sys_mounted_fread_fstyp=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_fread_fstyp])
|
|
if test $fu_cv_sys_mounted_fread_fstyp = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_FREAD_FSTYP, 1,
|
|
[Define if sys/statfs.h, sys/fstyp.h and mnttab.h
|
|
can be used together])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# 4.4BSD and DEC OSF/1.
|
|
AC_MSG_CHECKING([for getmntinfo function])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_getmntinfo,
|
|
[
|
|
ok=
|
|
if test $ac_cv_func_getmntinfo = yes; then
|
|
AC_EGREP_HEADER(f_type;, sys/mount.h,
|
|
ok=yes)
|
|
fi
|
|
test -n "$ok" \
|
|
&& fu_cv_sys_mounted_getmntinfo=yes \
|
|
|| fu_cv_sys_mounted_getmntinfo=no
|
|
])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_getmntinfo])
|
|
if test $fu_cv_sys_mounted_getmntinfo = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_GETMNTINFO, 1,
|
|
[Define if `getmntinfo' function can be used])
|
|
AC_MSG_CHECKING([if struct statfs has f_fstypename])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_f_fstypename,
|
|
[AC_EGREP_HEADER([f_fstypename],
|
|
[sys/mount.h],
|
|
[fu_cv_sys_mounted_f_fstypename=yes],
|
|
[fu_cv_sys_mounted_f_fstypename=no])
|
|
])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_f_fstypename])
|
|
if test $fu_cv_sys_mounted_f_fstypename = yes; then
|
|
AC_DEFINE(HAVE_F_FSTYPENAME, 1,
|
|
[Define if `f_fstypename' is member of `struct statfs'])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# Ultrix
|
|
AC_MSG_CHECKING([for getmnt function])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_getmnt,
|
|
[AC_TRY_CPP([
|
|
#include <sys/fs_types.h>
|
|
#include <sys/mount.h>],
|
|
fu_cv_sys_mounted_getmnt=yes,
|
|
fu_cv_sys_mounted_getmnt=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_getmnt])
|
|
if test $fu_cv_sys_mounted_getmnt = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_GETMNT, 1,
|
|
[Define if `getmnt' function can be used])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
# SVR2
|
|
AC_MSG_CHECKING([whether it is possible to resort to fread on /etc/mnttab])
|
|
AC_CACHE_VAL(fu_cv_sys_mounted_fread,
|
|
[AC_TRY_CPP([#include <mnttab.h>],
|
|
fu_cv_sys_mounted_fread=yes,
|
|
fu_cv_sys_mounted_fread=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_mounted_fread])
|
|
if test $fu_cv_sys_mounted_fread = yes; then
|
|
list_mounted_fs=found
|
|
AC_DEFINE(MOUNTED_FREAD, 1,
|
|
[Define if it's possible to resort to fread on /etc/mnttab])
|
|
fi
|
|
fi
|
|
|
|
if test -z "$list_mounted_fs"; then
|
|
AC_MSG_WARN([could not determine how to read list of mounted fs])
|
|
else
|
|
AC_DEFINE(HAVE_INFOMOUNT_LIST, 1,
|
|
[Define if the list of mounted filesystems can be determined])
|
|
fi
|
|
|
|
dnl This configure.in code has been stolen from GNU fileutils-3.12. Its
|
|
dnl job is to detect a method to get file system information.
|
|
|
|
AC_MSG_NOTICE([checking how to get filesystem space usage])
|
|
space=no
|
|
|
|
# Here we'll compromise a little (and perform only the link test)
|
|
# since it seems there are no variants of the statvfs function.
|
|
if test $space = no; then
|
|
# SVR4
|
|
AC_CHECK_FUNCS(statvfs)
|
|
if test $ac_cv_func_statvfs = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATVFS, 1,
|
|
[Define if function `statfs' can be used])
|
|
fi
|
|
fi
|
|
|
|
if test $space = no; then
|
|
# DEC Alpha running OSF/1
|
|
AC_MSG_CHECKING([for 3-argument statfs function (DEC OSF/1)])
|
|
AC_CACHE_VAL(fu_cv_sys_stat_statfs3_osf1,
|
|
[AC_TRY_RUN([
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/mount.h>
|
|
main ()
|
|
{
|
|
struct statfs fsd;
|
|
fsd.f_fsize = 0;
|
|
exit (statfs (".", &fsd, sizeof (struct statfs)));
|
|
}],
|
|
fu_cv_sys_stat_statfs3_osf1=yes,
|
|
fu_cv_sys_stat_statfs3_osf1=no,
|
|
fu_cv_sys_stat_statfs3_osf1=no)])
|
|
AC_MSG_RESULT($fu_cv_sys_stat_statfs3_osf1)
|
|
if test $fu_cv_sys_stat_statfs3_osf1 = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATFS3_OSF1, 1,
|
|
[Define if function `statfs' takes 3 arguments])
|
|
fi
|
|
fi
|
|
|
|
if test $space = no; then
|
|
# AIX
|
|
AC_MSG_CHECKING([for two-argument statfs with statfs.bsize member (AIX, 4.3BSD)])
|
|
AC_CACHE_VAL(fu_cv_sys_stat_statfs2_bsize,
|
|
[AC_TRY_RUN([
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
#include <sys/mount.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_VFS_H
|
|
#include <sys/vfs.h>
|
|
#endif
|
|
main ()
|
|
{
|
|
struct statfs fsd;
|
|
fsd.f_bsize = 0;
|
|
exit (statfs (".", &fsd));
|
|
}],
|
|
fu_cv_sys_stat_statfs2_bsize=yes,
|
|
fu_cv_sys_stat_statfs2_bsize=no,
|
|
fu_cv_sys_stat_statfs2_bsize=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_stat_statfs2_bsize])
|
|
if test $fu_cv_sys_stat_statfs2_bsize = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATFS2_BSIZE, 1,
|
|
[Define if function `statfs' takes two arguments and
|
|
`bsize' is member of `struct statfs'])
|
|
fi
|
|
fi
|
|
|
|
if test $space = no; then
|
|
# SVR3
|
|
AC_MSG_CHECKING([for four-argument statfs (AIX-3.2.5, SVR3)])
|
|
AC_CACHE_VAL(fu_cv_sys_stat_statfs4,
|
|
[AC_TRY_RUN([#include <sys/types.h>
|
|
#include <sys/statfs.h>
|
|
main ()
|
|
{
|
|
struct statfs fsd;
|
|
exit (statfs (".", &fsd, sizeof fsd, 0));
|
|
}],
|
|
fu_cv_sys_stat_statfs4=yes,
|
|
fu_cv_sys_stat_statfs4=no,
|
|
fu_cv_sys_stat_statfs4=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_stat_statfs4])
|
|
if test $fu_cv_sys_stat_statfs4 = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATFS4, 1,
|
|
[Define if function `statfs' takes 4 arguments])
|
|
fi
|
|
fi
|
|
|
|
if test $space = no; then
|
|
# 4.4BSD and NetBSD
|
|
AC_MSG_CHECKING([for two-argument statfs with statfs.fsize dnl
|
|
member (4.4BSD and NetBSD)])
|
|
AC_CACHE_VAL(fu_cv_sys_stat_statfs2_fsize,
|
|
[AC_TRY_RUN([#include <sys/types.h>
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
#include <sys/mount.h>
|
|
#endif
|
|
main ()
|
|
{
|
|
struct statfs fsd;
|
|
fsd.f_fsize = 0;
|
|
exit (statfs (".", &fsd));
|
|
}],
|
|
fu_cv_sys_stat_statfs2_fsize=yes,
|
|
fu_cv_sys_stat_statfs2_fsize=no,
|
|
fu_cv_sys_stat_statfs2_fsize=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_stat_statfs2_fsize])
|
|
if test $fu_cv_sys_stat_statfs2_fsize = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATFS2_FSIZE, 1,
|
|
[Define if function `statfs' takes two arguments and
|
|
`fsize' is member of `struct statfs'])
|
|
fi
|
|
fi
|
|
|
|
if test $space = no; then
|
|
# Ultrix
|
|
AC_MSG_CHECKING([for two-argument statfs with struct fs_data (Ultrix)])
|
|
AC_CACHE_VAL(fu_cv_sys_stat_fs_data,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
#include <sys/mount.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_FS_TYPES_H
|
|
#include <sys/fs_types.h>
|
|
#endif
|
|
main ()
|
|
{
|
|
struct fs_data fsd;
|
|
/* Ultrix's statfs returns 1 for success,
|
|
0 for not mounted, -1 for failure. */
|
|
exit (statfs (".", &fsd) != 1);
|
|
}],
|
|
fu_cv_sys_stat_fs_data=yes,
|
|
fu_cv_sys_stat_fs_data=no,
|
|
fu_cv_sys_stat_fs_data=no)])
|
|
AC_MSG_RESULT([$fu_cv_sys_stat_fs_data])
|
|
if test $fu_cv_sys_stat_fs_data = yes; then
|
|
space=yes
|
|
AC_DEFINE(STAT_STATFS2_FS_DATA, 1,
|
|
[Define if function `statfs' takes two arguments
|
|
and uses `struct fs_data'])
|
|
fi
|
|
fi
|
|
|
|
dnl Not supported
|
|
dnl if test $space = no; then
|
|
dnl # SVR2
|
|
dnl AC_TRY_CPP([#include <sys/filsys.h>],
|
|
dnl AC_DEFINE(STAT_READ_FILSYS) space=yes)
|
|
dnl fi
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Try using termcap database and link with libtermcap if possible.
|
|
dnl
|
|
AC_DEFUN([MC_USE_TERMCAP], [
|
|
screen_msg="$screen_msg with termcap database"
|
|
AC_MSG_NOTICE([using S-Lang screen library with termcap])
|
|
AC_DEFINE(USE_TERMCAP, 1, [Define to use termcap database])
|
|
AC_CHECK_LIB(termcap, tgoto, [MCLIBS="$MCLIBS -ltermcap"], , [$LIBS])
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Common code for MC_WITH_SLANG and MC_WITH_MCSLANG
|
|
dnl
|
|
AC_DEFUN([_MC_WITH_XSLANG], [
|
|
screen_type=slang
|
|
AC_DEFINE(HAVE_SLANG, 1,
|
|
[Define to use S-Lang library for screen management])
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Check if the system S-Lang library can be used.
|
|
dnl If not, and $1 is "strict", exit, otherwise fall back to mcslang.
|
|
dnl
|
|
AC_DEFUN([MC_WITH_SLANG], [
|
|
with_screen=slang
|
|
ac_save_MCLIBS="$MCLIBS"
|
|
|
|
dnl Check the header
|
|
if test x$with_screen = xslang; then
|
|
slang_h_found=
|
|
AC_CHECK_HEADERS([slang.h slang/slang.h],
|
|
[slang_h_found=yes; break])
|
|
|
|
if test -z "$slang_h_found"; then
|
|
with_screen=mcslang
|
|
fi
|
|
fi
|
|
|
|
dnl Check if the installed S-Lang library uses termcap
|
|
if test x$with_screen = xslang; then
|
|
screen_type=slang
|
|
screen_msg="S-Lang library (installed on the system)"
|
|
AC_DEFINE(HAVE_SYSTEM_SLANG, 1,
|
|
[Define to use S-Lang library installed on the system])
|
|
ac_save_LIBS="$LIBS"
|
|
LIBS="$LIBS -lslang"
|
|
AC_TRY_LINK([
|
|
#ifdef HAVE_SLANG_SLANG_H
|
|
#include <slang/slang.h>
|
|
#else
|
|
#include <slang.h>
|
|
#endif],
|
|
[SLtt_get_terminfo();
|
|
SLtt_tgetflag("");],
|
|
[LIBS="$ac_save_LIBS"],
|
|
[LIBS="$ac_save_LIBS"; MC_USE_TERMCAP
|
|
ac_save_MCLIBS="$MCLIBS"])
|
|
_MC_WITH_XSLANG
|
|
fi
|
|
|
|
if test x$with_screen = xslang; then
|
|
AC_CHECK_LIB([slang], [SLang_init_tty], [MCLIBS="$MCLIBS -lslang"],
|
|
[with_screen=mcslang], ["$MCLIBS"])
|
|
fi
|
|
|
|
dnl Unless external S-Lang was requested, reject S-Lang with UTF-8 hacks
|
|
m4_if([$1], strict, ,
|
|
[AC_CHECK_LIB([slang], [SLsmg_write_nwchars],
|
|
[AC_MSG_WARN([Rejecting S-Lang with UTF-8 support, \
|
|
it doesn't work well])
|
|
with_screen=mcslang])])
|
|
|
|
m4_if([$1], strict,
|
|
[if test $with_screen != slang; then
|
|
AC_MSG_ERROR([S-Lang library not found])
|
|
fi],
|
|
[MC_WITH_MCSLANG]
|
|
)
|
|
|
|
if test x$with_screen != xslang; then
|
|
MCLIBS="$ac_save_MCLIBS"
|
|
fi
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Use the included S-Lang library.
|
|
dnl
|
|
AC_DEFUN([MC_WITH_MCSLANG], [
|
|
screen_type=mcslang
|
|
screen_msg="Included S-Lang library (mcslang)"
|
|
|
|
# Search for terminfo database.
|
|
use_terminfo=
|
|
if test x"$with_termcap" != xyes; then
|
|
if test x"$with_termcap" = xno; then
|
|
use_terminfo=yes
|
|
fi
|
|
if test -n "$TERMINFO" && test -r "$TERMINFO/v/vt100"; then
|
|
use_terminfo=yes
|
|
fi
|
|
for dir in "/usr/share/terminfo" "/usr/lib/terminfo" \
|
|
"/usr/share/lib/terminfo" "/etc/terminfo" \
|
|
"/usr/local/lib/terminfo" "$HOME/.terminfo"; do
|
|
if test -r "$dir/v/vt100"; then
|
|
use_terminfo=yes
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# If there is no terminfo, use termcap
|
|
if test -z "$use_terminfo"; then
|
|
MC_USE_TERMCAP
|
|
fi
|
|
|
|
_MC_WITH_XSLANG
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Use the ncurses library. It can only be requested explicitly,
|
|
dnl so just fail if anything goes wrong.
|
|
dnl
|
|
dnl If ncurses exports the ESCDELAY variable it should be set to 0
|
|
dnl or you'll have to press Esc three times to dismiss a dialog box.
|
|
dnl
|
|
AC_DEFUN([MC_WITH_NCURSES], [
|
|
dnl has_colors() is specific to ncurses, it's not in the old curses
|
|
save_LIBS="$LIBS"
|
|
LIBS=
|
|
AC_SEARCH_LIBS([has_colors], [ncurses curses], [MCLIBS="$MCLIBS $LIBS"],
|
|
[AC_MSG_ERROR([Cannot find ncurses library])])
|
|
|
|
dnl Check the header
|
|
ncurses_h_found=
|
|
AC_CHECK_HEADERS([ncurses/curses.h ncurses.h curses.h],
|
|
[ncurses_h_found=yes; break])
|
|
|
|
if test -z "$ncurses_h_found"; then
|
|
AC_MSG_ERROR([Cannot find ncurses header file])
|
|
fi
|
|
|
|
screen_type=ncurses
|
|
screen_msg="ncurses library"
|
|
AC_DEFINE(USE_NCURSES, 1,
|
|
[Define to use ncurses for screen management])
|
|
|
|
AC_CACHE_CHECK([for ESCDELAY variable],
|
|
[mc_cv_ncurses_escdelay],
|
|
[AC_TRY_LINK([], [
|
|
extern int ESCDELAY;
|
|
ESCDELAY = 0;
|
|
],
|
|
[mc_cv_ncurses_escdelay=yes],
|
|
[mc_cv_ncurses_escdelay=no])
|
|
])
|
|
if test "$mc_cv_ncurses_escdelay" = yes; then
|
|
AC_DEFINE(HAVE_ESCDELAY, 1,
|
|
[Define if ncurses has ESCDELAY variable])
|
|
fi
|
|
|
|
AC_CHECK_FUNCS(resizeterm)
|
|
LIBS="$save_LIBS"
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Check for ext2fs recovery code
|
|
dnl
|
|
AC_DEFUN([AC_EXT2_UNDEL], [
|
|
MC_UNDELFS_CHECKS
|
|
if test "$ext2fs_undel" = yes; then
|
|
AC_MSG_NOTICE([using ext2fs file recovery code])
|
|
vfs_flags="${vfs_flags}, undelfs"
|
|
use_undelfs=yes
|
|
MCLIBS="$MCLIBS $EXT2FS_UNDEL_LIBS"
|
|
else
|
|
AC_MSG_NOTICE([not using ext2fs file recovery code])
|
|
fi
|
|
])
|
|
|
|
dnl The next line is for compatibility with gettext 0.10.x
|
|
AC_DEFUN([AM_GNU_GETTEXT_VERSION], [])
|
|
|
|
dnl
|
|
dnl Check whether the g_module_* family of functions works
|
|
dnl on this system. We need to know that at the compile time to
|
|
dnl decide whether to link with X11.
|
|
dnl
|
|
AC_DEFUN([AC_G_MODULE_SUPPORTED], [
|
|
AC_CACHE_CHECK([if gmodule functionality is supported], mc_cv_g_module_supported, [
|
|
ac_save_CFLAGS="$CFLAGS"
|
|
ac_save_LIBS="$LIBS"
|
|
CFLAGS="$CFLAGS $GMODULE_CFLAGS"
|
|
LIBS="$GMODULE_LIBS $LIBS"
|
|
AC_TRY_RUN([
|
|
#include <gmodule.h>
|
|
|
|
int main ()
|
|
{
|
|
int ret = (g_module_supported () == TRUE) ? 0 : 1;
|
|
return ret;
|
|
}
|
|
],
|
|
[mc_cv_g_module_supported=yes],
|
|
[mc_cv_g_module_supported=no],
|
|
[mc_cv_g_module_supported=no]
|
|
)
|
|
CFLAGS="$ac_save_CFLAGS"
|
|
LIBS="$ac_save_LIBS"
|
|
])
|
|
|
|
if test "$mc_cv_g_module_supported" = yes; then
|
|
AC_DEFINE(HAVE_GMODULE, 1,
|
|
[Define if gmodule functionality is supported])
|
|
fi
|
|
])
|
|
|
|
|
|
dnl
|
|
dnl Check if it's possible to use asm labels to rename functions.
|
|
dnl This macro is necessary because gettext wrongly assumes that gcc
|
|
dnl can do it regardless of the OS.
|
|
dnl
|
|
AC_DEFUN([MC_ASM_LABELS], [
|
|
AC_CACHE_CHECK([whether functions can be renamed by asm labels],
|
|
mc_cv_asm_labels,
|
|
[mc_cv_asm_labels=no
|
|
if test -n "$GCC"; then
|
|
AC_TRY_LINK(, [
|
|
static int function1 (void) __asm__ ("function2");
|
|
static int function1 (void)
|
|
{
|
|
return 0;
|
|
}
|
|
return function2();
|
|
], [mc_cv_asm_labels=yes])
|
|
fi
|
|
])
|
|
|
|
if test "$mc_cv_asm_labels" != yes; then
|
|
AC_DEFINE(_INTL_REDIRECT_MACROS, 1,
|
|
[Define if functions cannot be renamed by asm labels])
|
|
fi
|
|
])
|