You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
686 lines
23 KiB
686 lines
23 KiB
diff --git a/gnulib-tests/Makefile.in b/gnulib-tests/Makefile.in |
|
index aa979f4..194cc7d 100644 |
|
--- a/gnulib-tests/Makefile.in |
|
+++ b/gnulib-tests/Makefile.in |
|
@@ -3100,7 +3100,7 @@ test_argmatch_LDADD = $(LDADD) @LIBINTL@ $(LIB_MBRTOWC) |
|
test_bind_LDADD = $(LDADD) @LIBSOCKET@ $(INET_PTON_LIB) |
|
test_btowc_LDADD = $(LDADD) $(LIB_SETLOCALE) |
|
test_c_ctype_LDADD = $(LDADD) $(LIB_SETLOCALE) |
|
-test_c_stack_LDADD = $(LDADD) $(LIBCSTACK) @LIBINTL@ |
|
+test_c_stack_LDADD = $(LDADD) -lsigsegv @LIBINTL@ |
|
test_c_strcasecmp_LDADD = $(LDADD) $(LIB_SETLOCALE) |
|
test_c_strncasecmp_LDADD = $(LDADD) $(LIB_SETLOCALE) |
|
test_connect_LDADD = $(LDADD) @LIBSOCKET@ $(INET_PTON_LIB) |
|
diff --git a/gnulib-tests/gnulib.mk b/gnulib-tests/gnulib.mk |
|
index b1dc6f9..ba0594e 100644 |
|
--- a/gnulib-tests/gnulib.mk |
|
+++ b/gnulib-tests/gnulib.mk |
|
@@ -209,7 +209,7 @@ EXTRA_DIST += test-c-ctype.c macros.h |
|
TESTS += test-c-stack.sh test-c-stack2.sh |
|
TESTS_ENVIRONMENT += LIBSIGSEGV='@LIBSIGSEGV@' |
|
check_PROGRAMS += test-c-stack |
|
-test_c_stack_LDADD = $(LDADD) $(LIBCSTACK) @LIBINTL@ |
|
+test_c_stack_LDADD = $(LDADD) -lsigsegv @LIBINTL@ |
|
MOSTLYCLEANFILES += t-c-stack.tmp t-c-stack2.tmp |
|
EXTRA_DIST += test-c-stack.c test-c-stack.sh test-c-stack2.sh macros.h |
|
|
|
diff --git a/lib/c-stack.c b/lib/c-stack.c |
|
index 3aea16a..b0e5cb1 100644 |
|
--- a/lib/c-stack.c |
|
+++ b/lib/c-stack.c |
|
@@ -1,6 +1,6 @@ |
|
/* Stack overflow handling. |
|
|
|
- Copyright (C) 2002, 2004, 2006, 2008-2020 Free Software Foundation, Inc. |
|
+ Copyright (C) 2002, 2004, 2006, 2008-2021 Free Software Foundation, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
@@ -37,54 +37,28 @@ |
|
|
|
#include "c-stack.h" |
|
|
|
-#include "gettext.h" |
|
-#define _(msgid) gettext (msgid) |
|
- |
|
#include <errno.h> |
|
#include <inttypes.h> |
|
- |
|
#include <signal.h> |
|
-#if ! HAVE_STACK_T && ! defined stack_t |
|
-typedef struct sigaltstack stack_t; |
|
-#endif |
|
- |
|
-#include <stdbool.h> |
|
#include <stddef.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
- |
|
-/* Pre-2008 POSIX declared ucontext_t in ucontext.h instead of signal.h. */ |
|
-#if HAVE_UCONTEXT_H |
|
-# include <ucontext.h> |
|
-#endif |
|
- |
|
#include <unistd.h> |
|
|
|
#if DEBUG |
|
# include <stdio.h> |
|
#endif |
|
|
|
-/* Use libsigsegv only if needed; kernels like Solaris can detect |
|
- stack overflow without the overhead of an external library. */ |
|
-#define USE_LIBSIGSEGV (!HAVE_XSI_STACK_OVERFLOW_HEURISTIC && HAVE_LIBSIGSEGV) |
|
- |
|
-#if USE_LIBSIGSEGV |
|
-# include <sigsegv.h> |
|
-#endif |
|
+#include <sigsegv.h> |
|
|
|
#include "exitfail.h" |
|
-#include "ignore-value.h" |
|
-#include "intprops.h" |
|
#include "getprogname.h" |
|
+#include "ignore-value.h" |
|
|
|
-#if defined SA_ONSTACK && defined SA_SIGINFO |
|
-# define SIGINFO_WORKS 1 |
|
-#else |
|
-# define SIGINFO_WORKS 0 |
|
-# ifndef SA_ONSTACK |
|
-# define SA_ONSTACK 0 |
|
-# endif |
|
-#endif |
|
+#include "gettext.h" |
|
+#define _(msgid) gettext (msgid) |
|
+ |
|
+#if HAVE_STACK_OVERFLOW_RECOVERY |
|
|
|
/* Storage for the alternate signal stack. |
|
64 KiB is not too large for Gnulib-using apps, and is large enough |
|
@@ -106,9 +80,6 @@ static _GL_ASYNC_SAFE void (* volatile segv_action) (int); |
|
static char const * volatile program_error_message; |
|
static char const * volatile stack_overflow_message; |
|
|
|
-#if (USE_LIBSIGSEGV \ |
|
- || (HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING)) |
|
- |
|
/* Output an error message, then exit with status EXIT_FAILURE if it |
|
appears to have been a stack overflow, or with a core dump |
|
otherwise. This function is async-signal-safe. */ |
|
@@ -118,12 +89,6 @@ static char const * volatile progname; |
|
static _GL_ASYNC_SAFE _Noreturn void |
|
die (int signo) |
|
{ |
|
-# if !SIGINFO_WORKS && !USE_LIBSIGSEGV |
|
- /* We can't easily determine whether it is a stack overflow; so |
|
- assume that the rest of our program is perfect (!) and that |
|
- this segmentation violation is a stack overflow. */ |
|
- signo = 0; |
|
-# endif |
|
segv_action (signo); |
|
char const *message = signo ? program_error_message : stack_overflow_message; |
|
|
|
@@ -164,12 +129,8 @@ null_action (int signo _GL_UNUSED) |
|
{ |
|
} |
|
|
|
-#endif /* SIGALTSTACK || LIBSIGSEGV */ |
|
- |
|
-#if USE_LIBSIGSEGV |
|
- |
|
/* Pacify GCC 9.3.1, which otherwise would complain about segv_handler. */ |
|
-# if __GNUC_PREREQ (4, 6) |
|
+# if 4 < __GNUC__ + (6 <= __GNUC_MINOR__) |
|
# pragma GCC diagnostic ignored "-Wsuggest-attribute=pure" |
|
# endif |
|
|
|
@@ -240,132 +201,7 @@ c_stack_action (_GL_ASYNC_SAFE void (*action) (int)) |
|
return 0; |
|
} |
|
|
|
-#elif HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING |
|
- |
|
-# if SIGINFO_WORKS |
|
- |
|
-static size_t volatile page_size; |
|
- |
|
-/* Handle a segmentation violation and exit. This function is |
|
- async-signal-safe. */ |
|
- |
|
-static _GL_ASYNC_SAFE _Noreturn void |
|
-segv_handler (int signo, siginfo_t *info, void *context _GL_UNUSED) |
|
-{ |
|
- /* Clear SIGNO if it seems to have been a stack overflow. */ |
|
- |
|
- /* If si_code is nonpositive, something like raise (SIGSEGV) occurred |
|
- so it cannot be a stack overflow. */ |
|
- bool cannot_be_stack_overflow = info->si_code <= 0; |
|
- |
|
- /* An unaligned address cannot be a stack overflow. */ |
|
-# if FAULT_YIELDS_SIGBUS |
|
- cannot_be_stack_overflow |= signo == SIGBUS && info->si_code == BUS_ADRALN; |
|
-# endif |
|
- |
|
- /* If we can't easily determine that it is not a stack overflow, |
|
- assume that the rest of our program is perfect (!) and that |
|
- this segmentation violation is a stack overflow. |
|
- |
|
- Note that although both Linux and Solaris provide |
|
- sigaltstack, SA_ONSTACK, and SA_SIGINFO, currently only |
|
- Solaris satisfies the XSI heuristic. This is because |
|
- Solaris populates uc_stack with the details of the |
|
- interrupted stack, while Linux populates it with the details |
|
- of the current stack. */ |
|
- if (!cannot_be_stack_overflow) |
|
- { |
|
- /* If the faulting address is within the stack, or within one |
|
- page of the stack, assume that it is a stack overflow. */ |
|
- uintptr_t faulting_address = (uintptr_t) info->si_addr; |
|
- |
|
- /* On all platforms we know of, the first page is not in the |
|
- stack to catch null pointer dereferening. However, all other |
|
- pages might be in the stack. */ |
|
- void *stack_base = (void *) (uintptr_t) page_size; |
|
- uintptr_t stack_size = 0; stack_size -= page_size; |
|
-# if HAVE_XSI_STACK_OVERFLOW_HEURISTIC |
|
- /* Tighten the stack bounds via the XSI heuristic. */ |
|
- ucontext_t const *user_context = context; |
|
- stack_base = user_context->uc_stack.ss_sp; |
|
- stack_size = user_context->uc_stack.ss_size; |
|
-# endif |
|
- uintptr_t base = (uintptr_t) stack_base, |
|
- lo = (INT_SUBTRACT_WRAPV (base, page_size, &lo) || lo < page_size |
|
- ? page_size : lo), |
|
- hi = ((INT_ADD_WRAPV (base, stack_size, &hi) |
|
- || INT_ADD_WRAPV (hi, page_size - 1, &hi)) |
|
- ? UINTPTR_MAX : hi); |
|
- if (lo <= faulting_address && faulting_address <= hi) |
|
- signo = 0; |
|
- |
|
-# if DEBUG |
|
- { |
|
- char buf[1024]; |
|
- ignore_value (write (STDERR_FILENO, buf, |
|
- sprintf (buf, |
|
- ("segv_handler code=%d fault=%p base=%p" |
|
- " size=0x%zx page=0x%zx signo=%d\n"), |
|
- info->si_code, info->si_addr, stack_base, |
|
- stack_size, page_size, signo))); |
|
- } |
|
-# endif |
|
- } |
|
- |
|
- die (signo); |
|
-} |
|
-# endif |
|
- |
|
-int |
|
-c_stack_action (_GL_ASYNC_SAFE void (*action) (int)) |
|
-{ |
|
- stack_t st; |
|
- st.ss_flags = 0; |
|
- st.ss_sp = alternate_signal_stack; |
|
- st.ss_size = sizeof alternate_signal_stack; |
|
-# if SIGALTSTACK_SS_REVERSED |
|
- /* Irix mistakenly treats ss_sp as the upper bound, rather than |
|
- lower bound, of the alternate stack. */ |
|
- st.ss_size -= sizeof (void *); |
|
- char *ss_sp = st.ss_sp; |
|
- st.ss_sp = ss_sp + st.ss_size; |
|
-# endif |
|
- int r = sigaltstack (&st, NULL); |
|
- if (r != 0) |
|
- return r; |
|
- |
|
- segv_action = action ? action : null_action; |
|
- program_error_message = _("program error"); |
|
- stack_overflow_message = _("stack overflow"); |
|
- progname = getprogname (); |
|
- |
|
-# if SIGINFO_WORKS |
|
- page_size = sysconf (_SC_PAGESIZE); |
|
-# endif |
|
- |
|
- struct sigaction act; |
|
- sigemptyset (&act.sa_mask); |
|
- |
|
-# if SIGINFO_WORKS |
|
- /* POSIX 1003.1-2001 says SA_RESETHAND implies SA_NODEFER, but |
|
- this is not true on Solaris 8 at least. It doesn't hurt to use |
|
- SA_NODEFER here, so leave it in. */ |
|
- act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO; |
|
- act.sa_sigaction = segv_handler; |
|
-# else |
|
- act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND; |
|
- act.sa_handler = die; |
|
-# endif |
|
- |
|
-# if FAULT_YIELDS_SIGBUS |
|
- if (sigaction (SIGBUS, &act, NULL) < 0) |
|
- return -1; |
|
-# endif |
|
- return sigaction (SIGSEGV, &act, NULL); |
|
-} |
|
- |
|
-#else /* ! (USE_LIBSIGSEGV |
|
- || (HAVE_DECL_SIGALTSTACK && HAVE_STACK_OVERFLOW_HANDLING)) */ |
|
+#else /* !HAVE_STACK_OVERFLOW_RECOVERY */ |
|
|
|
int |
|
c_stack_action (_GL_ASYNC_SAFE void (*action) (int) _GL_UNUSED) |
|
diff --git a/m4/c-stack.m4 b/m4/c-stack.m4 |
|
index 85107f4..7cccb06 100644 |
|
--- a/m4/c-stack.m4 |
|
+++ b/m4/c-stack.m4 |
|
@@ -1,376 +1,21 @@ |
|
# Check prerequisites for compiling lib/c-stack.c. |
|
|
|
-# Copyright (C) 2002-2004, 2008-2020 Free Software Foundation, Inc. |
|
+# Copyright (C) 2002-2004, 2008-2021 Free Software Foundation, Inc. |
|
# This file is free software; the Free Software Foundation |
|
# gives unlimited permission to copy and/or distribute it, |
|
# with or without modifications, as long as this notice is preserved. |
|
|
|
# Written by Paul Eggert. |
|
|
|
-# serial 20 |
|
- |
|
-AC_DEFUN([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC], |
|
- [ |
|
- AC_REQUIRE([AC_CANONICAL_HOST]) |
|
- AC_CHECK_FUNCS_ONCE([setrlimit]) |
|
- AC_CHECK_HEADERS_ONCE([ucontext.h]) |
|
- |
|
- dnl List of signals that are sent when an invalid virtual memory address |
|
- dnl is accessed, or when the stack overflows. |
|
- dnl Either { SIGSEGV } or { SIGSEGV, SIGBUS }. |
|
- case "$host_os" in |
|
- sunos4* | freebsd* | dragonfly* | openbsd* | mirbsd* | netbsd* | kfreebsd* | knetbsd*) # BSD systems |
|
- FAULT_YIELDS_SIGBUS=1 ;; |
|
- hpux*) # HP-UX |
|
- FAULT_YIELDS_SIGBUS=1 ;; |
|
- macos* | darwin*) # Mac OS X |
|
- FAULT_YIELDS_SIGBUS=1 ;; |
|
- gnu*) # Hurd |
|
- FAULT_YIELDS_SIGBUS=1 ;; |
|
- *) |
|
- FAULT_YIELDS_SIGBUS=0 ;; |
|
- esac |
|
- AC_DEFINE_UNQUOTED([FAULT_YIELDS_SIGBUS], [$FAULT_YIELDS_SIGBUS], |
|
- [Define to 1 if an invalid memory address access may yield a SIGBUS.]) |
|
- |
|
- AC_CACHE_CHECK([for working C stack overflow detection], |
|
- [gl_cv_sys_stack_overflow_works], |
|
- [AC_RUN_IFELSE([AC_LANG_SOURCE( |
|
- [[ |
|
- #include <unistd.h> |
|
- #include <signal.h> |
|
- #if HAVE_SETRLIMIT |
|
- # include <sys/types.h> |
|
- # include <sys/time.h> |
|
- # include <sys/resource.h> |
|
- #endif |
|
- #ifndef SIGSTKSZ |
|
- # define SIGSTKSZ 16384 |
|
- #endif |
|
- |
|
- static union |
|
- { |
|
- char buffer[2 * SIGSTKSZ]; |
|
- long double ld; |
|
- long u; |
|
- void *p; |
|
- } alternate_signal_stack; |
|
- |
|
- static void |
|
- segv_handler (int signo) |
|
- { |
|
- _exit (0); |
|
- } |
|
- |
|
- static int |
|
- c_stack_action () |
|
- { |
|
- stack_t st; |
|
- struct sigaction act; |
|
- int r; |
|
- |
|
- st.ss_flags = 0; |
|
- /* Use the midpoint to avoid Irix sigaltstack bug. */ |
|
- st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ; |
|
- st.ss_size = SIGSTKSZ; |
|
- r = sigaltstack (&st, 0); |
|
- if (r != 0) |
|
- return 1; |
|
- |
|
- sigemptyset (&act.sa_mask); |
|
- act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND; |
|
- act.sa_handler = segv_handler; |
|
- #if FAULT_YIELDS_SIGBUS |
|
- if (sigaction (SIGBUS, &act, 0) < 0) |
|
- return 2; |
|
- #endif |
|
- if (sigaction (SIGSEGV, &act, 0) < 0) |
|
- return 3; |
|
- return 0; |
|
- } |
|
- static volatile int * |
|
- recurse_1 (volatile int n, volatile int *p) |
|
- { |
|
- if (n >= 0) |
|
- *recurse_1 (n + 1, p) += n; |
|
- return p; |
|
- } |
|
- static int |
|
- recurse (volatile int n) |
|
- { |
|
- int sum = 0; |
|
- return *recurse_1 (n, &sum); |
|
- } |
|
- int |
|
- main () |
|
- { |
|
- int result; |
|
- #if HAVE_SETRLIMIT && defined RLIMIT_STACK |
|
- /* Before starting the endless recursion, try to be friendly |
|
- to the user's machine. On some Linux 2.2.x systems, there |
|
- is no stack limit for user processes at all. We don't want |
|
- to kill such systems. */ |
|
- struct rlimit rl; |
|
- rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */ |
|
- setrlimit (RLIMIT_STACK, &rl); |
|
- #endif |
|
- |
|
- result = c_stack_action (); |
|
- if (result != 0) |
|
- return result; |
|
- return recurse (0); |
|
- } |
|
- ]])], |
|
- [gl_cv_sys_stack_overflow_works=yes], |
|
- [gl_cv_sys_stack_overflow_works=no], |
|
- [case "$host_os" in |
|
- # Guess no on native Windows. |
|
- mingw*) gl_cv_sys_stack_overflow_works="guessing no" ;; |
|
- *) gl_cv_sys_stack_overflow_works=cross-compiling ;; |
|
- esac |
|
- ]) |
|
- ]) |
|
- |
|
- if test "$gl_cv_sys_stack_overflow_works" = yes; then |
|
- AC_DEFINE([HAVE_STACK_OVERFLOW_HANDLING], [1], |
|
- [Define to 1 if extending the stack slightly past the limit causes |
|
- a SIGSEGV which can be handled on an alternate stack established |
|
- with sigaltstack.]) |
|
- |
|
- dnl The ss_sp field of a stack_t is, according to POSIX, the lowest address |
|
- dnl of the memory block designated as an alternate stack. But IRIX 5.3 |
|
- dnl interprets it as the highest address! |
|
- AC_CACHE_CHECK([for correct stack_t interpretation], |
|
- [gl_cv_sigaltstack_low_base], [ |
|
- AC_RUN_IFELSE([ |
|
- AC_LANG_SOURCE([[ |
|
-#include <stdlib.h> |
|
-#include <signal.h> |
|
-#if HAVE_SYS_SIGNAL_H |
|
-# include <sys/signal.h> |
|
-#endif |
|
-#ifndef SIGSTKSZ |
|
-# define SIGSTKSZ 16384 |
|
-#endif |
|
-volatile char *stack_lower_bound; |
|
-volatile char *stack_upper_bound; |
|
-static void check_stack_location (volatile char *addr) |
|
-{ |
|
- if (addr >= stack_lower_bound && addr <= stack_upper_bound) |
|
- exit (0); |
|
- else |
|
- exit (1); |
|
-} |
|
-static void stackoverflow_handler (int sig) |
|
-{ |
|
- char dummy; |
|
- check_stack_location (&dummy); |
|
-} |
|
-int main () |
|
-{ |
|
- char mystack[2 * SIGSTKSZ]; |
|
- stack_t altstack; |
|
- struct sigaction action; |
|
- /* Install the alternate stack. */ |
|
- altstack.ss_sp = mystack + SIGSTKSZ; |
|
- altstack.ss_size = SIGSTKSZ; |
|
- stack_lower_bound = (char *) altstack.ss_sp; |
|
- stack_upper_bound = (char *) altstack.ss_sp + altstack.ss_size - 1; |
|
- altstack.ss_flags = 0; /* no SS_DISABLE */ |
|
- if (sigaltstack (&altstack, NULL) < 0) |
|
- exit (2); |
|
- /* Install the SIGSEGV handler. */ |
|
- sigemptyset (&action.sa_mask); |
|
- action.sa_handler = &stackoverflow_handler; |
|
- action.sa_flags = SA_ONSTACK; |
|
- if (sigaction (SIGSEGV, &action, (struct sigaction *) NULL) < 0) |
|
- exit(3); |
|
- /* Provoke a SIGSEGV. */ |
|
- raise (SIGSEGV); |
|
- exit (4); |
|
-}]])], |
|
- [gl_cv_sigaltstack_low_base=yes], |
|
- [gl_cv_sigaltstack_low_base=no], |
|
- [gl_cv_sigaltstack_low_base=cross-compiling])]) |
|
- if test "$gl_cv_sigaltstack_low_base" = no; then |
|
- AC_DEFINE([SIGALTSTACK_SS_REVERSED], [1], |
|
- [Define if sigaltstack() interprets the stack_t.ss_sp field |
|
- incorrectly, as the highest address of the alternate stack range |
|
- rather than as the lowest address.]) |
|
- fi |
|
- |
|
- AC_CACHE_CHECK([for precise C stack overflow detection], |
|
- [gl_cv_sys_xsi_stack_overflow_heuristic], |
|
- [dnl On Linux/sparc64 (both in 32-bit and 64-bit mode), it would be wrong |
|
- dnl to set HAVE_XSI_STACK_OVERFLOW_HEURISTIC to 1, because the third |
|
- dnl argument passed to the segv_handler is a 'struct sigcontext *', not |
|
- dnl an 'ucontext_t *'. It would lead to a failure of test-c-stack2.sh. |
|
- case "${host_os}--${host_cpu}" in |
|
- linux*--sparc*) |
|
- gl_cv_sys_xsi_stack_overflow_heuristic=no |
|
- ;; |
|
- *) |
|
- AC_RUN_IFELSE( |
|
- [AC_LANG_SOURCE( |
|
- [[ |
|
- #include <unistd.h> |
|
- #include <signal.h> |
|
- #if HAVE_UCONTEXT_H |
|
- # include <ucontext.h> |
|
- #endif |
|
- #if HAVE_SETRLIMIT |
|
- # include <sys/types.h> |
|
- # include <sys/time.h> |
|
- # include <sys/resource.h> |
|
- #endif |
|
- #ifndef SIGSTKSZ |
|
- # define SIGSTKSZ 16384 |
|
- #endif |
|
- |
|
- static union |
|
- { |
|
- char buffer[2 * SIGSTKSZ]; |
|
- long double ld; |
|
- long u; |
|
- void *p; |
|
- } alternate_signal_stack; |
|
- |
|
- #if STACK_DIRECTION |
|
- # define find_stack_direction(ptr) STACK_DIRECTION |
|
- #else |
|
- static int |
|
- find_stack_direction (char const *addr) |
|
- { |
|
- char dummy; |
|
- return (! addr ? find_stack_direction (&dummy) |
|
- : addr < &dummy ? 1 : -1); |
|
- } |
|
- #endif |
|
- |
|
- static void |
|
- segv_handler (int signo, siginfo_t *info, void *context) |
|
- { |
|
- if (0 < info->si_code) |
|
- { |
|
- /* For XSI heuristics to work, we need uc_stack to |
|
- describe the interrupted stack (as on Solaris), and |
|
- not the currently executing stack (as on Linux). */ |
|
- ucontext_t const *user_context = context; |
|
- char const *stack_min = user_context->uc_stack.ss_sp; |
|
- size_t stack_size = user_context->uc_stack.ss_size; |
|
- char const *faulting_address = info->si_addr; |
|
- size_t s = faulting_address - stack_min; |
|
- size_t page_size = sysconf (_SC_PAGESIZE); |
|
- if (find_stack_direction (0) < 0) |
|
- s += page_size; |
|
- if (s < stack_size + page_size) |
|
- _exit (0); |
|
- _exit (4); |
|
- } |
|
- _exit (5); |
|
- } |
|
- |
|
- static int |
|
- c_stack_action () |
|
- { |
|
- stack_t st; |
|
- struct sigaction act; |
|
- int r; |
|
- |
|
- st.ss_flags = 0; |
|
- /* Use the midpoint to avoid Irix sigaltstack bug. */ |
|
- st.ss_sp = alternate_signal_stack.buffer + SIGSTKSZ; |
|
- st.ss_size = SIGSTKSZ; |
|
- r = sigaltstack (&st, 0); |
|
- if (r != 0) |
|
- return 1; |
|
- |
|
- sigemptyset (&act.sa_mask); |
|
- act.sa_flags = SA_NODEFER | SA_ONSTACK | SA_RESETHAND | SA_SIGINFO; |
|
- act.sa_sigaction = segv_handler; |
|
- #if FAULT_YIELDS_SIGBUS |
|
- if (sigaction (SIGBUS, &act, 0) < 0) |
|
- return 2; |
|
- #endif |
|
- if (sigaction (SIGSEGV, &act, 0) < 0) |
|
- return 3; |
|
- return 0; |
|
- } |
|
- static volatile int * |
|
- recurse_1 (volatile int n, volatile int *p) |
|
- { |
|
- if (n >= 0) |
|
- *recurse_1 (n + 1, p) += n; |
|
- return p; |
|
- } |
|
- static int |
|
- recurse (volatile int n) |
|
- { |
|
- int sum = 0; |
|
- return *recurse_1 (n, &sum); |
|
- } |
|
- int |
|
- main () |
|
- { |
|
- int result; |
|
- #if HAVE_SETRLIMIT && defined RLIMIT_STACK |
|
- /* Before starting the endless recursion, try to be friendly |
|
- to the user's machine. On some Linux 2.2.x systems, there |
|
- is no stack limit for user processes at all. We don't want |
|
- to kill such systems. */ |
|
- struct rlimit rl; |
|
- rl.rlim_cur = rl.rlim_max = 0x100000; /* 1 MB */ |
|
- setrlimit (RLIMIT_STACK, &rl); |
|
- #endif |
|
- |
|
- result = c_stack_action (); |
|
- if (result != 0) |
|
- return result; |
|
- return recurse (0); |
|
- } |
|
- ]])], |
|
- [gl_cv_sys_xsi_stack_overflow_heuristic=yes], |
|
- [gl_cv_sys_xsi_stack_overflow_heuristic=no], |
|
- [gl_cv_sys_xsi_stack_overflow_heuristic=cross-compiling]) |
|
- ;; |
|
- esac |
|
- ]) |
|
- |
|
- if test "$gl_cv_sys_xsi_stack_overflow_heuristic" = yes; then |
|
- AC_DEFINE([HAVE_XSI_STACK_OVERFLOW_HEURISTIC], [1], |
|
- [Define to 1 if extending the stack slightly past the limit causes |
|
- a SIGSEGV, and an alternate stack can be established with sigaltstack, |
|
- and the signal handler is passed a context that specifies the |
|
- run time stack. This behavior is defined by POSIX 1003.1-2001 |
|
- with the X/Open System Interface (XSI) option |
|
- and is a standardized way to implement a SEGV-based stack |
|
- overflow detection heuristic.]) |
|
- fi |
|
- fi]) |
|
- |
|
- |
|
-AC_DEFUN([gl_PREREQ_C_STACK], |
|
- [AC_REQUIRE([AC_SYS_XSI_STACK_OVERFLOW_HEURISTIC]) |
|
- |
|
- AC_CHECK_FUNCS_ONCE([sigaltstack]) |
|
- AC_CHECK_DECLS([sigaltstack], , , [[#include <signal.h>]]) |
|
- |
|
- AC_CHECK_HEADERS_ONCE([ucontext.h]) |
|
- |
|
- AC_CHECK_TYPES([stack_t], , , [[#include <signal.h>]]) |
|
- |
|
- dnl c-stack does not need -lsigsegv if the system has XSI heuristics. |
|
- if test "$gl_cv_sys_xsi_stack_overflow_heuristic" != yes; then |
|
- gl_LIBSIGSEGV |
|
- if test "$gl_cv_lib_sigsegv" = yes; then |
|
- AC_SUBST([LIBCSTACK], [$LIBSIGSEGV]) |
|
- AC_SUBST([LTLIBCSTACK], [$LTLIBSIGSEGV]) |
|
- fi |
|
- fi |
|
-]) |
|
+# serial 23 |
|
|
|
AC_DEFUN([gl_C_STACK], |
|
[ |
|
- dnl Prerequisites of lib/c-stack.c. |
|
- gl_PREREQ_C_STACK |
|
+ dnl 'c-stack' needs -lsigsegv if and only if the 'sigsegv' module needs it. |
|
+ if test "$with_libsigsegv" = yes; then |
|
+ if test "$gl_cv_lib_sigsegv" = yes; then |
|
+ AC_SUBST([LIBCSTACK], [$LIBSIGSEGV]) |
|
+ AC_SUBST([LTLIBCSTACK], [$LTLIBSIGSEGV]) |
|
+ fi |
|
+ fi |
|
]) |
|
diff --git a/src/Makefile.am b/src/Makefile.am |
|
index 1aebcf7..055ee17 100644 |
|
--- a/src/Makefile.am |
|
+++ b/src/Makefile.am |
|
@@ -45,7 +45,7 @@ LDADD = \ |
|
../lib/libgreputils.a $(LIBINTL) ../lib/libgreputils.a $(LIBICONV) \ |
|
$(LIBTHREAD) |
|
|
|
-grep_LDADD = $(LDADD) $(PCRE_LIBS) $(LIBCSTACK) |
|
+grep_LDADD = $(LDADD) $(PCRE_LIBS) -lsigsegv |
|
localedir = $(datadir)/locale |
|
AM_CPPFLAGS = -I$(top_builddir)/lib -I$(top_srcdir)/lib |
|
|
|
diff --git a/src/Makefile.in b/src/Makefile.in |
|
index 20c43b5..a276db8 100644 |
|
--- a/src/Makefile.in |
|
+++ b/src/Makefile.in |
|
@@ -1541,7 +1541,7 @@ LDADD = \ |
|
../lib/libgreputils.a $(LIBINTL) ../lib/libgreputils.a $(LIBICONV) \ |
|
$(LIBTHREAD) |
|
|
|
-grep_LDADD = $(LDADD) $(PCRE_LIBS) $(LIBCSTACK) |
|
+grep_LDADD = $(LDADD) $(PCRE_LIBS) -lsigsegv |
|
AM_CPPFLAGS = -I$(top_builddir)/lib -I$(top_srcdir)/lib |
|
EXTRA_DIST = egrep.sh |
|
CLEANFILES = egrep fgrep *-t
|
|
|