1464 lines
37 KiB
Plaintext
1464 lines
37 KiB
Plaintext
dnl
|
|
dnl Bash specific tests
|
|
dnl
|
|
dnl Some derived from PDKSH 5.1.3 autoconf tests
|
|
dnl
|
|
dnl
|
|
dnl Check if dup2() does not clear the close on exec flag
|
|
dnl
|
|
AC_DEFUN(BASH_DUP2_CLOEXEC_CHECK,
|
|
[AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
|
|
AC_CACHE_VAL(bash_cv_dup2_broken,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
main()
|
|
{
|
|
int fd1, fd2, fl;
|
|
fd1 = open("/dev/null", 2);
|
|
if (fcntl(fd1, 2, 1) < 0)
|
|
exit(1);
|
|
fd2 = dup2(fd1, 1);
|
|
if (fd2 < 0)
|
|
exit(2);
|
|
fl = fcntl(fd2, 1, 0);
|
|
/* fl will be 1 if dup2 did not reset the close-on-exec flag. */
|
|
exit(fl != 1);
|
|
}
|
|
], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
|
|
[AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no)
|
|
bash_cv_dup2_broken=no])
|
|
])
|
|
AC_MSG_RESULT($bash_cv_dup2_broken)
|
|
if test $bash_cv_dup2_broken = yes; then
|
|
AC_DEFINE(DUP2_BROKEN)
|
|
fi
|
|
])
|
|
|
|
dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
|
|
AC_DEFUN(BASH_SIGNAL_CHECK,
|
|
[AC_REQUIRE([AC_TYPE_SIGNAL])
|
|
AC_MSG_CHECKING(for type of signal functions)
|
|
AC_CACHE_VAL(bash_cv_signal_vintage,
|
|
[
|
|
AC_TRY_LINK([#include <signal.h>],[
|
|
sigset_t ss;
|
|
struct sigaction sa;
|
|
sigemptyset(&ss); sigsuspend(&ss);
|
|
sigaction(SIGINT, &sa, (struct sigaction *) 0);
|
|
sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
|
|
], bash_cv_signal_vintage=posix,
|
|
[
|
|
AC_TRY_LINK([#include <signal.h>], [
|
|
int mask = sigmask(SIGINT);
|
|
sigsetmask(mask); sigblock(mask); sigpause(mask);
|
|
], bash_cv_signal_vintage=4.2bsd,
|
|
[
|
|
AC_TRY_LINK([
|
|
#include <signal.h>
|
|
RETSIGTYPE foo() { }], [
|
|
int mask = sigmask(SIGINT);
|
|
sigset(SIGINT, foo); sigrelse(SIGINT);
|
|
sighold(SIGINT); sigpause(SIGINT);
|
|
], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
|
|
)]
|
|
)]
|
|
)
|
|
])
|
|
AC_MSG_RESULT($bash_cv_signal_vintage)
|
|
if test "$bash_cv_signal_vintage" = posix; then
|
|
AC_DEFINE(HAVE_POSIX_SIGNALS)
|
|
elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
|
|
AC_DEFINE(HAVE_BSD_SIGNALS)
|
|
elif test "$bash_cv_signal_vintage" = svr3; then
|
|
AC_DEFINE(HAVE_USG_SIGHOLD)
|
|
fi
|
|
])
|
|
|
|
dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
|
|
AC_DEFUN(BASH_PGRP_SYNC,
|
|
[AC_REQUIRE([AC_FUNC_GETPGRP])
|
|
AC_MSG_CHECKING(whether pgrps need synchronization)
|
|
AC_CACHE_VAL(bash_cv_pgrp_pipe,
|
|
[AC_TRY_RUN([
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
main()
|
|
{
|
|
# ifdef GETPGRP_VOID
|
|
# define getpgID() getpgrp()
|
|
# else
|
|
# define getpgID() getpgrp(0)
|
|
# define setpgid(x,y) setpgrp(x,y)
|
|
# endif
|
|
int pid1, pid2, fds[2];
|
|
int status;
|
|
char ok;
|
|
|
|
switch (pid1 = fork()) {
|
|
case -1:
|
|
exit(1);
|
|
case 0:
|
|
setpgid(0, getpid());
|
|
exit(0);
|
|
}
|
|
setpgid(pid1, pid1);
|
|
|
|
sleep(2); /* let first child die */
|
|
|
|
if (pipe(fds) < 0)
|
|
exit(2);
|
|
|
|
switch (pid2 = fork()) {
|
|
case -1:
|
|
exit(3);
|
|
case 0:
|
|
setpgid(0, pid1);
|
|
ok = getpgID() == pid1;
|
|
write(fds[1], &ok, 1);
|
|
exit(0);
|
|
}
|
|
setpgid(pid2, pid1);
|
|
|
|
close(fds[1]);
|
|
if (read(fds[0], &ok, 1) != 1)
|
|
exit(4);
|
|
wait(&status);
|
|
wait(&status);
|
|
exit(ok ? 0 : 5);
|
|
}
|
|
], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
|
|
[AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
|
|
bash_cv_pgrp_pipe=no])
|
|
])
|
|
AC_MSG_RESULT($bash_cv_pgrp_pipe)
|
|
if test $bash_cv_pgrp_pipe = yes; then
|
|
AC_DEFINE(PGRP_PIPE)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl check for typedef'd symbols in header files, but allow the caller to
|
|
dnl specify the include files to be checked in addition to the default
|
|
dnl
|
|
dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
|
|
AC_DEFUN(BASH_CHECK_TYPE,
|
|
[AC_REQUIRE([AC_HEADER_STDC])dnl
|
|
AC_MSG_CHECKING(for $1)
|
|
AC_CACHE_VAL(bash_cv_type_$1,
|
|
[AC_EGREP_CPP($1, [#include <sys/types.h>
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#endif
|
|
$2
|
|
], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
|
|
AC_MSG_RESULT($bash_cv_type_$1)
|
|
ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
|
|
AC_DEFINE($4)
|
|
fi])
|
|
if test $bash_cv_type_$1 = no; then
|
|
AC_DEFINE($1, $3)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
|
|
dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
|
|
dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3). To simplify
|
|
dnl matters, this just checks for rlim_t, quad_t, or long.
|
|
dnl
|
|
AC_DEFUN(BASH_RLIMIT_TYPE,
|
|
[AC_MSG_CHECKING(for size and type of struct rlimit fields)
|
|
AC_CACHE_VAL(bash_cv_type_rlimit,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/resource.h>],
|
|
[rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
|
|
AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
main()
|
|
{
|
|
#ifdef HAVE_QUAD_T
|
|
struct rlimit rl;
|
|
if (sizeof(rl.rlim_cur) == sizeof(quad_t))
|
|
exit(0);
|
|
#endif
|
|
exit(1);
|
|
}], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
|
|
[AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long)
|
|
bash_cv_type_rlimit=long])])
|
|
])
|
|
AC_MSG_RESULT($bash_cv_type_rlimit)
|
|
if test $bash_cv_type_rlimit = quad_t; then
|
|
AC_DEFINE(RLIMTYPE, quad_t)
|
|
elif test $bash_cv_type_rlimit = rlim_t; then
|
|
AC_DEFINE(RLIMTYPE, rlim_t)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl Check for sys_siglist[] or _sys_siglist[]
|
|
dnl
|
|
AC_DEFUN(BASH_DECL_UNDER_SYS_SIGLIST,
|
|
[AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h])
|
|
AC_CACHE_VAL(bash_cv_decl_under_sys_siglist,
|
|
[AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif], [ char *msg = _sys_siglist[2]; ],
|
|
bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no,
|
|
[AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl
|
|
AC_MSG_RESULT($bash_cv_decl_under_sys_siglist)
|
|
if test $bash_cv_decl_under_sys_siglist = yes; then
|
|
AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
|
|
[AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
|
|
AC_MSG_CHECKING([for _sys_siglist in system C library])
|
|
AC_CACHE_VAL(bash_cv_under_sys_siglist,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#ifndef UNDER_SYS_SIGLIST_DECLARED
|
|
extern char *_sys_siglist[];
|
|
#endif
|
|
main()
|
|
{
|
|
char *msg = (char *)_sys_siglist[2];
|
|
exit(msg == 0);
|
|
}],
|
|
bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
|
|
[AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)
|
|
bash_cv_under_sys_siglist=no])])
|
|
AC_MSG_RESULT($bash_cv_under_sys_siglist)
|
|
if test $bash_cv_under_sys_siglist = yes; then
|
|
AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_SYS_SIGLIST,
|
|
[AC_REQUIRE([AC_DECL_SYS_SIGLIST])
|
|
AC_MSG_CHECKING([for sys_siglist in system C library])
|
|
AC_CACHE_VAL(bash_cv_sys_siglist,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#ifndef SYS_SIGLIST_DECLARED
|
|
extern char *sys_siglist[];
|
|
#endif
|
|
main()
|
|
{
|
|
char *msg = sys_siglist[2];
|
|
exit(msg == 0);
|
|
}],
|
|
bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
|
|
[AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no)
|
|
bash_cv_sys_siglist=no])])
|
|
AC_MSG_RESULT($bash_cv_sys_siglist)
|
|
if test $bash_cv_sys_siglist = yes; then
|
|
AC_DEFINE(HAVE_SYS_SIGLIST)
|
|
fi
|
|
])
|
|
|
|
dnl Check for sys_errlist[] and sys_nerr, check for declaration
|
|
AC_DEFUN(BASH_SYS_ERRLIST,
|
|
[AC_MSG_CHECKING([for sys_errlist and sys_nerr])
|
|
AC_CACHE_VAL(bash_cv_sys_errlist,
|
|
[AC_TRY_LINK([#include <errno.h>],
|
|
[extern char *sys_errlist[];
|
|
extern int sys_nerr;
|
|
char *msg = sys_errlist[sys_nerr - 1];],
|
|
bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
|
|
AC_MSG_RESULT($bash_cv_sys_errlist)
|
|
if test $bash_cv_sys_errlist = yes; then
|
|
AC_DEFINE(HAVE_SYS_ERRLIST)
|
|
fi
|
|
])
|
|
|
|
dnl Check to see if opendir will open non-directories (not a nice thing)
|
|
AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
|
|
[AC_REQUIRE([AC_HEADER_DIRENT])dnl
|
|
AC_MSG_CHECKING(if opendir() opens non-directories)
|
|
AC_CACHE_VAL(bash_cv_opendir_not_robust,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif /* HAVE_UNISTD_H */
|
|
#if defined(HAVE_DIRENT_H)
|
|
# include <dirent.h>
|
|
#else
|
|
# define dirent direct
|
|
# ifdef HAVE_SYS_NDIR_H
|
|
# include <sys/ndir.h>
|
|
# endif /* SYSNDIR */
|
|
# ifdef HAVE_SYS_DIR_H
|
|
# include <sys/dir.h>
|
|
# endif /* SYSDIR */
|
|
# ifdef HAVE_NDIR_H
|
|
# include <ndir.h>
|
|
# endif
|
|
#endif /* HAVE_DIRENT_H */
|
|
main()
|
|
{
|
|
DIR *dir;
|
|
int fd, err;
|
|
err = mkdir("/tmp/bash-aclocal", 0700);
|
|
if (err < 0) {
|
|
perror("mkdir");
|
|
exit(1);
|
|
}
|
|
unlink("/tmp/bash-aclocal/not_a_directory");
|
|
fd = open("/tmp/bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
|
|
write(fd, "\n", 1);
|
|
close(fd);
|
|
dir = opendir("/tmp/bash-aclocal/not_a_directory");
|
|
unlink("/tmp/bash-aclocal/not_a_directory");
|
|
rmdir("/tmp/bash-aclocal");
|
|
exit (dir == 0);
|
|
}], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
|
|
[AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
|
|
bash_cv_opendir_not_robust=no]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_opendir_not_robust)
|
|
if test $bash_cv_opendir_not_robust = yes; then
|
|
AC_DEFINE(OPENDIR_NOT_ROBUST)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_SIGHANDLER,
|
|
[AC_MSG_CHECKING([whether signal handlers are of type void])
|
|
AC_CACHE_VAL(bash_cv_void_sighandler,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <signal.h>
|
|
#ifdef signal
|
|
#undef signal
|
|
#endif
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
void (*signal ()) ();],
|
|
[int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
|
|
AC_MSG_RESULT($bash_cv_void_sighandler)
|
|
if test $bash_cv_void_sighandler = yes; then
|
|
AC_DEFINE(VOID_SIGHANDLER)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl A signed 16-bit integer quantity
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_BITS16_T,
|
|
[
|
|
if test "$ac_cv_sizeof_short" = 2; then
|
|
AC_CHECK_TYPE(bits16_t, short)
|
|
elif test "$ac_cv_sizeof_char" = 2; then
|
|
AC_CHECK_TYPE(bits16_t, char)
|
|
else
|
|
AC_CHECK_TYPE(bits16_t, short)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl An unsigned 16-bit integer quantity
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_U_BITS16_T,
|
|
[
|
|
if test "$ac_cv_sizeof_short" = 2; then
|
|
AC_CHECK_TYPE(u_bits16_t, unsigned short)
|
|
elif test "$ac_cv_sizeof_char" = 2; then
|
|
AC_CHECK_TYPE(u_bits16_t, unsigned char)
|
|
else
|
|
AC_CHECK_TYPE(u_bits16_t, unsigned short)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl A signed 32-bit integer quantity
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_BITS32_T,
|
|
[
|
|
if test "$ac_cv_sizeof_int" = 4; then
|
|
AC_CHECK_TYPE(bits32_t, int)
|
|
elif test "$ac_cv_sizeof_long" = 4; then
|
|
AC_CHECK_TYPE(bits32_t, long)
|
|
else
|
|
AC_CHECK_TYPE(bits32_t, int)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl An unsigned 32-bit integer quantity
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_U_BITS32_T,
|
|
[
|
|
if test "$ac_cv_sizeof_int" = 4; then
|
|
AC_CHECK_TYPE(u_bits32_t, unsigned int)
|
|
elif test "$ac_cv_sizeof_long" = 4; then
|
|
AC_CHECK_TYPE(u_bits32_t, unsigned long)
|
|
else
|
|
AC_CHECK_TYPE(u_bits32_t, unsigned int)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_TYPE_PTRDIFF_T,
|
|
[
|
|
if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
|
|
AC_CHECK_TYPE(ptrdiff_t, int)
|
|
elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
|
|
AC_CHECK_TYPE(ptrdiff_t, long)
|
|
else
|
|
AC_CHECK_TYPE(ptrdiff_t, int)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl A signed 64-bit quantity
|
|
dnl
|
|
AC_DEFUN(BASH_TYPE_BITS64_T,
|
|
[
|
|
if test "$ac_sv_sizeof_char_p" = 8; then
|
|
AC_CHECK_TYPE(bits64_t, char *)
|
|
elif test "$ac_cv_sizeof_double" = 8; then
|
|
AC_CHECK_TYPE(bits64_t, double)
|
|
elif test "$ac_cv_sizeof_long" = 8; then
|
|
AC_CHECK_TYPE(bits64_t, long)
|
|
else
|
|
AC_CHECK_TYPE(bits64_t, double)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_STRSIGNAL,
|
|
[AC_MSG_CHECKING([for the existence of strsignal])
|
|
AC_CACHE_VAL(bash_cv_have_strsignal,
|
|
[AC_TRY_LINK([#include <sys/types.h>
|
|
#include <signal.h>],
|
|
[char *s = (char *)strsignal(2);],
|
|
bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
|
|
AC_MSG_RESULT($bash_cv_have_strsignal)
|
|
if test $bash_cv_have_strsignal = yes; then
|
|
AC_DEFINE(HAVE_STRSIGNAL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_LSTAT,
|
|
[dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
|
|
dnl inline function in <sys/stat.h>.
|
|
AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
|
|
[AC_TRY_LINK([
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
],[ lstat(".",(struct stat *)0); ],
|
|
bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
|
|
if test $bash_cv_func_lstat = yes; then
|
|
AC_DEFINE(HAVE_LSTAT)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_INET_ATON,
|
|
[
|
|
AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton,
|
|
[AC_TRY_LINK([
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ],
|
|
bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)])
|
|
if test $bash_cv_func_inet_aton = yes; then
|
|
AC_DEFINE(HAVE_INET_ATON)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
|
|
[AC_MSG_CHECKING([for a c_line member of struct termios])
|
|
AC_CACHE_VAL(bash_cv_termios_ldisc,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <termios.h>],[struct termios t; int i; i = t.c_line;],
|
|
bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl
|
|
AC_MSG_RESULT($bash_cv_termios_ldisc)
|
|
if test $bash_cv_termios_ldisc = yes; then
|
|
AC_DEFINE(TERMIOS_LDISC)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
|
|
[AC_MSG_CHECKING([for a c_line member of struct termio])
|
|
AC_CACHE_VAL(bash_cv_termio_ldisc,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <termio.h>],[struct termio t; int i; i = t.c_line;],
|
|
bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl
|
|
AC_MSG_RESULT($bash_cv_termio_ldisc)
|
|
if test $bash_cv_termio_ldisc = yes; then
|
|
AC_DEFINE(TERMIO_LDISC)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_GETENV,
|
|
[AC_MSG_CHECKING(to see if getenv can be redefined)
|
|
AC_CACHE_VAL(bash_cv_getenv_redef,
|
|
[AC_TRY_RUN([
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#ifndef __STDC__
|
|
# ifndef const
|
|
# define const
|
|
# endif
|
|
#endif
|
|
char *
|
|
getenv (name)
|
|
#if defined (__linux__) || defined (__bsdi__) || defined (convex)
|
|
const char *name;
|
|
#else
|
|
char const *name;
|
|
#endif /* !__linux__ && !__bsdi__ && !convex */
|
|
{
|
|
return "42";
|
|
}
|
|
main()
|
|
{
|
|
char *s;
|
|
/* The next allows this program to run, but does not allow bash to link
|
|
when it redefines getenv. I'm not really interested in figuring out
|
|
why not. */
|
|
#if defined (NeXT)
|
|
exit(1);
|
|
#endif
|
|
s = getenv("ABCDE");
|
|
exit(s == 0); /* force optimizer to leave getenv in */
|
|
}
|
|
], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
|
|
[AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
|
|
bash_cv_getenv_redef=yes]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_getenv_redef)
|
|
if test $bash_cv_getenv_redef = yes; then
|
|
AC_DEFINE(CAN_REDEFINE_GETENV)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_PRINTF,
|
|
[AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
|
|
AC_CACHE_VAL(bash_cv_printf_declared,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#ifdef __STDC__
|
|
typedef int (*_bashfunc)(const char *, ...);
|
|
#else
|
|
typedef int (*_bashfunc)();
|
|
#endif
|
|
main()
|
|
{
|
|
_bashfunc pf;
|
|
pf = (_bashfunc) printf;
|
|
exit(pf == 0);
|
|
}
|
|
], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
|
|
[AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
|
|
bash_cv_printf_declared=yes]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_printf_declared)
|
|
if test $bash_cv_printf_declared = yes; then
|
|
AC_DEFINE(PRINTF_DECLARED)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
|
|
[AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
|
|
AC_CACHE_VAL(bash_cv_ulimit_maxfds,
|
|
[AC_TRY_RUN([
|
|
main()
|
|
{
|
|
long maxfds = ulimit(4, 0L);
|
|
exit (maxfds == -1L);
|
|
}
|
|
], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
|
|
[AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
|
|
bash_cv_ulimit_maxfds=no]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_ulimit_maxfds)
|
|
if test $bash_cv_ulimit_maxfds = yes; then
|
|
AC_DEFINE(ULIMIT_MAXFDS)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
|
|
[
|
|
if test "X$bash_cv_termcap_lib" = "X"; then
|
|
_bash_needmsg=yes
|
|
else
|
|
AC_MSG_CHECKING(which library has the termcap functions)
|
|
_bash_needmsg=
|
|
fi
|
|
AC_CACHE_VAL(bash_cv_termcap_lib,
|
|
[AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
|
|
[AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
|
|
[AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
|
|
bash_cv_termcap_lib=gnutermcap)])])])
|
|
if test "X$_bash_needmsg" = "Xyes"; then
|
|
AC_MSG_CHECKING(which library has the termcap functions)
|
|
fi
|
|
AC_MSG_RESULT(using $bash_cv_termcap_lib)
|
|
if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
|
|
LDFLAGS="$LDFLAGS -L./lib/termcap"
|
|
TERMCAP_LIB="./lib/termcap/libtermcap.a"
|
|
TERMCAP_DEP="./lib/termcap/libtermcap.a"
|
|
elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
|
|
TERMCAP_LIB=-ltermcap
|
|
TERMCAP_DEP=
|
|
elif test $bash_cv_termcap_lib = libncurses; then
|
|
TERMCAP_LIB=-lncurses
|
|
TERMCAP_DEP=
|
|
else
|
|
TERMCAP_LIB=-lcurses
|
|
TERMCAP_DEP=
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_GETCWD,
|
|
[AC_MSG_CHECKING([if getcwd() calls popen()])
|
|
AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifndef __STDC__
|
|
#ifndef const
|
|
#define const
|
|
#endif
|
|
#endif
|
|
|
|
int popen_called;
|
|
|
|
FILE *
|
|
popen(command, type)
|
|
const char *command;
|
|
const char *type;
|
|
{
|
|
popen_called = 1;
|
|
return (FILE *)NULL;
|
|
}
|
|
|
|
FILE *_popen(command, type)
|
|
const char *command;
|
|
const char *type;
|
|
{
|
|
return (popen (command, type));
|
|
}
|
|
|
|
int
|
|
pclose(stream)
|
|
FILE *stream;
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
_pclose(stream)
|
|
FILE *stream;
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
main()
|
|
{
|
|
char lbuf[32];
|
|
popen_called = 0;
|
|
getcwd(lbuf, 32);
|
|
exit (popen_called);
|
|
}
|
|
], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
|
|
[AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no)
|
|
bash_cv_getcwd_calls_popen=no]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
|
|
if test $bash_cv_getcwd_calls_popen = yes; then
|
|
AC_DEFINE(GETCWD_BROKEN)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
|
|
[AC_REQUIRE([AC_HEADER_DIRENT])
|
|
AC_MSG_CHECKING(if struct dirent has a d_ino member)
|
|
AC_CACHE_VAL(bash_cv_dirent_has_dino,
|
|
[AC_TRY_COMPILE([
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif /* HAVE_UNISTD_H */
|
|
#if defined(HAVE_DIRENT_H)
|
|
# include <dirent.h>
|
|
#else
|
|
# define dirent direct
|
|
# ifdef HAVE_SYS_NDIR_H
|
|
# include <sys/ndir.h>
|
|
# endif /* SYSNDIR */
|
|
# ifdef HAVE_SYS_DIR_H
|
|
# include <sys/dir.h>
|
|
# endif /* SYSDIR */
|
|
# ifdef HAVE_NDIR_H
|
|
# include <ndir.h>
|
|
# endif
|
|
#endif /* HAVE_DIRENT_H */
|
|
],[
|
|
struct dirent d; int z; z = d.d_ino;
|
|
], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
|
|
AC_MSG_RESULT($bash_cv_dirent_has_dino)
|
|
if test $bash_cv_dirent_has_dino = yes; then
|
|
AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
|
|
[AC_REQUIRE([AC_HEADER_DIRENT])
|
|
AC_MSG_CHECKING(if struct dirent has a d_fileno member)
|
|
AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
|
|
[AC_TRY_COMPILE([
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif /* HAVE_UNISTD_H */
|
|
#if defined(HAVE_DIRENT_H)
|
|
# include <dirent.h>
|
|
#else
|
|
# define dirent direct
|
|
# ifdef HAVE_SYS_NDIR_H
|
|
# include <sys/ndir.h>
|
|
# endif /* SYSNDIR */
|
|
# ifdef HAVE_SYS_DIR_H
|
|
# include <sys/dir.h>
|
|
# endif /* SYSDIR */
|
|
# ifdef HAVE_NDIR_H
|
|
# include <ndir.h>
|
|
# endif
|
|
#endif /* HAVE_DIRENT_H */
|
|
],[
|
|
struct dirent d; int z; z = d.d_fileno;
|
|
], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
|
|
AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
|
|
if test $bash_cv_dirent_has_d_fileno = yes; then
|
|
AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_REINSTALL_SIGHANDLERS,
|
|
[AC_REQUIRE([AC_TYPE_SIGNAL])
|
|
AC_REQUIRE([BASH_SIGNAL_CHECK])
|
|
AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
|
|
AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
|
|
[AC_TRY_RUN([
|
|
#include <signal.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
typedef RETSIGTYPE sigfunc();
|
|
|
|
int nsigint;
|
|
|
|
#ifdef HAVE_POSIX_SIGNALS
|
|
sigfunc *
|
|
set_signal_handler(sig, handler)
|
|
int sig;
|
|
sigfunc *handler;
|
|
{
|
|
struct sigaction act, oact;
|
|
act.sa_handler = handler;
|
|
act.sa_flags = 0;
|
|
sigemptyset (&act.sa_mask);
|
|
sigemptyset (&oact.sa_mask);
|
|
sigaction (sig, &act, &oact);
|
|
return (oact.sa_handler);
|
|
}
|
|
#else
|
|
#define set_signal_handler(s, h) signal(s, h)
|
|
#endif
|
|
|
|
RETSIGTYPE
|
|
sigint(s)
|
|
int s;
|
|
{
|
|
nsigint++;
|
|
}
|
|
|
|
main()
|
|
{
|
|
nsigint = 0;
|
|
set_signal_handler(SIGINT, sigint);
|
|
kill((int)getpid(), SIGINT);
|
|
kill((int)getpid(), SIGINT);
|
|
exit(nsigint != 2);
|
|
}
|
|
], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
|
|
[AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
|
|
bash_cv_must_reinstall_sighandlers=no]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
|
|
if test $bash_cv_must_reinstall_sighandlers = yes; then
|
|
AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_SBRK_DECLARED,
|
|
[AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
|
|
AC_CACHE_VAL(bash_cv_sbrk_declared,
|
|
[AC_EGREP_HEADER(sbrk, unistd.h,
|
|
bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
|
|
AC_MSG_RESULT($bash_cv_sbrk_declared)
|
|
if test $bash_cv_sbrk_declared = yes; then
|
|
AC_DEFINE(SBRK_DECLARED)
|
|
fi
|
|
])
|
|
|
|
dnl check that some necessary job control definitions are present
|
|
AC_DEFUN(BASH_JOB_CONTROL_MISSING,
|
|
[AC_REQUIRE([BASH_SIGNAL_CHECK])
|
|
AC_MSG_CHECKING(for presence of necessary job control definitions)
|
|
AC_CACHE_VAL(bash_cv_job_control_missing,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_WAIT_H
|
|
#include <sys/wait.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <signal.h>
|
|
|
|
/* Add more tests in here as appropriate. */
|
|
main()
|
|
{
|
|
/* signal type */
|
|
#if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
|
|
exit(1);
|
|
#endif
|
|
|
|
/* signals and tty control. */
|
|
#if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
|
|
exit (1);
|
|
#endif
|
|
|
|
/* process control */
|
|
#if !defined (WNOHANG) || !defined (WUNTRACED)
|
|
exit(1);
|
|
#endif
|
|
|
|
/* Posix systems have tcgetpgrp and waitpid. */
|
|
#if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
|
|
exit(1);
|
|
#endif
|
|
|
|
#if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
|
|
exit(1);
|
|
#endif
|
|
|
|
/* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
|
|
#if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
|
|
exit(1);
|
|
#endif
|
|
|
|
exit(0);
|
|
}], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
|
|
[AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
|
|
bash_cv_job_control_missing=missing]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_job_control_missing)
|
|
if test $bash_cv_job_control_missing = missing; then
|
|
AC_DEFINE(JOB_CONTROL_MISSING)
|
|
fi
|
|
])
|
|
|
|
dnl check whether named pipes are present
|
|
dnl this requires a previous check for mkfifo, but that is awkward to specify
|
|
AC_DEFUN(BASH_SYS_NAMED_PIPES,
|
|
[AC_MSG_CHECKING(for presence of named pipes)
|
|
AC_CACHE_VAL(bash_cv_sys_named_pipes,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
/* Add more tests in here as appropriate. */
|
|
main()
|
|
{
|
|
int fd, err;
|
|
|
|
#if defined (HAVE_MKFIFO)
|
|
exit (0);
|
|
#endif
|
|
|
|
#if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
|
|
exit (1);
|
|
#endif
|
|
|
|
#if defined (NeXT)
|
|
exit (1);
|
|
#endif
|
|
err = mkdir("/tmp/bash-aclocal", 0700);
|
|
if (err < 0) {
|
|
perror ("mkdir");
|
|
exit(1);
|
|
}
|
|
fd = mknod ("/tmp/bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
|
|
if (fd == -1) {
|
|
rmdir ("/tmp/bash-aclocal");
|
|
exit (1);
|
|
}
|
|
close(fd);
|
|
unlink ("/tmp/bash-aclocal/sh-np-autoconf");
|
|
rmdir ("/tmp/bash-aclocal");
|
|
exit(0);
|
|
}], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
|
|
[AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
|
|
bash_cv_sys_named_pipes=missing]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_sys_named_pipes)
|
|
if test $bash_cv_sys_named_pipes = missing; then
|
|
AC_DEFINE(NAMED_PIPES_MISSING)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
|
|
[AC_REQUIRE([BASH_SIGNAL_CHECK])
|
|
AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
|
|
AC_CACHE_VAL(bash_cv_func_sigsetjmp,
|
|
[AC_TRY_RUN([
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#include <setjmp.h>
|
|
|
|
main()
|
|
{
|
|
#if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
|
|
exit (1);
|
|
#else
|
|
|
|
int code;
|
|
sigset_t set, oset;
|
|
sigjmp_buf xx;
|
|
|
|
/* get the mask */
|
|
sigemptyset(&set);
|
|
sigemptyset(&oset);
|
|
sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
|
|
sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
|
|
|
|
/* save it */
|
|
code = sigsetjmp(xx, 1);
|
|
if (code)
|
|
exit(0); /* could get sigmask and compare to oset here. */
|
|
|
|
/* change it */
|
|
sigaddset(&set, SIGINT);
|
|
sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
|
|
|
|
/* and siglongjmp */
|
|
siglongjmp(xx, 10);
|
|
exit(1);
|
|
#endif
|
|
}], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
|
|
[AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
|
|
bash_cv_func_sigsetjmp=missing]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_func_sigsetjmp)
|
|
if test $bash_cv_func_sigsetjmp = present; then
|
|
AC_DEFINE(HAVE_POSIX_SIGSETJMP)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
|
|
[AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
|
|
AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
|
|
bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
|
|
AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
|
|
if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
|
|
AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_STRUCT_WINSIZE,
|
|
[AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
|
|
AC_CACHE_VAL(bash_cv_struct_winsize_header,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/ioctl.h>], [struct winsize x;],
|
|
bash_cv_struct_winsize_header=ioctl_h,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <termios.h>], [struct winsize x;],
|
|
bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
|
|
])])
|
|
if test $bash_cv_struct_winsize_header = ioctl_h; then
|
|
AC_MSG_RESULT(sys/ioctl.h)
|
|
AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
|
|
elif test $bash_cv_struct_winsize_header = termios_h; then
|
|
AC_MSG_RESULT(termios.h)
|
|
AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
|
|
else
|
|
AC_MSG_RESULT(not found)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_HAVE_TIOCSTAT,
|
|
[AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
|
|
AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/ioctl.h>], [int x = TIOCSTAT;],
|
|
bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
|
|
AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
|
|
if test $bash_cv_tiocstat_in_ioctl = yes; then
|
|
AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_HAVE_FIONREAD,
|
|
[AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
|
|
AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>
|
|
#include <sys/ioctl.h>], [int x = FIONREAD;],
|
|
bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
|
|
AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
|
|
if test $bash_cv_fionread_in_ioctl = yes; then
|
|
AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl See if speed_t is declared in <sys/types.h>. Some versions of linux
|
|
dnl require a definition of speed_t each time <termcap.h> is included,
|
|
dnl but you can only get speed_t if you include <termios.h> (on some
|
|
dnl versions) or <sys/types.h> (on others).
|
|
dnl
|
|
AC_DEFUN(BASH_MISC_SPEED_T,
|
|
[AC_MSG_CHECKING(for speed_t in sys/types.h)
|
|
AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
|
|
[AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
|
|
bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
|
|
AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
|
|
if test $bash_cv_speed_t_in_sys_types = yes; then
|
|
AC_DEFINE(SPEED_T_IN_SYS_TYPES)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
|
|
[AC_MSG_CHECKING(whether getpw functions are declared in pwd.h)
|
|
AC_CACHE_VAL(bash_cv_getpw_declared,
|
|
[AC_EGREP_CPP(getpwuid,
|
|
[
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <pwd.h>
|
|
],
|
|
bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)])
|
|
AC_MSG_RESULT($bash_cv_getpw_declared)
|
|
if test $bash_cv_getpw_declared = yes; then
|
|
AC_DEFINE(HAVE_GETPW_DECLS)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_CHECK_DEV_FD,
|
|
[AC_MSG_CHECKING(whether /dev/fd is available)
|
|
AC_CACHE_VAL(bash_cv_dev_fd,
|
|
[if test -d /dev/fd && test -r /dev/fd/0; then
|
|
bash_cv_dev_fd=standard
|
|
elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
|
|
bash_cv_dev_fd=whacky
|
|
else
|
|
bash_cv_dev_fd=absent
|
|
fi
|
|
])
|
|
AC_MSG_RESULT($bash_cv_dev_fd)
|
|
if test $bash_cv_dev_fd = "standard"; then
|
|
AC_DEFINE(HAVE_DEV_FD)
|
|
AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
|
|
elif test $bash_cv_dev_fd = "whacky"; then
|
|
AC_DEFINE(HAVE_DEV_FD)
|
|
AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_CHECK_DEV_STDIN,
|
|
[AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
|
|
AC_CACHE_VAL(bash_cv_dev_stdin,
|
|
[if test -d /dev/fd && test -r /dev/stdin; then
|
|
bash_cv_dev_stdin=present
|
|
elif test -d /proc/self/fd && test -r /dev/stdin; then
|
|
bash_cv_dev_stdin=present
|
|
else
|
|
bash_cv_dev_stdin=absent
|
|
fi
|
|
])
|
|
AC_MSG_RESULT($bash_cv_dev_stdin)
|
|
if test $bash_cv_dev_stdin = "present"; then
|
|
AC_DEFINE(HAVE_DEV_STDIN)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl Check for the presence of getpeername in libsocket.
|
|
dnl If libsocket is present, check for libnsl and add it to LIBS if
|
|
dnl it's there, since most systems with libsocket require linking
|
|
dnl with libnsl as well. This should only be called if getpeername
|
|
dnl was not found in libc.
|
|
dnl
|
|
dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
|
|
dnl AS WELL
|
|
dnl
|
|
AC_DEFUN(BASH_CHECK_SOCKLIB,
|
|
[
|
|
if test "X$bash_cv_have_socklib" = "X"; then
|
|
_bash_needmsg=
|
|
else
|
|
AC_MSG_CHECKING(for socket library)
|
|
_bash_needmsg=yes
|
|
fi
|
|
AC_CACHE_VAL(bash_cv_have_socklib,
|
|
[AC_CHECK_LIB(socket, getpeername,
|
|
bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
|
|
if test "X$_bash_needmsg" = Xyes; then
|
|
AC_MSG_RESULT($bash_cv_have_socklib)
|
|
_bash_needmsg=
|
|
fi
|
|
if test $bash_cv_have_socklib = yes; then
|
|
# check for libnsl, add it to LIBS if present
|
|
if test "X$bash_cv_have_libnsl" = "X"; then
|
|
_bash_needmsg=
|
|
else
|
|
AC_MSG_CHECKING(for libnsl)
|
|
_bash_needmsg=yes
|
|
fi
|
|
AC_CACHE_VAL(bash_cv_have_libnsl,
|
|
[AC_CHECK_LIB(nsl, t_open,
|
|
bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
|
|
if test "X$_bash_needmsg" = Xyes; then
|
|
AC_MSG_RESULT($bash_cv_have_libnsl)
|
|
_bash_needmsg=
|
|
fi
|
|
if test $bash_cv_have_libnsl = yes; then
|
|
LIBS="-lsocket -lnsl $LIBS"
|
|
else
|
|
LIBS="-lsocket $LIBS"
|
|
fi
|
|
AC_DEFINE(HAVE_LIBSOCKET)
|
|
AC_DEFINE(HAVE_GETPEERNAME)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
|
|
dnl system, we can't use AC_PREREQ
|
|
dnl
|
|
AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
|
|
[if test "X$bash_cv_have_gethostbyname" = "X"; then
|
|
_bash_needmsg=yes
|
|
else
|
|
AC_MSG_CHECKING(for gethostbyname in socket library)
|
|
_bash_needmsg=
|
|
fi
|
|
AC_CACHE_VAL(bash_cv_have_gethostbyname,
|
|
[AC_TRY_LINK([#include <netdb.h>],
|
|
[ struct hostent *hp;
|
|
hp = gethostbyname("localhost");
|
|
], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
|
|
)
|
|
if test "X$_bash_needmsg" = Xyes; then
|
|
AC_MSG_CHECKING(for gethostbyname in socket library)
|
|
fi
|
|
AC_MSG_RESULT($bash_cv_have_gethostbyname)
|
|
if test "$bash_cv_have_gethostbyname" = yes; then
|
|
AC_DEFINE(HAVE_GETHOSTBYNAME)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_DEFAULT_MAIL_DIR,
|
|
[AC_MSG_CHECKING(for default mail directory)
|
|
AC_CACHE_VAL(bash_cv_mail_dir,
|
|
[if test -d /var/mail; then
|
|
bash_cv_mail_dir=/var/mail
|
|
elif test -d /usr/mail; then
|
|
bash_cv_mail_dir=/usr/mail
|
|
elif test -d /var/spool/mail; then
|
|
bash_cv_mail_dir=/var/spool/mail
|
|
elif test -d /usr/spool/mail; then
|
|
bash_cv_mail_dir=/usr/spool/mail
|
|
else
|
|
bash_cv_mail_dir=unknown
|
|
fi
|
|
])
|
|
AC_MSG_RESULT($bash_cv_mail_dir)
|
|
if test $bash_cv_mail_dir = "/var/mail"; then
|
|
AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
|
|
elif test $bash_cv_mail_dir = "/usr/mail"; then
|
|
AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
|
|
elif test $bash_cv_mail_dir = "/var/spool/mail"; then
|
|
AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
|
|
elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
|
|
AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
|
|
else
|
|
AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
|
|
dnl
|
|
AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK,
|
|
[AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
|
|
AC_CACHE_VAL(bash_cv_kernel_rlimit,
|
|
[AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <sys/resource.h>
|
|
],
|
|
[
|
|
int f;
|
|
f = RLIMIT_DATA;
|
|
], bash_cv_kernel_rlimit=no,
|
|
[AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#define _KERNEL
|
|
#include <sys/resource.h>
|
|
#undef _KERNEL
|
|
],
|
|
[
|
|
int f;
|
|
f = RLIMIT_DATA;
|
|
], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_kernel_rlimit)
|
|
if test $bash_cv_kernel_rlimit = yes; then
|
|
AC_DEFINE(RLIMIT_NEEDS_KERNEL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_FUNC_STRCOLL,
|
|
[
|
|
AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
|
|
AC_CACHE_VAL(bash_cv_func_strcoll_broken,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#if defined (HAVE_LOCALE_H)
|
|
#include <locale.h>
|
|
#endif
|
|
|
|
main(c, v)
|
|
int c;
|
|
char *v[];
|
|
{
|
|
int r1, r2;
|
|
char *deflocale, *defcoll;
|
|
|
|
#ifdef HAVE_SETLOCALE
|
|
deflocale = setlocale(LC_ALL, "");
|
|
defcoll = setlocale(LC_COLLATE, "");
|
|
#endif
|
|
|
|
#ifdef HAVE_STRCOLL
|
|
/* These two values are taken from tests/glob-test. */
|
|
r1 = strcoll("abd", "aXd");
|
|
#else
|
|
r1 = 0;
|
|
#endif
|
|
r2 = strcmp("abd", "aXd");
|
|
|
|
/* These two should both be greater than 0. It is permissible for
|
|
a system to return different values, as long as the sign is the
|
|
same. */
|
|
|
|
/* Exit with 1 (failure) if these two values are both > 0, since
|
|
this tests whether strcoll(3) is broken with respect to strcmp(3)
|
|
in the default locale. */
|
|
exit (r1 > 0 && r2 > 0);
|
|
}
|
|
], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
|
|
[AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
|
|
bash_cv_func_strcoll_broken=no]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_func_strcoll_broken)
|
|
if test $bash_cv_func_strcoll_broken = yes; then
|
|
AC_DEFINE(STRCOLL_BROKEN)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl If available, use support for large files unless the user specified
|
|
dnl one of the CPPFLAGS, LDFLAGS, or LIBS variables (<eggert@twinsun.com>
|
|
dnl via GNU patch 2.5)
|
|
dnl
|
|
AC_DEFUN(BASH_LARGE_FILE_SUPPORT,
|
|
[AC_MSG_CHECKING(whether large file support needs explicit enabling)
|
|
ac_getconfs=''
|
|
ac_result=yes
|
|
ac_set=''
|
|
ac_shellvars='CPPFLAGS LDFLAGS LIBS'
|
|
for ac_shellvar in $ac_shellvars; do
|
|
case $ac_shellvar in
|
|
CPPFLAGS) ac_lfsvar=LFS_CFLAGS ac_lfs64var=LFS64_CFLAGS ;;
|
|
*) ac_lfsvar=LFS_$ac_shellvar ac_lfs64var=LFS64_$ac_shellvar ;;
|
|
esac
|
|
eval test '"${'$ac_shellvar'+set}"' = set && ac_set=$ac_shellvar
|
|
(getconf $ac_lfsvar) >/dev/null 2>&1 || { ac_result=no; break; }
|
|
ac_getconf=`getconf $ac_lfsvar`
|
|
ac_getconf64=`getconf $ac_lfs64var`
|
|
ac_getconfs=$ac_getconfs$ac_getconf\ $ac_getconf64
|
|
eval ac_test_$ac_shellvar="\$ac_getconf\ \$ac_getconf64"
|
|
done
|
|
case "$ac_result$ac_getconfs" in
|
|
yes) ac_result=no ;;
|
|
esac
|
|
case "$ac_result$ac_set" in
|
|
yes?*) ac_result="yes, but $ac_set is already set, so use its settings"
|
|
esac
|
|
AC_MSG_RESULT($ac_result)
|
|
case $ac_result in
|
|
yes)
|
|
for ac_shellvar in $ac_shellvars; do
|
|
eval $ac_shellvar=\$ac_test_$ac_shellvar
|
|
done ;;
|
|
esac
|
|
])
|
|
|
|
dnl
|
|
dnl AC_SYS_RESTARTABLE_SYSCALLS tests only for restarted system calls
|
|
dnl after a signal handler has been installed with signal(). Since
|
|
dnl Bash uses sigaction() if it is available, we need to check whether
|
|
dnl or not a signal handler installed with sigaction and SA_RESTART
|
|
dnl causes system calls to be restarted after the signal is caught
|
|
dnl
|
|
AC_DEFUN(BASH_SYS_RESTARTABLE_SYSCALLS,
|
|
[AC_REQUIRE([BASH_SIGNAL_CHECK])
|
|
AC_CACHE_CHECK(whether posix sigaction restarts system calls by default,
|
|
bash_cv_sys_restartable_syscalls,
|
|
[AC_TRY_RUN(
|
|
[/* Exit 0 (true) if wait returns something other than -1,
|
|
i.e. the pid of the child, which means that wait was restarted
|
|
after getting the signal. */
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
static int caught = 0;
|
|
void ucatch (isig) int isig; { caught = 1; }
|
|
main ()
|
|
{
|
|
#if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
|
|
exit (1);
|
|
#else
|
|
struct sigaction act, oact;
|
|
int i, status;
|
|
|
|
act.sa_handler = ucatch;
|
|
/* Might want to add SA_RESTART here, but bash's set_signal_handler
|
|
does not. */
|
|
act.sa_flags = 0;
|
|
sigemptyset(&act.sa_mask);
|
|
sigemptyset(&oact.sa_mask);
|
|
i = fork ();
|
|
/* A possible race condition here, but in practice it never happens. */
|
|
if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
|
|
sigaction(SIGINT, &act, &oact);
|
|
status = wait(&i);
|
|
if (status == -1) wait(&i);
|
|
exit (status == -1);
|
|
#endif
|
|
}
|
|
], bash_cv_sys_restartable_syscalls=yes, bash_cv_sys_restartable_syscalls=no,
|
|
AC_MSG_WARN(cannot check restartable syscalls if cross compiling))
|
|
])
|
|
if test $bash_cv_sys_restartable_syscalls = yes; then
|
|
AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
|
|
fi
|
|
])
|
|
dnl
|
|
dnl Check for 64-bit off_t -- used for malloc alignment
|
|
dnl
|
|
dnl C does not allow duplicate case labels, so the compile will fail if
|
|
dnl sizeof(off_t) is > 4.
|
|
dnl
|
|
AC_DEFUN(BASH_CHECK_OFF_T_64,
|
|
[AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
],[
|
|
switch (0) case 0: case (sizeof (off_t) <= 4):;
|
|
], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
|
|
if test $bash_cv_off_t_64 = yes; then
|
|
AC_DEFINE(HAVE_OFF_T_64)
|
|
fi])
|
|
|
|
AC_DEFUN(BASH_STRUCT_TIMEVAL,
|
|
[AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
|
|
AC_CACHE_VAL(bash_cv_struct_timeval,
|
|
[
|
|
AC_EGREP_HEADER(struct timeval, sys/time.h,
|
|
bash_cv_struct_timeval=yes,
|
|
AC_EGREP_HEADER(struct timeval, time.h,
|
|
bash_cv_struct_timeval=yes,
|
|
bash_cv_struct_timeval=no))
|
|
])
|
|
AC_MSG_RESULT($bash_cv_struct_timeval)
|
|
if test $bash_cv_struct_timeval = yes; then
|
|
AC_DEFINE(HAVE_TIMEVAL)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(BASH_CHECK_RTSIGS,
|
|
[AC_MSG_CHECKING(for unusable real-time signals due to large values)
|
|
AC_CACHE_VAL(bash_cv_unusable_rtsigs,
|
|
[AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
|
|
#ifndef NSIG
|
|
# define NSIG 64
|
|
#endif
|
|
|
|
main ()
|
|
{
|
|
int n_sigs = 2 * NSIG;
|
|
#ifdef SIGRTMIN
|
|
int rtmin = SIGRTMIN;
|
|
#else
|
|
int rtmin = 0;
|
|
#endif
|
|
|
|
exit(rtmin < n_sigs);
|
|
}], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no,
|
|
[AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes)
|
|
bash_cv_unusable_rtsigs=yes]
|
|
)])
|
|
AC_MSG_RESULT($bash_cv_unusable_rtsigs)
|
|
if test $bash_cv_unusable_rtsigs = yes; then
|
|
AC_DEFINE(UNUSABLE_RT_SIGNALS)
|
|
fi
|
|
])
|