acinclude.m4

   1 dnl MC_UNDELFS_CHECKS
   2 dnl    Check for ext2fs undel support.
   3 dnl    Set shell variable ext2fs_undel to "yes" if we have it,
   4 dnl    "no" otherwise.  May define USE_EXT2FSLIB for cpp.
   5 dnl    Will set EXT2FS_UNDEL_LIBS to required libraries.
   6
   7 AC_DEFUN([MC_UNDELFS_CHECKS], [
   8   ext2fs_undel=no
   9   EXT2FS_UNDEL_LIBS=
  10   AC_CHECK_HEADERS(linux/ext2_fs.h)
  11   if test x$ac_cv_header_linux_ext2_fs_h = xyes
  12   then
  13     AC_CHECK_HEADERS(ext2fs/ext2fs.h, , , [#include <stdio.h>
  14 #include <linux/ext2_fs.h>])
  15     if test x$ac_cv_header_ext2fs_ext2fs_h = xyes
  16     then
  17       AC_DEFINE(USE_EXT2FSLIB, 1,
  18                 [Define to enable undelete support on ext2])
  19       ext2fs_undel=yes
  20       EXT2FS_UNDEL_LIBS="-lext2fs -lcom_err"
  21     fi
  22   fi
  23 ])
  24
  25
  26
  27 dnl MC_VFS_CHECKS
  28 dnl   Check for various functions needed by libvfs.
  29 dnl   This has various effects:
  30 dnl     Sets MC_VFS_LIBS to libraries required
  31 dnl     Sets termnet  to true or false depending on whether it is required.
  32 dnl        If yes, defines USE_TERMNET.
  33 dnl     Sets vfs_flags to "pretty" list of vfs implementations we include.
  34 dnl     Sets shell variable use_vfs to yes (default, --with-vfs) or
  35 dnl        "no" (--without-vfs).
  36 dnl     Calls AC_SUBST(mcserv), which is either empty or "mcserv".
  37
  38 dnl Private define
  39 AC_DEFUN([MC_WITH_VFS],[
  40   dnl FIXME: network checks should probably be in their own macro.
  41   AC_CHECK_LIB(nsl, t_accept)
  42   AC_CHECK_LIB(socket, socket)
  43
  44   have_socket=no
  45   AC_CHECK_FUNCS(socket, have_socket=yes)
  46   if test $have_socket = no; then
  47     # socket is not in the default libraries.  See if it's in some other.
  48     for lib in bsd socket inet; do
  49       AC_CHECK_LIB([$lib], [socket], [
  50           LIBS="$LIBS -l$lib"
  51           have_socket=yes
  52           AC_DEFINE(HAVE_SOCKET)
  53           break])
  54     done
  55   fi
  56
  57   have_gethostbyname=no
  58   AC_CHECK_FUNC(gethostbyname, have_gethostbyname=yes)
  59   if test $have_gethostbyname = no; then
  60     # gethostbyname is not in the default libraries.  See if it's in some other.
  61     for lib in bsd socket inet; do
  62       AC_CHECK_LIB([$lib], [gethostbyname],
  63                    [LIBS="$LIBS -l$lib"; have_gethostbyname=yes; break])
  64     done
  65   fi
  66
  67   vfs_flags="tarfs"
  68   use_net_code=false
  69   if test $have_socket = yes; then
  70       AC_STRUCT_LINGER
  71       AC_CHECK_FUNCS(pmap_set, , [
  72          AC_CHECK_LIB(rpc, pmap_set, [
  73            LIBS="-lrpc $LIBS"
  74           AC_DEFINE(HAVE_PMAP_SET)
  75           ])])
  76       AC_CHECK_FUNCS(pmap_getport pmap_getmaps rresvport)
  77       dnl add for source routing support setsockopt
  78       AC_CHECK_HEADERS(rpc/pmap_clnt.h, , , [
  79 #include <sys/types.h>
  80 #include <sys/socket.h>
  81 #include <netinet/in.h>
  82 #include <rpc/rpc.h>
  83 #include <rpc/pmap_prot.h>
  84                                             ])
  85       vfs_flags="$vfs_flags, mcfs, ftpfs, fish"
  86       use_net_code=true
  87   fi
  88
  89   dnl
  90   dnl Samba support
  91   dnl
  92   smbfs=""
  93   SAMBAFILES=""
  94   AC_ARG_WITH(samba,
  95           [--with-samba             Support smb virtual file system],[
  96           if test "x$withval" != "xno"; then
  97                   AC_DEFINE(WITH_SMBFS, 1, [Define to enable VFS over SMB])
  98                   vfs_flags="$vfs_flags, smbfs"
  99                   smbfs="smbfs.o"
 100                   SAMBAFILES="\$(SAMBAFILES)"
 101           fi
 102   ])
 103   AC_SUBST(smbfs)
 104   AC_SUBST(SAMBAFILES)
 105
 106   dnl
 107   dnl The termnet support
 108   dnl
 109   termnet=false
 110   AC_ARG_WITH(termnet,
 111           [--with-termnet             If you want a termified net support],[
 112           if test x$withval = xyes; then
 113                   AC_DEFINE(USE_TERMNET, 1,
 114                             [Define to enable `term' firewall support])
 115                   termnet=true
 116           fi
 117   ])
 118
 119   TERMNET=""
 120   AC_DEFINE(USE_VFS, 1, [Define to enable VFS support])
 121   if $use_net_code; then
 122      AC_DEFINE(USE_NETCODE, 1, [Define to use networked VFS])
 123   fi
 124   mcserv=
 125   if test $have_socket = yes; then
 126      mcserv="mcserv"
 127      if $termnet; then
 128         TERMNET="-ltermnet"
 129      fi
 130   fi
 131
 132   AC_SUBST(TERMNET)
 133   AC_SUBST(mcserv)
 134
 135 dnl FIXME:
 136 dnl MC_VFS_LIBS=
 137
 138 ])
 139
 140
 141
 142 AC_DEFUN([MC_VFS_CHECKS],[
 143         use_vfs=yes
 144         AC_ARG_WITH(vfs,
 145                 [--with-vfs                Compile with the VFS code],
 146                 use_vfs=$withval
 147         )
 148         case $use_vfs in
 149                 yes)    MC_WITH_VFS;;
 150                 no)     use_vfs=no;;
 151                 *)      use_vfs=no;;
 152                         dnl Should we issue a warning?
 153         esac
 154 ])
 155
 156
 157
 158 dnl
 159 dnl Check for struct linger
 160 dnl
 161 AC_DEFUN([AC_STRUCT_LINGER], [
 162 av_struct_linger=no
 163 AC_MSG_CHECKING([struct linger is available])
 164 AC_TRY_RUN([
 165 #include <sys/types.h>
 166 #include <sys/socket.h>
 167
 168 struct linger li;
 169
 170 int main ()
 171 {
 172     li.l_onoff = 1;
 173     li.l_linger = 120;
 174     return 0;
 175 }
 176 ],[
 177 AC_DEFINE(HAVE_STRUCT_LINGER, 1,
 178           [Define if `struct linger' is available])
 179 av_struct_linger=yes
 180 ],[
 181 av_struct_linger=no
 182 ],[
 183 av_struct_linger=no
 184 ])
 185 AC_MSG_RESULT([$av_struct_linger])
 186 ])
 187
 188
 189
 190 dnl
 191 dnl Check for size of d_name dirent member
 192 dnl
 193 AC_DEFUN([AC_SHORT_D_NAME_LEN], [
 194 AC_MSG_CHECKING([filename fits on dirent.d_name])
 195 AC_CACHE_VAL(ac_cv_dnamesize, [
 196 OCFLAGS="$CFLAGS"
 197 CFLAGS="$CFLAGS -I$srcdir"
 198 AC_TRY_RUN([
 199 #include <src/fs.h>
 200
 201 int main ()
 202 {
 203    struct dirent ddd;
 204
 205    if (sizeof (ddd.d_name) < 12)
 206         return 0;
 207    else
 208         return 1;
 209 }
 210
 211 ],[
 212     ac_cv_dnamesize="no"
 213 ], [
 214     ac_cv_dnamesize="yes"
 215 ], [
 216 # Cannot find out, so assume no
 217     ac_cv_dnamesize="no"
 218 ])
 219 CFLAGS="$OCFLAGS"
 220 ])
 221 if test x$ac_cv_dnamesize = xno; then
 222     AC_DEFINE(NEED_EXTRA_DIRENT_BUFFER, 1,
 223               [Define if using `struct dirent' can overwrite stack])
 224 fi
 225 AC_MSG_RESULT([$ac_cv_dnamesize])
 226 ])
 227
 228 dnl
 229 dnl Filesystem information detection
 230 dnl
 231 dnl To get information about the disk, mount points, etc.
 232 dnl
 233
 234 AC_DEFUN([AC_GET_FS_INFO], [
 235     AC_CHECK_HEADERS(fcntl.h sys/dustat.h sys/param.h sys/statfs.h sys/fstyp.h)
 236     AC_CHECK_HEADERS(mnttab.h mntent.h utime.h sys/statvfs.h sys/vfs.h)
 237     AC_CHECK_HEADERS(sys/filsys.h sys/fs_types.h)
 238     AC_CHECK_HEADERS(sys/mount.h, , , [
 239 #include <sys/param.h>
 240 #include <sys/stat.h>
 241                                       ])
 242     AC_CHECK_FUNCS(getmntinfo)
 243
 244     dnl This configure.in code has been stolen from GNU fileutils-3.12.  Its
 245     dnl job is to detect a method to get list of mounted filesystems.
 246
 247     AC_MSG_CHECKING([for d_ino member in directory struct])
 248     AC_CACHE_VAL(fu_cv_sys_d_ino_in_dirent,
 249     [AC_TRY_LINK([
 250 #include <sys/types.h>
 251 #ifdef HAVE_DIRENT_H
 252 # include <dirent.h>
 253 #else /* not HAVE_DIRENT_H */
 254 # define dirent direct
 255 # ifdef HAVE_SYS_NDIR_H
 256 #  include <sys/ndir.h>
 257 # endif /* HAVE_SYS_NDIR_H */
 258 # ifdef HAVE_SYS_DIR_H
 259 #  include <sys/dir.h>
 260 # endif /* HAVE_SYS_DIR_H */
 261 # ifdef HAVE_NDIR_H
 262 #  include <ndir.h>
 263 # endif /* HAVE_NDIR_H */
 264 #endif /* HAVE_DIRENT_H */
 265     ],
 266       [struct dirent dp; dp.d_ino = 0;],
 267         fu_cv_sys_d_ino_in_dirent=yes,
 268         fu_cv_sys_d_ino_in_dirent=no)])
 269     AC_MSG_RESULT([$fu_cv_sys_d_ino_in_dirent])
 270     if test $fu_cv_sys_d_ino_in_dirent = yes; then
 271       AC_DEFINE(D_INO_IN_DIRENT, 1,
 272                 [Define if `d_ino' is member of `struct directory'])
 273     fi
 274
 275     # Determine how to get the list of mounted filesystems.
 276     list_mounted_fs=
 277
 278     # If the getmntent function is available but not in the standard library,
 279     # make sure LIBS contains -lsun (on Irix4) or -lseq (on PTX).
 280     AC_FUNC_GETMNTENT
 281
 282     if test $ac_cv_func_getmntent = yes; then
 283
 284       # This system has the getmntent function.
 285       # Determine whether it's the one-argument variant or the two-argument one.
 286
 287       if test -z "$list_mounted_fs"; then
 288         # SVR4
 289         AC_MSG_CHECKING([for two-argument getmntent function])
 290         AC_CACHE_VAL(fu_cv_sys_mounted_getmntent2,
 291         [AC_EGREP_HEADER(getmntent, sys/mnttab.h,
 292           fu_cv_sys_mounted_getmntent2=yes,
 293           fu_cv_sys_mounted_getmntent2=no)])
 294         AC_MSG_RESULT([$fu_cv_sys_mounted_getmntent2])
 295         if test $fu_cv_sys_mounted_getmntent2 = yes; then
 296           list_mounted_fs=found
 297           AC_DEFINE(MOUNTED_GETMNTENT2, 1,
 298                     [Define if function `getmntent' takes 2 arguments])
 299         fi
 300       fi
 301
 302       if test -z "$list_mounted_fs"; then
 303         # 4.3BSD, SunOS, HP-UX, Dynix, Irix
 304         AC_MSG_CHECKING([for one-argument getmntent function])
 305         AC_CACHE_VAL(fu_cv_sys_mounted_getmntent1,
 306                      [test $ac_cv_header_mntent_h = yes \
 307                        && fu_cv_sys_mounted_getmntent1=yes \
 308                        || fu_cv_sys_mounted_getmntent1=no])
 309         AC_MSG_RESULT([$fu_cv_sys_mounted_getmntent1])
 310         if test $fu_cv_sys_mounted_getmntent1 = yes; then
 311           list_mounted_fs=found
 312           AC_DEFINE(MOUNTED_GETMNTENT1, 1,
 313                     [Define if function `getmntent' takes 1 argument])
 314         fi
 315       fi
 316
 317     fi
 318
 319     if test -z "$list_mounted_fs"; then
 320       # DEC Alpha running OSF/1.
 321       AC_MSG_CHECKING([for getfsstat function])
 322       AC_CACHE_VAL(fu_cv_sys_mounted_getsstat,
 323       [AC_TRY_LINK([
 324 #include <sys/types.h>
 325 #include <sys/mount.h>
 326 #include <sys/fs_types.h>],
 327       [struct statfs *stats;
 328       numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT); ],
 329         fu_cv_sys_mounted_getsstat=yes,
 330         fu_cv_sys_mounted_getsstat=no)])
 331       AC_MSG_RESULT([$fu_cv_sys_mounted_getsstat])
 332       if test $fu_cv_sys_mounted_getsstat = yes; then
 333         list_mounted_fs=found
 334         AC_DEFINE(MOUNTED_GETFSSTAT, 1,
 335                   [Define if function `getfsstat' can be used])
 336       fi
 337     fi
 338
 339     if test -z "$list_mounted_fs"; then
 340       # AIX.
 341       AC_MSG_CHECKING([for mntctl function and struct vmount])
 342       AC_CACHE_VAL(fu_cv_sys_mounted_vmount,
 343       [AC_TRY_CPP([#include <fshelp.h>],
 344         fu_cv_sys_mounted_vmount=yes,
 345         fu_cv_sys_mounted_vmount=no)])
 346       AC_MSG_RESULT([$fu_cv_sys_mounted_vmount])
 347       if test $fu_cv_sys_mounted_vmount = yes; then
 348         list_mounted_fs=found
 349         AC_DEFINE(MOUNTED_VMOUNT, 1,
 350                   [Define if function `mntctl' and `struct vmount' can be used])
 351       fi
 352     fi
 353
 354     if test -z "$list_mounted_fs"; then
 355       # SVR3
 356       AC_MSG_CHECKING([for existence of three headers])
 357       AC_CACHE_VAL(fu_cv_sys_mounted_fread_fstyp,
 358         [AC_TRY_CPP([
 359 #include <sys/statfs.h>
 360 #include <sys/fstyp.h>
 361 #include <mnttab.h>],
 362                     fu_cv_sys_mounted_fread_fstyp=yes,
 363                     fu_cv_sys_mounted_fread_fstyp=no)])
 364       AC_MSG_RESULT([$fu_cv_sys_mounted_fread_fstyp])
 365       if test $fu_cv_sys_mounted_fread_fstyp = yes; then
 366         list_mounted_fs=found
 367         AC_DEFINE(MOUNTED_FREAD_FSTYP, 1,
 368                   [Define if sys/statfs.h, sys/fstyp.h and mnttab.h
 369 can be used together])
 370       fi
 371     fi
 372
 373     if test -z "$list_mounted_fs"; then
 374       # 4.4BSD and DEC OSF/1.
 375       AC_MSG_CHECKING([for getmntinfo function])
 376       AC_CACHE_VAL(fu_cv_sys_mounted_getmntinfo,
 377         [
 378           ok=
 379           if test $ac_cv_func_getmntinfo = yes; then
 380             AC_EGREP_HEADER(f_type;, sys/mount.h,
 381                             ok=yes)
 382           fi
 383           test -n "$ok" \
 384               && fu_cv_sys_mounted_getmntinfo=yes \
 385               || fu_cv_sys_mounted_getmntinfo=no
 386         ])
 387       AC_MSG_RESULT([$fu_cv_sys_mounted_getmntinfo])
 388       if test $fu_cv_sys_mounted_getmntinfo = yes; then
 389         list_mounted_fs=found
 390         AC_DEFINE(MOUNTED_GETMNTINFO, 1,
 391                   [Define if `getmntinfo' function can be used])
 392         AC_MSG_CHECKING([if struct statfs has f_fstypename])
 393         AC_CACHE_VAL(fu_cv_sys_mounted_f_fstypename,
 394           [AC_EGREP_HEADER([f_fstypename],
 395                            [sys/mount.h],
 396                            [fu_cv_sys_mounted_f_fstypename=yes],
 397                            [fu_cv_sys_mounted_f_fstypename=no])
 398           ])
 399         AC_MSG_RESULT([$fu_cv_sys_mounted_f_fstypename])
 400         if test $fu_cv_sys_mounted_f_fstypename = yes; then
 401           AC_DEFINE(HAVE_F_FSTYPENAME, 1,
 402                     [Define if `f_fstypename' is member of `struct statfs'])
 403         fi
 404       fi
 405     fi
 406
 407     if test -z "$list_mounted_fs"; then
 408       # Ultrix
 409       AC_MSG_CHECKING([for getmnt function])
 410       AC_CACHE_VAL(fu_cv_sys_mounted_getmnt,
 411         [AC_TRY_CPP([
 412 #include <sys/fs_types.h>
 413 #include <sys/mount.h>],
 414                     fu_cv_sys_mounted_getmnt=yes,
 415                     fu_cv_sys_mounted_getmnt=no)])
 416       AC_MSG_RESULT([$fu_cv_sys_mounted_getmnt])
 417       if test $fu_cv_sys_mounted_getmnt = yes; then
 418         list_mounted_fs=found
 419         AC_DEFINE(MOUNTED_GETMNT, 1,
 420                   [Define if `getmnt' function can be used])
 421       fi
 422     fi
 423
 424     if test -z "$list_mounted_fs"; then
 425       # SVR2
 426     AC_MSG_CHECKING([whether it is possible to resort to fread on /etc/mnttab])
 427       AC_CACHE_VAL(fu_cv_sys_mounted_fread,
 428         [AC_TRY_CPP([#include <mnttab.h>],
 429                     fu_cv_sys_mounted_fread=yes,
 430                     fu_cv_sys_mounted_fread=no)])
 431       AC_MSG_RESULT([$fu_cv_sys_mounted_fread])
 432       if test $fu_cv_sys_mounted_fread = yes; then
 433         list_mounted_fs=found
 434         AC_DEFINE(MOUNTED_FREAD, 1,
 435                  [Define if it's possible to resort to fread on /etc/mnttab])
 436       fi
 437     fi
 438
 439     if test -z "$list_mounted_fs"; then
 440       AC_MSG_WARN([could not determine how to read list of mounted fs])
 441     else
 442       AC_DEFINE(HAVE_INFOMOUNT_LIST, 1,
 443                 [Define if the list of mounted filesystems can be determined])
 444     fi
 445
 446 dnl This configure.in code has been stolen from GNU fileutils-3.12.  Its
 447 dnl job is to detect a method to get file system information.
 448
 449     AC_MSG_NOTICE([checking how to get filesystem space usage])
 450     space=no
 451
 452     # Here we'll compromise a little (and perform only the link test)
 453     # since it seems there are no variants of the statvfs function.
 454     if test $space = no; then
 455       # SVR4
 456       AC_CHECK_FUNCS(statvfs)
 457       if test $ac_cv_func_statvfs = yes; then
 458         space=yes
 459         AC_DEFINE(STAT_STATVFS, 1,
 460                   [Define if function `statfs' can be used])
 461       fi
 462     fi
 463
 464     if test $space = no; then
 465       # DEC Alpha running OSF/1
 466       AC_MSG_CHECKING([for 3-argument statfs function (DEC OSF/1)])
 467       AC_CACHE_VAL(fu_cv_sys_stat_statfs3_osf1,
 468       [AC_TRY_RUN([
 469 #include <sys/param.h>
 470 #include <sys/types.h>
 471 #include <sys/mount.h>
 472       main ()
 473       {
 474         struct statfs fsd;
 475         fsd.f_fsize = 0;
 476         exit (statfs (".", &fsd, sizeof (struct statfs)));
 477       }],
 478       fu_cv_sys_stat_statfs3_osf1=yes,
 479       fu_cv_sys_stat_statfs3_osf1=no,
 480       fu_cv_sys_stat_statfs3_osf1=no)])
 481       AC_MSG_RESULT($fu_cv_sys_stat_statfs3_osf1)
 482       if test $fu_cv_sys_stat_statfs3_osf1 = yes; then
 483         space=yes
 484         AC_DEFINE(STAT_STATFS3_OSF1, 1,
 485                   [Define if function `statfs' takes 3 arguments])
 486       fi
 487     fi
 488
 489     if test $space = no; then
 490     # AIX
 491       AC_MSG_CHECKING([for two-argument statfs with statfs.bsize member (AIX, 4.3BSD)])
 492       AC_CACHE_VAL(fu_cv_sys_stat_statfs2_bsize,
 493       [AC_TRY_RUN([
 494 #ifdef HAVE_SYS_PARAM_H
 495 #include <sys/param.h>
 496 #endif
 497 #ifdef HAVE_SYS_MOUNT_H
 498 #include <sys/mount.h>
 499 #endif
 500 #ifdef HAVE_SYS_VFS_H
 501 #include <sys/vfs.h>
 502 #endif
 503       main ()
 504       {
 505       struct statfs fsd;
 506       fsd.f_bsize = 0;
 507       exit (statfs (".", &fsd));
 508       }],
 509       fu_cv_sys_stat_statfs2_bsize=yes,
 510       fu_cv_sys_stat_statfs2_bsize=no,
 511       fu_cv_sys_stat_statfs2_bsize=no)])
 512       AC_MSG_RESULT([$fu_cv_sys_stat_statfs2_bsize])
 513       if test $fu_cv_sys_stat_statfs2_bsize = yes; then
 514         space=yes
 515         AC_DEFINE(STAT_STATFS2_BSIZE, 1,
 516                   [Define if function `statfs' takes two arguments and
 517 `bsize' is member of `struct statfs'])
 518       fi
 519     fi
 520
 521     if test $space = no; then
 522     # SVR3
 523       AC_MSG_CHECKING([for four-argument statfs (AIX-3.2.5, SVR3)])
 524       AC_CACHE_VAL(fu_cv_sys_stat_statfs4,
 525       [AC_TRY_RUN([#include <sys/types.h>
 526 #include <sys/statfs.h>
 527       main ()
 528       {
 529       struct statfs fsd;
 530       exit (statfs (".", &fsd, sizeof fsd, 0));
 531       }],
 532         fu_cv_sys_stat_statfs4=yes,
 533         fu_cv_sys_stat_statfs4=no,
 534         fu_cv_sys_stat_statfs4=no)])
 535       AC_MSG_RESULT([$fu_cv_sys_stat_statfs4])
 536       if test $fu_cv_sys_stat_statfs4 = yes; then
 537         space=yes
 538         AC_DEFINE(STAT_STATFS4, 1,
 539                   [Define if function `statfs' takes 4 arguments])
 540       fi
 541     fi
 542
 543     if test $space = no; then
 544     # 4.4BSD and NetBSD
 545       AC_MSG_CHECKING([for two-argument statfs with statfs.fsize dnl
 546     member (4.4BSD and NetBSD)])
 547       AC_CACHE_VAL(fu_cv_sys_stat_statfs2_fsize,
 548       [AC_TRY_RUN([#include <sys/types.h>
 549 #ifdef HAVE_SYS_PARAM_H
 550 #include <sys/param.h>
 551 #endif
 552 #ifdef HAVE_SYS_MOUNT_H
 553 #include <sys/mount.h>
 554 #endif
 555       main ()
 556       {
 557       struct statfs fsd;
 558       fsd.f_fsize = 0;
 559       exit (statfs (".", &fsd));
 560       }],
 561       fu_cv_sys_stat_statfs2_fsize=yes,
 562       fu_cv_sys_stat_statfs2_fsize=no,
 563       fu_cv_sys_stat_statfs2_fsize=no)])
 564       AC_MSG_RESULT([$fu_cv_sys_stat_statfs2_fsize])
 565       if test $fu_cv_sys_stat_statfs2_fsize = yes; then
 566         space=yes
 567         AC_DEFINE(STAT_STATFS2_FSIZE, 1,
 568                   [Define if function `statfs' takes two arguments and
 569 `fsize' is member of `struct statfs'])
 570       fi
 571     fi
 572
 573     if test $space = no; then
 574       # Ultrix
 575       AC_MSG_CHECKING([for two-argument statfs with struct fs_data (Ultrix)])
 576       AC_CACHE_VAL(fu_cv_sys_stat_fs_data,
 577       [AC_TRY_RUN([
 578 #include <sys/types.h>
 579 #ifdef HAVE_SYS_PARAM_H
 580 #include <sys/param.h>
 581 #endif
 582 #ifdef HAVE_SYS_MOUNT_H
 583 #include <sys/mount.h>
 584 #endif
 585 #ifdef HAVE_SYS_FS_TYPES_H
 586 #include <sys/fs_types.h>
 587 #endif
 588       main ()
 589       {
 590       struct fs_data fsd;
 591       /* Ultrix's statfs returns 1 for success,
 592          0 for not mounted, -1 for failure.  */
 593       exit (statfs (".", &fsd) != 1);
 594       }],
 595       fu_cv_sys_stat_fs_data=yes,
 596       fu_cv_sys_stat_fs_data=no,
 597       fu_cv_sys_stat_fs_data=no)])
 598       AC_MSG_RESULT([$fu_cv_sys_stat_fs_data])
 599       if test $fu_cv_sys_stat_fs_data = yes; then
 600         space=yes
 601         AC_DEFINE(STAT_STATFS2_FS_DATA, 1,
 602                   [Define if function `statfs' takes two arguments
 603 and uses `struct fs_data'])
 604       fi
 605     fi
 606
 607     dnl Not supported
 608     dnl if test $space = no; then
 609     dnl # SVR2
 610     dnl AC_TRY_CPP([#include <sys/filsys.h>],
 611     dnl   AC_DEFINE(STAT_READ_FILSYS) space=yes)
 612     dnl fi
 613 ])
 614
 615 dnl AC_TRY_WARNINGS(INCLUDES, FUNCTION-BODY,
 616 dnl             ACTION-IF-NO-WARNINGS [, ACTION-IF-WARNINGS-OR-ERROR])
 617 AC_DEFUN([AC_TRY_WARNINGS],
 618 [cat > conftest.$ac_ext <<EOF
 619 dnl This sometimes fails to find confdefs.h, for some reason.
 620 dnl [#]line __oline__ "[$]0"
 621 [#]line __oline__ "configure"
 622 #include "confdefs.h"
 623 [$1]
 624 int main() { return 0; }
 625 int t() {
 626 [$2]
 627 ; return 0; }
 628 EOF
 629 ac_compile_warn='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 2>&1'
 630 if { if eval $ac_compile_warn; then :; else echo arning; fi; } |
 631         grep arning 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
 632   ifelse([$4], , :, [rm -rf conftest*
 633   $4])
 634 ifelse([$3], , , [else
 635   rm -rf conftest*
 636   $3
 637 ])dnl
 638 fi
 639 rm -f conftest*]
 640 )
 641
 642 AC_DEFUN([AC_USE_TERMINFO], [
 643         AC_DEFINE(SLANG_TERMINFO, 1, [Define to use S-Lang with terminfo])
 644         AC_MSG_NOTICE([using SLang screen manager/terminfo])
 645         slang_term=" with terminfo"
 646 ])
 647
 648 AC_DEFUN([AC_USE_TERMCAP], [
 649         AC_MSG_NOTICE([using S-Lang screen manager/termcap])
 650         AC_DEFINE(USE_TERMCAP, 1, [Define to use termcap library])
 651         dnl Check with $LIBS at the end so that it works with ELF libs.
 652         AC_CHECK_LIB(termcap, tgoto, [LIBS="$LIBS -ltermcap"], , [$LIBS])
 653         slang_term=" with termcap"
 654 ])
 655
 656 AC_DEFUN([AC_WITH_SLANG], [
 657         AC_DEFINE(HAVE_SLANG, 1,
 658                   [Define to use S-Lang library for screen management])
 659         search_ncurses=false
 660         if $slang_use_system_installed_lib
 661         then
 662             AC_DEFINE(HAVE_SYSTEM_SLANG, 1,
 663                       [Define to use S-Lang library installed on the system])
 664             MCLIBS="-lslang $MCLIBS"
 665             screen_manager="SLang (system-installed library)"
 666             AC_MSG_NOTICE([using system installed S-Lang library])
 667             rm -f slang/slang.h
 668             ac_save_LIBS="$LIBS"
 669             LIBS="$LIBS -lslang"
 670             AC_TRY_LINK(
 671             [
 672             #ifdef HAVE_SLANG_SLANG_H
 673             #include <slang/slang.h>
 674             #else
 675             #include <slang.h>
 676             #endif], [
 677             SLtt_get_terminfo();
 678             SLtt_tgetflag("");],
 679             [LIBS="$ac_save_LIBS"; AC_USE_TERMINFO],
 680             [LIBS="$ac_save_LIBS"; AC_USE_TERMCAP])
 681         else
 682             screen_manager="SLang"
 683             CPPFLAGS="$CPPFLAGS -I../slang"
 684             fastdepslang=fastdepslang
 685             mkdir -p slang
 686             rm -f slang/slang.h
 687             case "$srcdir" in
 688                 /*) ln -sf  $srcdir/slang/slang-mc.h slang/slang.h;;
 689                 *)  ln -sf  ../$srcdir/slang/slang-mc.h slang/slang.h;;
 690             esac
 691         fi
 692         if $slang_check_lib
 693         then
 694             use_terminfo=false
 695             for dir in  /usr/lib /usr/share/lib /usr/local/lib /lib \
 696                         /usr/local/share /usr/share
 697             do
 698                 if test -d $dir/terminfo; then
 699                 use_terminfo=true;
 700                 break
 701                 fi
 702             done
 703             if $use_terminfo; then
 704                 AC_USE_TERMINFO
 705             else
 706                 AC_USE_TERMCAP
 707             fi
 708         fi]
 709 )
 710
 711 AC_DEFUN([AC_WITH_EDIT], [
 712         AC_DEFINE(USE_INTERNAL_EDIT, 1,
 713                   [Define to enable internal editor])
 714         LIBEDIT_A="libedit.a"
 715         MCEDIT="mcedit"
 716         LEDIT="-ledit"
 717         EDIT_msg="yes"
 718         AC_MSG_NOTICE([using internal editor])
 719 ])
 720
 721 AC_DEFUN([AC_EXT2_UNDEL], [
 722   MC_UNDELFS_CHECKS
 723   if test "$ext2fs_undel" = yes; then
 724      AC_MSG_NOTICE([using ext2fs file recovery code])
 725      vfs_flags="${vfs_flags}, undelfs"
 726      undelfs_o="undelfs.o"
 727      LIBS="$LIBS $EXT2FS_UNDEL_LIBS"
 728   else
 729      AC_MSG_NOTICE([not using ext2fs file recovery code])
 730   fi
 731 ])
 732
 733 dnl
 734 dnl Parameters: directory filename LIBS_append CPPFLAGS_append nicename
 735 dnl
 736 AC_DEFUN([AC_NCURSES], [
 737     if $search_ncurses
 738     then
 739         if test -f $1/$2
 740         then
 741             AC_MSG_NOTICE([found ncurses header $1/$2])
 742             MCLIBS="$MCLIBS $3"
 743             CPPFLAGS="$CPPFLAGS $4"
 744             search_ncurses=false
 745             screen_manager=$5
 746             AC_DEFINE(USE_NCURSES, 1,
 747                       [Define to use ncurses for screen management])
 748         fi
 749     fi
 750 ])