]> git.ipfire.org Git - thirdparty/bash.git/blob - aclocal.m4
Imported from ../bash-2.05.tar.gz.
[thirdparty/bash.git] / aclocal.m4
1 dnl
2 dnl Bash specific tests
3 dnl
4 dnl Some derived from PDKSH 5.1.3 autoconf tests
5 dnl
6 dnl
7 dnl Check if dup2() does not clear the close on exec flag
8 dnl
9 AC_DEFUN(BASH_DUP2_CLOEXEC_CHECK,
10 [AC_MSG_CHECKING(if dup2 fails to clear the close-on-exec flag)
11 AC_CACHE_VAL(bash_cv_dup2_broken,
12 [AC_TRY_RUN([
13 #include <sys/types.h>
14 #include <fcntl.h>
15 main()
16 {
17 int fd1, fd2, fl;
18 fd1 = open("/dev/null", 2);
19 if (fcntl(fd1, 2, 1) < 0)
20 exit(1);
21 fd2 = dup2(fd1, 1);
22 if (fd2 < 0)
23 exit(2);
24 fl = fcntl(fd2, 1, 0);
25 /* fl will be 1 if dup2 did not reset the close-on-exec flag. */
26 exit(fl != 1);
27 }
28 ], bash_cv_dup2_broken=yes, bash_cv_dup2_broken=no,
29 [AC_MSG_WARN(cannot check dup2 if cross compiling -- defaulting to no)
30 bash_cv_dup2_broken=no])
31 ])
32 AC_MSG_RESULT($bash_cv_dup2_broken)
33 if test $bash_cv_dup2_broken = yes; then
34 AC_DEFINE(DUP2_BROKEN)
35 fi
36 ])
37
38 dnl Check type of signal routines (posix, 4.2bsd, 4.1bsd or v7)
39 AC_DEFUN(BASH_SIGNAL_CHECK,
40 [AC_REQUIRE([AC_TYPE_SIGNAL])
41 AC_MSG_CHECKING(for type of signal functions)
42 AC_CACHE_VAL(bash_cv_signal_vintage,
43 [
44 AC_TRY_LINK([#include <signal.h>],[
45 sigset_t ss;
46 struct sigaction sa;
47 sigemptyset(&ss); sigsuspend(&ss);
48 sigaction(SIGINT, &sa, (struct sigaction *) 0);
49 sigprocmask(SIG_BLOCK, &ss, (sigset_t *) 0);
50 ], bash_cv_signal_vintage=posix,
51 [
52 AC_TRY_LINK([#include <signal.h>], [
53 int mask = sigmask(SIGINT);
54 sigsetmask(mask); sigblock(mask); sigpause(mask);
55 ], bash_cv_signal_vintage=4.2bsd,
56 [
57 AC_TRY_LINK([
58 #include <signal.h>
59 RETSIGTYPE foo() { }], [
60 int mask = sigmask(SIGINT);
61 sigset(SIGINT, foo); sigrelse(SIGINT);
62 sighold(SIGINT); sigpause(SIGINT);
63 ], bash_cv_signal_vintage=svr3, bash_cv_signal_vintage=v7
64 )]
65 )]
66 )
67 ])
68 AC_MSG_RESULT($bash_cv_signal_vintage)
69 if test "$bash_cv_signal_vintage" = posix; then
70 AC_DEFINE(HAVE_POSIX_SIGNALS)
71 elif test "$bash_cv_signal_vintage" = "4.2bsd"; then
72 AC_DEFINE(HAVE_BSD_SIGNALS)
73 elif test "$bash_cv_signal_vintage" = svr3; then
74 AC_DEFINE(HAVE_USG_SIGHOLD)
75 fi
76 ])
77
78 dnl Check if the pgrp of setpgrp() can't be the pid of a zombie process.
79 AC_DEFUN(BASH_PGRP_SYNC,
80 [AC_REQUIRE([AC_FUNC_GETPGRP])
81 AC_MSG_CHECKING(whether pgrps need synchronization)
82 AC_CACHE_VAL(bash_cv_pgrp_pipe,
83 [AC_TRY_RUN([
84 #ifdef HAVE_UNISTD_H
85 # include <unistd.h>
86 #endif
87 main()
88 {
89 # ifdef GETPGRP_VOID
90 # define getpgID() getpgrp()
91 # else
92 # define getpgID() getpgrp(0)
93 # define setpgid(x,y) setpgrp(x,y)
94 # endif
95 int pid1, pid2, fds[2];
96 int status;
97 char ok;
98
99 switch (pid1 = fork()) {
100 case -1:
101 exit(1);
102 case 0:
103 setpgid(0, getpid());
104 exit(0);
105 }
106 setpgid(pid1, pid1);
107
108 sleep(2); /* let first child die */
109
110 if (pipe(fds) < 0)
111 exit(2);
112
113 switch (pid2 = fork()) {
114 case -1:
115 exit(3);
116 case 0:
117 setpgid(0, pid1);
118 ok = getpgID() == pid1;
119 write(fds[1], &ok, 1);
120 exit(0);
121 }
122 setpgid(pid2, pid1);
123
124 close(fds[1]);
125 if (read(fds[0], &ok, 1) != 1)
126 exit(4);
127 wait(&status);
128 wait(&status);
129 exit(ok ? 0 : 5);
130 }
131 ], bash_cv_pgrp_pipe=no,bash_cv_pgrp_pipe=yes,
132 [AC_MSG_WARN(cannot check pgrp synchronization if cross compiling -- defaulting to no)
133 bash_cv_pgrp_pipe=no])
134 ])
135 AC_MSG_RESULT($bash_cv_pgrp_pipe)
136 if test $bash_cv_pgrp_pipe = yes; then
137 AC_DEFINE(PGRP_PIPE)
138 fi
139 ])
140
141 dnl
142 dnl check for typedef'd symbols in header files, but allow the caller to
143 dnl specify the include files to be checked in addition to the default
144 dnl
145 dnl BASH_CHECK_TYPE(TYPE, HEADERS, DEFAULT[, VALUE-IF-FOUND])
146 AC_DEFUN(BASH_CHECK_TYPE,
147 [AC_REQUIRE([AC_HEADER_STDC])dnl
148 AC_MSG_CHECKING(for $1)
149 AC_CACHE_VAL(bash_cv_type_$1,
150 [AC_EGREP_CPP($1, [#include <sys/types.h>
151 #if STDC_HEADERS
152 #include <stdlib.h>
153 #endif
154 $2
155 ], bash_cv_type_$1=yes, bash_cv_type_$1=no)])
156 AC_MSG_RESULT($bash_cv_type_$1)
157 ifelse($#, 4, [if test $bash_cv_type_$1 = yes; then
158 AC_DEFINE($4)
159 fi])
160 if test $bash_cv_type_$1 = no; then
161 AC_DEFINE($1, $3)
162 fi
163 ])
164
165 dnl
166 dnl Type of struct rlimit fields: some systems (OSF/1, NetBSD, RISC/os 5.0)
167 dnl have a rlim_t, others (4.4BSD based systems) use quad_t, others use
168 dnl long and still others use int (HP-UX 9.01, SunOS 4.1.3). To simplify
169 dnl matters, this just checks for rlim_t, quad_t, or long.
170 dnl
171 AC_DEFUN(BASH_RLIMIT_TYPE,
172 [AC_MSG_CHECKING(for size and type of struct rlimit fields)
173 AC_CACHE_VAL(bash_cv_type_rlimit,
174 [AC_TRY_COMPILE([#include <sys/types.h>
175 #include <sys/resource.h>],
176 [rlim_t xxx;], bash_cv_type_rlimit=rlim_t,[
177 AC_TRY_RUN([
178 #include <sys/types.h>
179 #include <sys/time.h>
180 #include <sys/resource.h>
181 main()
182 {
183 #ifdef HAVE_QUAD_T
184 struct rlimit rl;
185 if (sizeof(rl.rlim_cur) == sizeof(quad_t))
186 exit(0);
187 #endif
188 exit(1);
189 }], bash_cv_type_rlimit=quad_t, bash_cv_type_rlimit=long,
190 [AC_MSG_WARN(cannot check quad_t if cross compiling -- defaulting to long)
191 bash_cv_type_rlimit=long])])
192 ])
193 AC_MSG_RESULT($bash_cv_type_rlimit)
194 if test $bash_cv_type_rlimit = quad_t; then
195 AC_DEFINE(RLIMTYPE, quad_t)
196 elif test $bash_cv_type_rlimit = rlim_t; then
197 AC_DEFINE(RLIMTYPE, rlim_t)
198 fi
199 ])
200
201 dnl
202 dnl Check for sys_siglist[] or _sys_siglist[]
203 dnl
204 AC_DEFUN(BASH_DECL_UNDER_SYS_SIGLIST,
205 [AC_MSG_CHECKING([for _sys_siglist in signal.h or unistd.h])
206 AC_CACHE_VAL(bash_cv_decl_under_sys_siglist,
207 [AC_TRY_COMPILE([
208 #include <sys/types.h>
209 #include <signal.h>
210 #ifdef HAVE_UNISTD_H
211 #include <unistd.h>
212 #endif], [ char *msg = _sys_siglist[2]; ],
213 bash_cv_decl_under_sys_siglist=yes, bash_cv_decl_under_sys_siglist=no,
214 [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)])])dnl
215 AC_MSG_RESULT($bash_cv_decl_under_sys_siglist)
216 if test $bash_cv_decl_under_sys_siglist = yes; then
217 AC_DEFINE(UNDER_SYS_SIGLIST_DECLARED)
218 fi
219 ])
220
221 AC_DEFUN(BASH_UNDER_SYS_SIGLIST,
222 [AC_REQUIRE([BASH_DECL_UNDER_SYS_SIGLIST])
223 AC_MSG_CHECKING([for _sys_siglist in system C library])
224 AC_CACHE_VAL(bash_cv_under_sys_siglist,
225 [AC_TRY_RUN([
226 #include <sys/types.h>
227 #include <signal.h>
228 #ifdef HAVE_UNISTD_H
229 #include <unistd.h>
230 #endif
231 #ifndef UNDER_SYS_SIGLIST_DECLARED
232 extern char *_sys_siglist[];
233 #endif
234 main()
235 {
236 char *msg = (char *)_sys_siglist[2];
237 exit(msg == 0);
238 }],
239 bash_cv_under_sys_siglist=yes, bash_cv_under_sys_siglist=no,
240 [AC_MSG_WARN(cannot check for _sys_siglist[] if cross compiling -- defaulting to no)
241 bash_cv_under_sys_siglist=no])])
242 AC_MSG_RESULT($bash_cv_under_sys_siglist)
243 if test $bash_cv_under_sys_siglist = yes; then
244 AC_DEFINE(HAVE_UNDER_SYS_SIGLIST)
245 fi
246 ])
247
248 AC_DEFUN(BASH_SYS_SIGLIST,
249 [AC_REQUIRE([AC_DECL_SYS_SIGLIST])
250 AC_MSG_CHECKING([for sys_siglist in system C library])
251 AC_CACHE_VAL(bash_cv_sys_siglist,
252 [AC_TRY_RUN([
253 #include <sys/types.h>
254 #include <signal.h>
255 #ifdef HAVE_UNISTD_H
256 #include <unistd.h>
257 #endif
258 #ifndef SYS_SIGLIST_DECLARED
259 extern char *sys_siglist[];
260 #endif
261 main()
262 {
263 char *msg = sys_siglist[2];
264 exit(msg == 0);
265 }],
266 bash_cv_sys_siglist=yes, bash_cv_sys_siglist=no,
267 [AC_MSG_WARN(cannot check for sys_siglist if cross compiling -- defaulting to no)
268 bash_cv_sys_siglist=no])])
269 AC_MSG_RESULT($bash_cv_sys_siglist)
270 if test $bash_cv_sys_siglist = yes; then
271 AC_DEFINE(HAVE_SYS_SIGLIST)
272 fi
273 ])
274
275 dnl Check for sys_errlist[] and sys_nerr, check for declaration
276 AC_DEFUN(BASH_SYS_ERRLIST,
277 [AC_MSG_CHECKING([for sys_errlist and sys_nerr])
278 AC_CACHE_VAL(bash_cv_sys_errlist,
279 [AC_TRY_LINK([#include <errno.h>],
280 [extern char *sys_errlist[];
281 extern int sys_nerr;
282 char *msg = sys_errlist[sys_nerr - 1];],
283 bash_cv_sys_errlist=yes, bash_cv_sys_errlist=no)])dnl
284 AC_MSG_RESULT($bash_cv_sys_errlist)
285 if test $bash_cv_sys_errlist = yes; then
286 AC_DEFINE(HAVE_SYS_ERRLIST)
287 fi
288 ])
289
290 dnl Check to see if opendir will open non-directories (not a nice thing)
291 AC_DEFUN(BASH_FUNC_OPENDIR_CHECK,
292 [AC_REQUIRE([AC_HEADER_DIRENT])dnl
293 AC_MSG_CHECKING(if opendir() opens non-directories)
294 AC_CACHE_VAL(bash_cv_opendir_not_robust,
295 [AC_TRY_RUN([
296 #include <stdio.h>
297 #include <sys/types.h>
298 #include <fcntl.h>
299 #ifdef HAVE_UNISTD_H
300 # include <unistd.h>
301 #endif /* HAVE_UNISTD_H */
302 #if defined(HAVE_DIRENT_H)
303 # include <dirent.h>
304 #else
305 # define dirent direct
306 # ifdef HAVE_SYS_NDIR_H
307 # include <sys/ndir.h>
308 # endif /* SYSNDIR */
309 # ifdef HAVE_SYS_DIR_H
310 # include <sys/dir.h>
311 # endif /* SYSDIR */
312 # ifdef HAVE_NDIR_H
313 # include <ndir.h>
314 # endif
315 #endif /* HAVE_DIRENT_H */
316 main()
317 {
318 DIR *dir;
319 int fd, err;
320 err = mkdir("/tmp/bash-aclocal", 0700);
321 if (err < 0) {
322 perror("mkdir");
323 exit(1);
324 }
325 unlink("/tmp/bash-aclocal/not_a_directory");
326 fd = open("/tmp/bash-aclocal/not_a_directory", O_WRONLY|O_CREAT|O_EXCL, 0666);
327 write(fd, "\n", 1);
328 close(fd);
329 dir = opendir("/tmp/bash-aclocal/not_a_directory");
330 unlink("/tmp/bash-aclocal/not_a_directory");
331 rmdir("/tmp/bash-aclocal");
332 exit (dir == 0);
333 }], bash_cv_opendir_not_robust=yes,bash_cv_opendir_not_robust=no,
334 [AC_MSG_WARN(cannot check opendir if cross compiling -- defaulting to no)
335 bash_cv_opendir_not_robust=no]
336 )])
337 AC_MSG_RESULT($bash_cv_opendir_not_robust)
338 if test $bash_cv_opendir_not_robust = yes; then
339 AC_DEFINE(OPENDIR_NOT_ROBUST)
340 fi
341 ])
342
343 dnl
344 AC_DEFUN(BASH_TYPE_SIGHANDLER,
345 [AC_MSG_CHECKING([whether signal handlers are of type void])
346 AC_CACHE_VAL(bash_cv_void_sighandler,
347 [AC_TRY_COMPILE([#include <sys/types.h>
348 #include <signal.h>
349 #ifdef signal
350 #undef signal
351 #endif
352 #ifdef __cplusplus
353 extern "C"
354 #endif
355 void (*signal ()) ();],
356 [int i;], bash_cv_void_sighandler=yes, bash_cv_void_sighandler=no)])dnl
357 AC_MSG_RESULT($bash_cv_void_sighandler)
358 if test $bash_cv_void_sighandler = yes; then
359 AC_DEFINE(VOID_SIGHANDLER)
360 fi
361 ])
362
363 dnl
364 dnl A signed 16-bit integer quantity
365 dnl
366 AC_DEFUN(BASH_TYPE_BITS16_T,
367 [
368 if test "$ac_cv_sizeof_short" = 2; then
369 AC_CHECK_TYPE(bits16_t, short)
370 elif test "$ac_cv_sizeof_char" = 2; then
371 AC_CHECK_TYPE(bits16_t, char)
372 else
373 AC_CHECK_TYPE(bits16_t, short)
374 fi
375 ])
376
377 dnl
378 dnl An unsigned 16-bit integer quantity
379 dnl
380 AC_DEFUN(BASH_TYPE_U_BITS16_T,
381 [
382 if test "$ac_cv_sizeof_short" = 2; then
383 AC_CHECK_TYPE(u_bits16_t, unsigned short)
384 elif test "$ac_cv_sizeof_char" = 2; then
385 AC_CHECK_TYPE(u_bits16_t, unsigned char)
386 else
387 AC_CHECK_TYPE(u_bits16_t, unsigned short)
388 fi
389 ])
390
391 dnl
392 dnl A signed 32-bit integer quantity
393 dnl
394 AC_DEFUN(BASH_TYPE_BITS32_T,
395 [
396 if test "$ac_cv_sizeof_int" = 4; then
397 AC_CHECK_TYPE(bits32_t, int)
398 elif test "$ac_cv_sizeof_long" = 4; then
399 AC_CHECK_TYPE(bits32_t, long)
400 else
401 AC_CHECK_TYPE(bits32_t, int)
402 fi
403 ])
404
405 dnl
406 dnl An unsigned 32-bit integer quantity
407 dnl
408 AC_DEFUN(BASH_TYPE_U_BITS32_T,
409 [
410 if test "$ac_cv_sizeof_int" = 4; then
411 AC_CHECK_TYPE(u_bits32_t, unsigned int)
412 elif test "$ac_cv_sizeof_long" = 4; then
413 AC_CHECK_TYPE(u_bits32_t, unsigned long)
414 else
415 AC_CHECK_TYPE(u_bits32_t, unsigned int)
416 fi
417 ])
418
419 AC_DEFUN(BASH_TYPE_PTRDIFF_T,
420 [
421 if test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_char_p"; then
422 AC_CHECK_TYPE(ptrdiff_t, int)
423 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_char_p"; then
424 AC_CHECK_TYPE(ptrdiff_t, long)
425 else
426 AC_CHECK_TYPE(ptrdiff_t, int)
427 fi
428 ])
429
430 dnl
431 dnl A signed 64-bit quantity
432 dnl
433 AC_DEFUN(BASH_TYPE_BITS64_T,
434 [
435 if test "$ac_sv_sizeof_char_p" = 8; then
436 AC_CHECK_TYPE(bits64_t, char *)
437 elif test "$ac_cv_sizeof_double" = 8; then
438 AC_CHECK_TYPE(bits64_t, double)
439 elif test "$ac_cv_sizeof_long" = 8; then
440 AC_CHECK_TYPE(bits64_t, long)
441 else
442 AC_CHECK_TYPE(bits64_t, double)
443 fi
444 ])
445
446 AC_DEFUN(BASH_FUNC_STRSIGNAL,
447 [AC_MSG_CHECKING([for the existence of strsignal])
448 AC_CACHE_VAL(bash_cv_have_strsignal,
449 [AC_TRY_LINK([#include <sys/types.h>
450 #include <signal.h>],
451 [char *s = (char *)strsignal(2);],
452 bash_cv_have_strsignal=yes, bash_cv_have_strsignal=no)])
453 AC_MSG_RESULT($bash_cv_have_strsignal)
454 if test $bash_cv_have_strsignal = yes; then
455 AC_DEFINE(HAVE_STRSIGNAL)
456 fi
457 ])
458
459 AC_DEFUN(BASH_FUNC_LSTAT,
460 [dnl Cannot use AC_CHECK_FUNCS(lstat) because Linux defines lstat() as an
461 dnl inline function in <sys/stat.h>.
462 AC_CACHE_CHECK([for lstat], bash_cv_func_lstat,
463 [AC_TRY_LINK([
464 #include <sys/types.h>
465 #include <sys/stat.h>
466 ],[ lstat(".",(struct stat *)0); ],
467 bash_cv_func_lstat=yes, bash_cv_func_lstat=no)])
468 if test $bash_cv_func_lstat = yes; then
469 AC_DEFINE(HAVE_LSTAT)
470 fi
471 ])
472
473 AC_DEFUN(BASH_FUNC_INET_ATON,
474 [
475 AC_CACHE_CHECK([for inet_aton], bash_cv_func_inet_aton,
476 [AC_TRY_LINK([
477 #include <sys/types.h>
478 #include <netinet/in.h>
479 #include <arpa/inet.h>
480 struct in_addr ap;], [ inet_aton("127.0.0.1", &ap); ],
481 bash_cv_func_inet_aton=yes, bash_cv_func_inet_aton=no)])
482 if test $bash_cv_func_inet_aton = yes; then
483 AC_DEFINE(HAVE_INET_ATON)
484 fi
485 ])
486
487 AC_DEFUN(BASH_STRUCT_TERMIOS_LDISC,
488 [AC_MSG_CHECKING([for a c_line member of struct termios])
489 AC_CACHE_VAL(bash_cv_termios_ldisc,
490 [AC_TRY_COMPILE([#include <sys/types.h>
491 #include <termios.h>],[struct termios t; int i; i = t.c_line;],
492 bash_cv_termios_ldisc=yes, bash_cv_termios_ldisc=no)])dnl
493 AC_MSG_RESULT($bash_cv_termios_ldisc)
494 if test $bash_cv_termios_ldisc = yes; then
495 AC_DEFINE(TERMIOS_LDISC)
496 fi
497 ])
498
499 AC_DEFUN(BASH_STRUCT_TERMIO_LDISC,
500 [AC_MSG_CHECKING([for a c_line member of struct termio])
501 AC_CACHE_VAL(bash_cv_termio_ldisc,
502 [AC_TRY_COMPILE([#include <sys/types.h>
503 #include <termio.h>],[struct termio t; int i; i = t.c_line;],
504 bash_cv_termio_ldisc=yes, bash_cv_termio_ldisc=no)])dnl
505 AC_MSG_RESULT($bash_cv_termio_ldisc)
506 if test $bash_cv_termio_ldisc = yes; then
507 AC_DEFINE(TERMIO_LDISC)
508 fi
509 ])
510
511 AC_DEFUN(BASH_FUNC_GETENV,
512 [AC_MSG_CHECKING(to see if getenv can be redefined)
513 AC_CACHE_VAL(bash_cv_getenv_redef,
514 [AC_TRY_RUN([
515 #ifdef HAVE_UNISTD_H
516 # include <unistd.h>
517 #endif
518 #ifndef __STDC__
519 # ifndef const
520 # define const
521 # endif
522 #endif
523 char *
524 getenv (name)
525 #if defined (__linux__) || defined (__bsdi__) || defined (convex)
526 const char *name;
527 #else
528 char const *name;
529 #endif /* !__linux__ && !__bsdi__ && !convex */
530 {
531 return "42";
532 }
533 main()
534 {
535 char *s;
536 /* The next allows this program to run, but does not allow bash to link
537 when it redefines getenv. I'm not really interested in figuring out
538 why not. */
539 #if defined (NeXT)
540 exit(1);
541 #endif
542 s = getenv("ABCDE");
543 exit(s == 0); /* force optimizer to leave getenv in */
544 }
545 ], bash_cv_getenv_redef=yes, bash_cv_getenv_redef=no,
546 [AC_MSG_WARN(cannot check getenv redefinition if cross compiling -- defaulting to yes)
547 bash_cv_getenv_redef=yes]
548 )])
549 AC_MSG_RESULT($bash_cv_getenv_redef)
550 if test $bash_cv_getenv_redef = yes; then
551 AC_DEFINE(CAN_REDEFINE_GETENV)
552 fi
553 ])
554
555 AC_DEFUN(BASH_FUNC_PRINTF,
556 [AC_MSG_CHECKING(for declaration of printf in <stdio.h>)
557 AC_CACHE_VAL(bash_cv_printf_declared,
558 [AC_TRY_RUN([
559 #include <stdio.h>
560 #ifdef __STDC__
561 typedef int (*_bashfunc)(const char *, ...);
562 #else
563 typedef int (*_bashfunc)();
564 #endif
565 main()
566 {
567 _bashfunc pf;
568 pf = (_bashfunc) printf;
569 exit(pf == 0);
570 }
571 ], bash_cv_printf_declared=yes, bash_cv_printf_declared=no,
572 [AC_MSG_WARN(cannot check printf declaration if cross compiling -- defaulting to yes)
573 bash_cv_printf_declared=yes]
574 )])
575 AC_MSG_RESULT($bash_cv_printf_declared)
576 if test $bash_cv_printf_declared = yes; then
577 AC_DEFINE(PRINTF_DECLARED)
578 fi
579 ])
580
581 AC_DEFUN(BASH_FUNC_ULIMIT_MAXFDS,
582 [AC_MSG_CHECKING(whether ulimit can substitute for getdtablesize)
583 AC_CACHE_VAL(bash_cv_ulimit_maxfds,
584 [AC_TRY_RUN([
585 main()
586 {
587 long maxfds = ulimit(4, 0L);
588 exit (maxfds == -1L);
589 }
590 ], bash_cv_ulimit_maxfds=yes, bash_cv_ulimit_maxfds=no,
591 [AC_MSG_WARN(cannot check ulimit if cross compiling -- defaulting to no)
592 bash_cv_ulimit_maxfds=no]
593 )])
594 AC_MSG_RESULT($bash_cv_ulimit_maxfds)
595 if test $bash_cv_ulimit_maxfds = yes; then
596 AC_DEFINE(ULIMIT_MAXFDS)
597 fi
598 ])
599
600 AC_DEFUN(BASH_CHECK_LIB_TERMCAP,
601 [
602 if test "X$bash_cv_termcap_lib" = "X"; then
603 _bash_needmsg=yes
604 else
605 AC_MSG_CHECKING(which library has the termcap functions)
606 _bash_needmsg=
607 fi
608 AC_CACHE_VAL(bash_cv_termcap_lib,
609 [AC_CHECK_LIB(termcap, tgetent, bash_cv_termcap_lib=libtermcap,
610 [AC_CHECK_LIB(curses, tgetent, bash_cv_termcap_lib=libcurses,
611 [AC_CHECK_LIB(ncurses, tgetent, bash_cv_termcap_lib=libncurses,
612 bash_cv_termcap_lib=gnutermcap)])])])
613 if test "X$_bash_needmsg" = "Xyes"; then
614 AC_MSG_CHECKING(which library has the termcap functions)
615 fi
616 AC_MSG_RESULT(using $bash_cv_termcap_lib)
617 if test $bash_cv_termcap_lib = gnutermcap && test -z "$prefer_curses"; then
618 LDFLAGS="$LDFLAGS -L./lib/termcap"
619 TERMCAP_LIB="./lib/termcap/libtermcap.a"
620 TERMCAP_DEP="./lib/termcap/libtermcap.a"
621 elif test $bash_cv_termcap_lib = libtermcap && test -z "$prefer_curses"; then
622 TERMCAP_LIB=-ltermcap
623 TERMCAP_DEP=
624 elif test $bash_cv_termcap_lib = libncurses; then
625 TERMCAP_LIB=-lncurses
626 TERMCAP_DEP=
627 else
628 TERMCAP_LIB=-lcurses
629 TERMCAP_DEP=
630 fi
631 ])
632
633 AC_DEFUN(BASH_FUNC_GETCWD,
634 [AC_MSG_CHECKING([if getcwd() calls popen()])
635 AC_CACHE_VAL(bash_cv_getcwd_calls_popen,
636 [AC_TRY_RUN([
637 #include <stdio.h>
638 #ifdef HAVE_UNISTD_H
639 #include <unistd.h>
640 #endif
641
642 #ifndef __STDC__
643 #ifndef const
644 #define const
645 #endif
646 #endif
647
648 int popen_called;
649
650 FILE *
651 popen(command, type)
652 const char *command;
653 const char *type;
654 {
655 popen_called = 1;
656 return (FILE *)NULL;
657 }
658
659 FILE *_popen(command, type)
660 const char *command;
661 const char *type;
662 {
663 return (popen (command, type));
664 }
665
666 int
667 pclose(stream)
668 FILE *stream;
669 {
670 return 0;
671 }
672
673 int
674 _pclose(stream)
675 FILE *stream;
676 {
677 return 0;
678 }
679
680 main()
681 {
682 char lbuf[32];
683 popen_called = 0;
684 getcwd(lbuf, 32);
685 exit (popen_called);
686 }
687 ], bash_cv_getcwd_calls_popen=no, bash_cv_getcwd_calls_popen=yes,
688 [AC_MSG_WARN(cannot check whether getcwd calls popen if cross compiling -- defaulting to no)
689 bash_cv_getcwd_calls_popen=no]
690 )])
691 AC_MSG_RESULT($bash_cv_getcwd_calls_popen)
692 if test $bash_cv_getcwd_calls_popen = yes; then
693 AC_DEFINE(GETCWD_BROKEN)
694 fi
695 ])
696
697 AC_DEFUN(BASH_STRUCT_DIRENT_D_INO,
698 [AC_REQUIRE([AC_HEADER_DIRENT])
699 AC_MSG_CHECKING(if struct dirent has a d_ino member)
700 AC_CACHE_VAL(bash_cv_dirent_has_dino,
701 [AC_TRY_COMPILE([
702 #include <stdio.h>
703 #include <sys/types.h>
704 #ifdef HAVE_UNISTD_H
705 # include <unistd.h>
706 #endif /* HAVE_UNISTD_H */
707 #if defined(HAVE_DIRENT_H)
708 # include <dirent.h>
709 #else
710 # define dirent direct
711 # ifdef HAVE_SYS_NDIR_H
712 # include <sys/ndir.h>
713 # endif /* SYSNDIR */
714 # ifdef HAVE_SYS_DIR_H
715 # include <sys/dir.h>
716 # endif /* SYSDIR */
717 # ifdef HAVE_NDIR_H
718 # include <ndir.h>
719 # endif
720 #endif /* HAVE_DIRENT_H */
721 ],[
722 struct dirent d; int z; z = d.d_ino;
723 ], bash_cv_dirent_has_dino=yes, bash_cv_dirent_has_dino=no)])
724 AC_MSG_RESULT($bash_cv_dirent_has_dino)
725 if test $bash_cv_dirent_has_dino = yes; then
726 AC_DEFINE(STRUCT_DIRENT_HAS_D_INO)
727 fi
728 ])
729
730 AC_DEFUN(BASH_STRUCT_DIRENT_D_FILENO,
731 [AC_REQUIRE([AC_HEADER_DIRENT])
732 AC_MSG_CHECKING(if struct dirent has a d_fileno member)
733 AC_CACHE_VAL(bash_cv_dirent_has_d_fileno,
734 [AC_TRY_COMPILE([
735 #include <stdio.h>
736 #include <sys/types.h>
737 #ifdef HAVE_UNISTD_H
738 # include <unistd.h>
739 #endif /* HAVE_UNISTD_H */
740 #if defined(HAVE_DIRENT_H)
741 # include <dirent.h>
742 #else
743 # define dirent direct
744 # ifdef HAVE_SYS_NDIR_H
745 # include <sys/ndir.h>
746 # endif /* SYSNDIR */
747 # ifdef HAVE_SYS_DIR_H
748 # include <sys/dir.h>
749 # endif /* SYSDIR */
750 # ifdef HAVE_NDIR_H
751 # include <ndir.h>
752 # endif
753 #endif /* HAVE_DIRENT_H */
754 ],[
755 struct dirent d; int z; z = d.d_fileno;
756 ], bash_cv_dirent_has_d_fileno=yes, bash_cv_dirent_has_d_fileno=no)])
757 AC_MSG_RESULT($bash_cv_dirent_has_d_fileno)
758 if test $bash_cv_dirent_has_d_fileno = yes; then
759 AC_DEFINE(STRUCT_DIRENT_HAS_D_FILENO)
760 fi
761 ])
762
763 AC_DEFUN(BASH_REINSTALL_SIGHANDLERS,
764 [AC_REQUIRE([AC_TYPE_SIGNAL])
765 AC_REQUIRE([BASH_SIGNAL_CHECK])
766 AC_MSG_CHECKING([if signal handlers must be reinstalled when invoked])
767 AC_CACHE_VAL(bash_cv_must_reinstall_sighandlers,
768 [AC_TRY_RUN([
769 #include <signal.h>
770 #ifdef HAVE_UNISTD_H
771 #include <unistd.h>
772 #endif
773
774 typedef RETSIGTYPE sigfunc();
775
776 int nsigint;
777
778 #ifdef HAVE_POSIX_SIGNALS
779 sigfunc *
780 set_signal_handler(sig, handler)
781 int sig;
782 sigfunc *handler;
783 {
784 struct sigaction act, oact;
785 act.sa_handler = handler;
786 act.sa_flags = 0;
787 sigemptyset (&act.sa_mask);
788 sigemptyset (&oact.sa_mask);
789 sigaction (sig, &act, &oact);
790 return (oact.sa_handler);
791 }
792 #else
793 #define set_signal_handler(s, h) signal(s, h)
794 #endif
795
796 RETSIGTYPE
797 sigint(s)
798 int s;
799 {
800 nsigint++;
801 }
802
803 main()
804 {
805 nsigint = 0;
806 set_signal_handler(SIGINT, sigint);
807 kill((int)getpid(), SIGINT);
808 kill((int)getpid(), SIGINT);
809 exit(nsigint != 2);
810 }
811 ], bash_cv_must_reinstall_sighandlers=no, bash_cv_must_reinstall_sighandlers=yes,
812 [AC_MSG_WARN(cannot check signal handling if cross compiling -- defaulting to no)
813 bash_cv_must_reinstall_sighandlers=no]
814 )])
815 AC_MSG_RESULT($bash_cv_must_reinstall_sighandlers)
816 if test $bash_cv_must_reinstall_sighandlers = yes; then
817 AC_DEFINE(MUST_REINSTALL_SIGHANDLERS)
818 fi
819 ])
820
821 AC_DEFUN(BASH_FUNC_SBRK_DECLARED,
822 [AC_MSG_CHECKING(for declaration of sbrk in <unistd.h>)
823 AC_CACHE_VAL(bash_cv_sbrk_declared,
824 [AC_EGREP_HEADER(sbrk, unistd.h,
825 bash_cv_sbrk_declared=yes, bash_cv_sbrk_declared=no)])
826 AC_MSG_RESULT($bash_cv_sbrk_declared)
827 if test $bash_cv_sbrk_declared = yes; then
828 AC_DEFINE(SBRK_DECLARED)
829 fi
830 ])
831
832 dnl check that some necessary job control definitions are present
833 AC_DEFUN(BASH_JOB_CONTROL_MISSING,
834 [AC_REQUIRE([BASH_SIGNAL_CHECK])
835 AC_MSG_CHECKING(for presence of necessary job control definitions)
836 AC_CACHE_VAL(bash_cv_job_control_missing,
837 [AC_TRY_RUN([
838 #include <sys/types.h>
839 #ifdef HAVE_SYS_WAIT_H
840 #include <sys/wait.h>
841 #endif
842 #ifdef HAVE_UNISTD_H
843 #include <unistd.h>
844 #endif
845 #include <signal.h>
846
847 /* Add more tests in here as appropriate. */
848 main()
849 {
850 /* signal type */
851 #if !defined (HAVE_POSIX_SIGNALS) && !defined (HAVE_BSD_SIGNALS)
852 exit(1);
853 #endif
854
855 /* signals and tty control. */
856 #if !defined (SIGTSTP) || !defined (SIGSTOP) || !defined (SIGCONT)
857 exit (1);
858 #endif
859
860 /* process control */
861 #if !defined (WNOHANG) || !defined (WUNTRACED)
862 exit(1);
863 #endif
864
865 /* Posix systems have tcgetpgrp and waitpid. */
866 #if defined (_POSIX_VERSION) && !defined (HAVE_TCGETPGRP)
867 exit(1);
868 #endif
869
870 #if defined (_POSIX_VERSION) && !defined (HAVE_WAITPID)
871 exit(1);
872 #endif
873
874 /* Other systems have TIOCSPGRP/TIOCGPRGP and wait3. */
875 #if !defined (_POSIX_VERSION) && !defined (HAVE_WAIT3)
876 exit(1);
877 #endif
878
879 exit(0);
880 }], bash_cv_job_control_missing=present, bash_cv_job_control_missing=missing,
881 [AC_MSG_WARN(cannot check job control if cross-compiling -- defaulting to missing)
882 bash_cv_job_control_missing=missing]
883 )])
884 AC_MSG_RESULT($bash_cv_job_control_missing)
885 if test $bash_cv_job_control_missing = missing; then
886 AC_DEFINE(JOB_CONTROL_MISSING)
887 fi
888 ])
889
890 dnl check whether named pipes are present
891 dnl this requires a previous check for mkfifo, but that is awkward to specify
892 AC_DEFUN(BASH_SYS_NAMED_PIPES,
893 [AC_MSG_CHECKING(for presence of named pipes)
894 AC_CACHE_VAL(bash_cv_sys_named_pipes,
895 [AC_TRY_RUN([
896 #include <sys/types.h>
897 #include <sys/stat.h>
898 #ifdef HAVE_UNISTD_H
899 #include <unistd.h>
900 #endif
901
902 /* Add more tests in here as appropriate. */
903 main()
904 {
905 int fd, err;
906
907 #if defined (HAVE_MKFIFO)
908 exit (0);
909 #endif
910
911 #if !defined (S_IFIFO) && (defined (_POSIX_VERSION) && !defined (S_ISFIFO))
912 exit (1);
913 #endif
914
915 #if defined (NeXT)
916 exit (1);
917 #endif
918 err = mkdir("/tmp/bash-aclocal", 0700);
919 if (err < 0) {
920 perror ("mkdir");
921 exit(1);
922 }
923 fd = mknod ("/tmp/bash-aclocal/sh-np-autoconf", 0666 | S_IFIFO, 0);
924 if (fd == -1) {
925 rmdir ("/tmp/bash-aclocal");
926 exit (1);
927 }
928 close(fd);
929 unlink ("/tmp/bash-aclocal/sh-np-autoconf");
930 rmdir ("/tmp/bash-aclocal");
931 exit(0);
932 }], bash_cv_sys_named_pipes=present, bash_cv_sys_named_pipes=missing,
933 [AC_MSG_WARN(cannot check for named pipes if cross-compiling -- defaulting to missing)
934 bash_cv_sys_named_pipes=missing]
935 )])
936 AC_MSG_RESULT($bash_cv_sys_named_pipes)
937 if test $bash_cv_sys_named_pipes = missing; then
938 AC_DEFINE(NAMED_PIPES_MISSING)
939 fi
940 ])
941
942 AC_DEFUN(BASH_FUNC_POSIX_SETJMP,
943 [AC_REQUIRE([BASH_SIGNAL_CHECK])
944 AC_MSG_CHECKING(for presence of POSIX-style sigsetjmp/siglongjmp)
945 AC_CACHE_VAL(bash_cv_func_sigsetjmp,
946 [AC_TRY_RUN([
947 #ifdef HAVE_UNISTD_H
948 #include <unistd.h>
949 #endif
950 #include <sys/types.h>
951 #include <signal.h>
952 #include <setjmp.h>
953
954 main()
955 {
956 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
957 exit (1);
958 #else
959
960 int code;
961 sigset_t set, oset;
962 sigjmp_buf xx;
963
964 /* get the mask */
965 sigemptyset(&set);
966 sigemptyset(&oset);
967 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &set);
968 sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
969
970 /* save it */
971 code = sigsetjmp(xx, 1);
972 if (code)
973 exit(0); /* could get sigmask and compare to oset here. */
974
975 /* change it */
976 sigaddset(&set, SIGINT);
977 sigprocmask(SIG_BLOCK, &set, (sigset_t *)NULL);
978
979 /* and siglongjmp */
980 siglongjmp(xx, 10);
981 exit(1);
982 #endif
983 }], bash_cv_func_sigsetjmp=present, bash_cv_func_sigsetjmp=missing,
984 [AC_MSG_WARN(cannot check for sigsetjmp/siglongjmp if cross-compiling -- defaulting to missing)
985 bash_cv_func_sigsetjmp=missing]
986 )])
987 AC_MSG_RESULT($bash_cv_func_sigsetjmp)
988 if test $bash_cv_func_sigsetjmp = present; then
989 AC_DEFINE(HAVE_POSIX_SIGSETJMP)
990 fi
991 ])
992
993 AC_DEFUN(BASH_HAVE_TIOCGWINSZ,
994 [AC_MSG_CHECKING(for TIOCGWINSZ in sys/ioctl.h)
995 AC_CACHE_VAL(bash_cv_tiocgwinsz_in_ioctl,
996 [AC_TRY_COMPILE([#include <sys/types.h>
997 #include <sys/ioctl.h>], [int x = TIOCGWINSZ;],
998 bash_cv_tiocgwinsz_in_ioctl=yes,bash_cv_tiocgwinsz_in_ioctl=no)])
999 AC_MSG_RESULT($bash_cv_tiocgwinsz_in_ioctl)
1000 if test $bash_cv_tiocgwinsz_in_ioctl = yes; then
1001 AC_DEFINE(GWINSZ_IN_SYS_IOCTL)
1002 fi
1003 ])
1004
1005 AC_DEFUN(BASH_STRUCT_WINSIZE,
1006 [AC_MSG_CHECKING(for struct winsize in sys/ioctl.h and termios.h)
1007 AC_CACHE_VAL(bash_cv_struct_winsize_header,
1008 [AC_TRY_COMPILE([#include <sys/types.h>
1009 #include <sys/ioctl.h>], [struct winsize x;],
1010 bash_cv_struct_winsize_header=ioctl_h,
1011 [AC_TRY_COMPILE([#include <sys/types.h>
1012 #include <termios.h>], [struct winsize x;],
1013 bash_cv_struct_winsize_header=termios_h, bash_cv_struct_winsize_header=other)
1014 ])])
1015 if test $bash_cv_struct_winsize_header = ioctl_h; then
1016 AC_MSG_RESULT(sys/ioctl.h)
1017 AC_DEFINE(STRUCT_WINSIZE_IN_SYS_IOCTL)
1018 elif test $bash_cv_struct_winsize_header = termios_h; then
1019 AC_MSG_RESULT(termios.h)
1020 AC_DEFINE(STRUCT_WINSIZE_IN_TERMIOS)
1021 else
1022 AC_MSG_RESULT(not found)
1023 fi
1024 ])
1025
1026 AC_DEFUN(BASH_HAVE_TIOCSTAT,
1027 [AC_MSG_CHECKING(for TIOCSTAT in sys/ioctl.h)
1028 AC_CACHE_VAL(bash_cv_tiocstat_in_ioctl,
1029 [AC_TRY_COMPILE([#include <sys/types.h>
1030 #include <sys/ioctl.h>], [int x = TIOCSTAT;],
1031 bash_cv_tiocstat_in_ioctl=yes,bash_cv_tiocstat_in_ioctl=no)])
1032 AC_MSG_RESULT($bash_cv_tiocstat_in_ioctl)
1033 if test $bash_cv_tiocstat_in_ioctl = yes; then
1034 AC_DEFINE(TIOCSTAT_IN_SYS_IOCTL)
1035 fi
1036 ])
1037
1038 AC_DEFUN(BASH_HAVE_FIONREAD,
1039 [AC_MSG_CHECKING(for FIONREAD in sys/ioctl.h)
1040 AC_CACHE_VAL(bash_cv_fionread_in_ioctl,
1041 [AC_TRY_COMPILE([#include <sys/types.h>
1042 #include <sys/ioctl.h>], [int x = FIONREAD;],
1043 bash_cv_fionread_in_ioctl=yes,bash_cv_fionread_in_ioctl=no)])
1044 AC_MSG_RESULT($bash_cv_fionread_in_ioctl)
1045 if test $bash_cv_fionread_in_ioctl = yes; then
1046 AC_DEFINE(FIONREAD_IN_SYS_IOCTL)
1047 fi
1048 ])
1049
1050 dnl
1051 dnl See if speed_t is declared in <sys/types.h>. Some versions of linux
1052 dnl require a definition of speed_t each time <termcap.h> is included,
1053 dnl but you can only get speed_t if you include <termios.h> (on some
1054 dnl versions) or <sys/types.h> (on others).
1055 dnl
1056 AC_DEFUN(BASH_MISC_SPEED_T,
1057 [AC_MSG_CHECKING(for speed_t in sys/types.h)
1058 AC_CACHE_VAL(bash_cv_speed_t_in_sys_types,
1059 [AC_TRY_COMPILE([#include <sys/types.h>], [speed_t x;],
1060 bash_cv_speed_t_in_sys_types=yes,bash_cv_speed_t_in_sys_types=no)])
1061 AC_MSG_RESULT($bash_cv_speed_t_in_sys_types)
1062 if test $bash_cv_speed_t_in_sys_types = yes; then
1063 AC_DEFINE(SPEED_T_IN_SYS_TYPES)
1064 fi
1065 ])
1066
1067 AC_DEFUN(BASH_CHECK_GETPW_FUNCS,
1068 [AC_MSG_CHECKING(whether getpw functions are declared in pwd.h)
1069 AC_CACHE_VAL(bash_cv_getpw_declared,
1070 [AC_EGREP_CPP(getpwuid,
1071 [
1072 #include <sys/types.h>
1073 #ifdef HAVE_UNISTD_H
1074 # include <unistd.h>
1075 #endif
1076 #include <pwd.h>
1077 ],
1078 bash_cv_getpw_declared=yes,bash_cv_getpw_declared=no)])
1079 AC_MSG_RESULT($bash_cv_getpw_declared)
1080 if test $bash_cv_getpw_declared = yes; then
1081 AC_DEFINE(HAVE_GETPW_DECLS)
1082 fi
1083 ])
1084
1085 AC_DEFUN(BASH_CHECK_DEV_FD,
1086 [AC_MSG_CHECKING(whether /dev/fd is available)
1087 AC_CACHE_VAL(bash_cv_dev_fd,
1088 [if test -d /dev/fd && test -r /dev/fd/0; then
1089 bash_cv_dev_fd=standard
1090 elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
1091 bash_cv_dev_fd=whacky
1092 else
1093 bash_cv_dev_fd=absent
1094 fi
1095 ])
1096 AC_MSG_RESULT($bash_cv_dev_fd)
1097 if test $bash_cv_dev_fd = "standard"; then
1098 AC_DEFINE(HAVE_DEV_FD)
1099 AC_DEFINE(DEV_FD_PREFIX, "/dev/fd/")
1100 elif test $bash_cv_dev_fd = "whacky"; then
1101 AC_DEFINE(HAVE_DEV_FD)
1102 AC_DEFINE(DEV_FD_PREFIX, "/proc/self/fd/")
1103 fi
1104 ])
1105
1106 AC_DEFUN(BASH_CHECK_DEV_STDIN,
1107 [AC_MSG_CHECKING(whether /dev/stdin stdout stderr are available)
1108 AC_CACHE_VAL(bash_cv_dev_stdin,
1109 [if test -d /dev/fd && test -r /dev/stdin; then
1110 bash_cv_dev_stdin=present
1111 elif test -d /proc/self/fd && test -r /dev/stdin; then
1112 bash_cv_dev_stdin=present
1113 else
1114 bash_cv_dev_stdin=absent
1115 fi
1116 ])
1117 AC_MSG_RESULT($bash_cv_dev_stdin)
1118 if test $bash_cv_dev_stdin = "present"; then
1119 AC_DEFINE(HAVE_DEV_STDIN)
1120 fi
1121 ])
1122
1123 dnl
1124 dnl Check for the presence of getpeername in libsocket.
1125 dnl If libsocket is present, check for libnsl and add it to LIBS if
1126 dnl it's there, since most systems with libsocket require linking
1127 dnl with libnsl as well. This should only be called if getpeername
1128 dnl was not found in libc.
1129 dnl
1130 dnl NOTE: IF WE FIND GETPEERNAME, WE ASSUME THAT WE HAVE BIND/CONNECT
1131 dnl AS WELL
1132 dnl
1133 AC_DEFUN(BASH_CHECK_SOCKLIB,
1134 [
1135 if test "X$bash_cv_have_socklib" = "X"; then
1136 _bash_needmsg=
1137 else
1138 AC_MSG_CHECKING(for socket library)
1139 _bash_needmsg=yes
1140 fi
1141 AC_CACHE_VAL(bash_cv_have_socklib,
1142 [AC_CHECK_LIB(socket, getpeername,
1143 bash_cv_have_socklib=yes, bash_cv_have_socklib=no, -lnsl)])
1144 if test "X$_bash_needmsg" = Xyes; then
1145 AC_MSG_RESULT($bash_cv_have_socklib)
1146 _bash_needmsg=
1147 fi
1148 if test $bash_cv_have_socklib = yes; then
1149 # check for libnsl, add it to LIBS if present
1150 if test "X$bash_cv_have_libnsl" = "X"; then
1151 _bash_needmsg=
1152 else
1153 AC_MSG_CHECKING(for libnsl)
1154 _bash_needmsg=yes
1155 fi
1156 AC_CACHE_VAL(bash_cv_have_libnsl,
1157 [AC_CHECK_LIB(nsl, t_open,
1158 bash_cv_have_libnsl=yes, bash_cv_have_libnsl=no)])
1159 if test "X$_bash_needmsg" = Xyes; then
1160 AC_MSG_RESULT($bash_cv_have_libnsl)
1161 _bash_needmsg=
1162 fi
1163 if test $bash_cv_have_libnsl = yes; then
1164 LIBS="-lsocket -lnsl $LIBS"
1165 else
1166 LIBS="-lsocket $LIBS"
1167 fi
1168 AC_DEFINE(HAVE_LIBSOCKET)
1169 AC_DEFINE(HAVE_GETPEERNAME)
1170 fi
1171 ])
1172
1173 dnl
1174 dnl This needs BASH_CHECK_SOCKLIB, but since that's not called on every
1175 dnl system, we can't use AC_PREREQ
1176 dnl
1177 AC_DEFUN(BASH_FUNC_GETHOSTBYNAME,
1178 [if test "X$bash_cv_have_gethostbyname" = "X"; then
1179 _bash_needmsg=yes
1180 else
1181 AC_MSG_CHECKING(for gethostbyname in socket library)
1182 _bash_needmsg=
1183 fi
1184 AC_CACHE_VAL(bash_cv_have_gethostbyname,
1185 [AC_TRY_LINK([#include <netdb.h>],
1186 [ struct hostent *hp;
1187 hp = gethostbyname("localhost");
1188 ], bash_cv_have_gethostbyname=yes, bash_cv_have_gethostbyname=no)]
1189 )
1190 if test "X$_bash_needmsg" = Xyes; then
1191 AC_MSG_CHECKING(for gethostbyname in socket library)
1192 fi
1193 AC_MSG_RESULT($bash_cv_have_gethostbyname)
1194 if test "$bash_cv_have_gethostbyname" = yes; then
1195 AC_DEFINE(HAVE_GETHOSTBYNAME)
1196 fi
1197 ])
1198
1199 AC_DEFUN(BASH_DEFAULT_MAIL_DIR,
1200 [AC_MSG_CHECKING(for default mail directory)
1201 AC_CACHE_VAL(bash_cv_mail_dir,
1202 [if test -d /var/mail; then
1203 bash_cv_mail_dir=/var/mail
1204 elif test -d /usr/mail; then
1205 bash_cv_mail_dir=/usr/mail
1206 elif test -d /var/spool/mail; then
1207 bash_cv_mail_dir=/var/spool/mail
1208 elif test -d /usr/spool/mail; then
1209 bash_cv_mail_dir=/usr/spool/mail
1210 else
1211 bash_cv_mail_dir=unknown
1212 fi
1213 ])
1214 AC_MSG_RESULT($bash_cv_mail_dir)
1215 if test $bash_cv_mail_dir = "/var/mail"; then
1216 AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/mail")
1217 elif test $bash_cv_mail_dir = "/usr/mail"; then
1218 AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/mail")
1219 elif test $bash_cv_mail_dir = "/var/spool/mail"; then
1220 AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/var/spool/mail")
1221 elif test $bash_cv_mail_dir = "/usr/spool/mail"; then
1222 AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "/usr/spool/mail")
1223 else
1224 AC_DEFINE(DEFAULT_MAIL_DIRECTORY, "unknown")
1225 fi
1226 ])
1227
1228 dnl
1229 dnl Check if HPUX needs _KERNEL defined for RLIMIT_* definitions
1230 dnl
1231 AC_DEFUN(BASH_KERNEL_RLIMIT_CHECK,
1232 [AC_MSG_CHECKING([whether $host_os needs _KERNEL for RLIMIT defines])
1233 AC_CACHE_VAL(bash_cv_kernel_rlimit,
1234 [AC_TRY_COMPILE([
1235 #include <sys/types.h>
1236 #include <sys/resource.h>
1237 ],
1238 [
1239 int f;
1240 f = RLIMIT_DATA;
1241 ], bash_cv_kernel_rlimit=no,
1242 [AC_TRY_COMPILE([
1243 #include <sys/types.h>
1244 #define _KERNEL
1245 #include <sys/resource.h>
1246 #undef _KERNEL
1247 ],
1248 [
1249 int f;
1250 f = RLIMIT_DATA;
1251 ], bash_cv_kernel_rlimit=yes, bash_cv_kernel_rlimit=no)]
1252 )])
1253 AC_MSG_RESULT($bash_cv_kernel_rlimit)
1254 if test $bash_cv_kernel_rlimit = yes; then
1255 AC_DEFINE(RLIMIT_NEEDS_KERNEL)
1256 fi
1257 ])
1258
1259 AC_DEFUN(BASH_FUNC_STRCOLL,
1260 [
1261 AC_MSG_CHECKING(whether or not strcoll and strcmp differ)
1262 AC_CACHE_VAL(bash_cv_func_strcoll_broken,
1263 [AC_TRY_RUN([
1264 #include <stdio.h>
1265 #if defined (HAVE_LOCALE_H)
1266 #include <locale.h>
1267 #endif
1268
1269 main(c, v)
1270 int c;
1271 char *v[];
1272 {
1273 int r1, r2;
1274 char *deflocale, *defcoll;
1275
1276 #ifdef HAVE_SETLOCALE
1277 deflocale = setlocale(LC_ALL, "");
1278 defcoll = setlocale(LC_COLLATE, "");
1279 #endif
1280
1281 #ifdef HAVE_STRCOLL
1282 /* These two values are taken from tests/glob-test. */
1283 r1 = strcoll("abd", "aXd");
1284 #else
1285 r1 = 0;
1286 #endif
1287 r2 = strcmp("abd", "aXd");
1288
1289 /* These two should both be greater than 0. It is permissible for
1290 a system to return different values, as long as the sign is the
1291 same. */
1292
1293 /* Exit with 1 (failure) if these two values are both > 0, since
1294 this tests whether strcoll(3) is broken with respect to strcmp(3)
1295 in the default locale. */
1296 exit (r1 > 0 && r2 > 0);
1297 }
1298 ], bash_cv_func_strcoll_broken=yes, bash_cv_func_strcoll_broken=no,
1299 [AC_MSG_WARN(cannot check strcoll if cross compiling -- defaulting to no)
1300 bash_cv_func_strcoll_broken=no]
1301 )])
1302 AC_MSG_RESULT($bash_cv_func_strcoll_broken)
1303 if test $bash_cv_func_strcoll_broken = yes; then
1304 AC_DEFINE(STRCOLL_BROKEN)
1305 fi
1306 ])
1307
1308 dnl
1309 dnl If available, use support for large files unless the user specified
1310 dnl one of the CPPFLAGS, LDFLAGS, or LIBS variables (<eggert@twinsun.com>
1311 dnl via GNU patch 2.5)
1312 dnl
1313 AC_DEFUN(BASH_LARGE_FILE_SUPPORT,
1314 [AC_MSG_CHECKING(whether large file support needs explicit enabling)
1315 ac_getconfs=''
1316 ac_result=yes
1317 ac_set=''
1318 ac_shellvars='CPPFLAGS LDFLAGS LIBS'
1319 for ac_shellvar in $ac_shellvars; do
1320 case $ac_shellvar in
1321 CPPFLAGS) ac_lfsvar=LFS_CFLAGS ac_lfs64var=LFS64_CFLAGS ;;
1322 *) ac_lfsvar=LFS_$ac_shellvar ac_lfs64var=LFS64_$ac_shellvar ;;
1323 esac
1324 eval test '"${'$ac_shellvar'+set}"' = set && ac_set=$ac_shellvar
1325 (getconf $ac_lfsvar) >/dev/null 2>&1 || { ac_result=no; break; }
1326 ac_getconf=`getconf $ac_lfsvar`
1327 ac_getconf64=`getconf $ac_lfs64var`
1328 ac_getconfs=$ac_getconfs$ac_getconf\ $ac_getconf64
1329 eval ac_test_$ac_shellvar="\$ac_getconf\ \$ac_getconf64"
1330 done
1331 case "$ac_result$ac_getconfs" in
1332 yes) ac_result=no ;;
1333 esac
1334 case "$ac_result$ac_set" in
1335 yes?*) ac_result="yes, but $ac_set is already set, so use its settings"
1336 esac
1337 AC_MSG_RESULT($ac_result)
1338 case $ac_result in
1339 yes)
1340 for ac_shellvar in $ac_shellvars; do
1341 eval $ac_shellvar=\$ac_test_$ac_shellvar
1342 done ;;
1343 esac
1344 ])
1345
1346 dnl
1347 dnl AC_SYS_RESTARTABLE_SYSCALLS tests only for restarted system calls
1348 dnl after a signal handler has been installed with signal(). Since
1349 dnl Bash uses sigaction() if it is available, we need to check whether
1350 dnl or not a signal handler installed with sigaction and SA_RESTART
1351 dnl causes system calls to be restarted after the signal is caught
1352 dnl
1353 AC_DEFUN(BASH_SYS_RESTARTABLE_SYSCALLS,
1354 [AC_REQUIRE([BASH_SIGNAL_CHECK])
1355 AC_CACHE_CHECK(whether posix sigaction restarts system calls by default,
1356 bash_cv_sys_restartable_syscalls,
1357 [AC_TRY_RUN(
1358 [/* Exit 0 (true) if wait returns something other than -1,
1359 i.e. the pid of the child, which means that wait was restarted
1360 after getting the signal. */
1361 #ifdef HAVE_UNISTD_H
1362 # include <unistd.h>
1363 #endif
1364 #include <sys/types.h>
1365 #include <signal.h>
1366 static int caught = 0;
1367 void ucatch (isig) int isig; { caught = 1; }
1368 main ()
1369 {
1370 #if !defined (_POSIX_VERSION) || !defined (HAVE_POSIX_SIGNALS)
1371 exit (1);
1372 #else
1373 struct sigaction act, oact;
1374 int i, status;
1375
1376 act.sa_handler = ucatch;
1377 /* Might want to add SA_RESTART here, but bash's set_signal_handler
1378 does not. */
1379 act.sa_flags = 0;
1380 sigemptyset(&act.sa_mask);
1381 sigemptyset(&oact.sa_mask);
1382 i = fork ();
1383 /* A possible race condition here, but in practice it never happens. */
1384 if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
1385 sigaction(SIGINT, &act, &oact);
1386 status = wait(&i);
1387 if (status == -1) wait(&i);
1388 exit (status == -1);
1389 #endif
1390 }
1391 ], bash_cv_sys_restartable_syscalls=yes, bash_cv_sys_restartable_syscalls=no,
1392 AC_MSG_WARN(cannot check restartable syscalls if cross compiling))
1393 ])
1394 if test $bash_cv_sys_restartable_syscalls = yes; then
1395 AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
1396 fi
1397 ])
1398 dnl
1399 dnl Check for 64-bit off_t -- used for malloc alignment
1400 dnl
1401 dnl C does not allow duplicate case labels, so the compile will fail if
1402 dnl sizeof(off_t) is > 4.
1403 dnl
1404 AC_DEFUN(BASH_CHECK_OFF_T_64,
1405 [AC_CACHE_CHECK(for 64-bit off_t, bash_cv_off_t_64,
1406 AC_TRY_COMPILE([
1407 #ifdef HAVE_UNISTD_H
1408 #include <unistd.h>
1409 #endif
1410 #include <sys/types.h>
1411 ],[
1412 switch (0) case 0: case (sizeof (off_t) <= 4):;
1413 ], bash_cv_off_t_64=no, bash_cv_off_t_64=yes))
1414 if test $bash_cv_off_t_64 = yes; then
1415 AC_DEFINE(HAVE_OFF_T_64)
1416 fi])
1417
1418 AC_DEFUN(BASH_STRUCT_TIMEVAL,
1419 [AC_MSG_CHECKING(for struct timeval in sys/time.h and time.h)
1420 AC_CACHE_VAL(bash_cv_struct_timeval,
1421 [
1422 AC_EGREP_HEADER(struct timeval, sys/time.h,
1423 bash_cv_struct_timeval=yes,
1424 AC_EGREP_HEADER(struct timeval, time.h,
1425 bash_cv_struct_timeval=yes,
1426 bash_cv_struct_timeval=no))
1427 ])
1428 AC_MSG_RESULT($bash_cv_struct_timeval)
1429 if test $bash_cv_struct_timeval = yes; then
1430 AC_DEFINE(HAVE_TIMEVAL)
1431 fi
1432 ])
1433
1434 AC_DEFUN(BASH_CHECK_RTSIGS,
1435 [AC_MSG_CHECKING(for unusable real-time signals due to large values)
1436 AC_CACHE_VAL(bash_cv_unusable_rtsigs,
1437 [AC_TRY_RUN([
1438 #include <sys/types.h>
1439 #include <signal.h>
1440
1441 #ifndef NSIG
1442 # define NSIG 64
1443 #endif
1444
1445 main ()
1446 {
1447 int n_sigs = 2 * NSIG;
1448 #ifdef SIGRTMIN
1449 int rtmin = SIGRTMIN;
1450 #else
1451 int rtmin = 0;
1452 #endif
1453
1454 exit(rtmin < n_sigs);
1455 }], bash_cv_unusable_rtsigs=yes, bash_cv_unusable_rtsigs=no,
1456 [AC_MSG_WARN(cannot check real-time signals if cross compiling -- defaulting to yes)
1457 bash_cv_unusable_rtsigs=yes]
1458 )])
1459 AC_MSG_RESULT($bash_cv_unusable_rtsigs)
1460 if test $bash_cv_unusable_rtsigs = yes; then
1461 AC_DEFINE(UNUSABLE_RT_SIGNALS)
1462 fi
1463 ])