diff options
Diffstat (limited to 'gcc/libgcc2.c')
| -rw-r--r-- | gcc/libgcc2.c | 138 |
1 files changed, 138 insertions, 0 deletions
diff --git a/gcc/libgcc2.c b/gcc/libgcc2.c index 3108bff6729..a49c8c128f9 100644 --- a/gcc/libgcc2.c +++ b/gcc/libgcc2.c @@ -2015,3 +2015,141 @@ func_ptr __DTOR_LIST__[2]; #endif #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */ #endif /* L_ctors */ + +#ifdef L_stack_chk +#ifndef TARGET_LIBC_PROVIDES_SSP + +#ifndef inhibit_libc +# include <string.h> +# include <unistd.h> +# include <fcntl.h> +# ifdef HAVE_PATHS_H +# include <paths.h> +# endif +# ifndef _PATH_TTY +# define _PATH_TTY "/dev/tty" +# endif +# ifdef HAVE_SYSLOG_H +# include <syslog.h> +# endif +#endif + +void *__stack_chk_guard = 0; + +static void __attribute__ ((constructor)) +__guard_setup (void) +{ + unsigned char *p; + + if (__stack_chk_guard != 0) + return; + +#ifndef inhibit_libc + { + int fd = open ("/dev/urandom", O_RDONLY); + if (fd != -1) + { + ssize_t size = read (fd, &__stack_chk_guard, + sizeof (__stack_chk_guard)); + close (fd); + if (size == sizeof(__stack_chk_guard)) + return; + } + } +#endif + + /* If a random generator can't be used, the protector switches the guard + to the "terminator canary". */ + p = (unsigned char *)&__stack_chk_guard; + p[sizeof(__stack_chk_guard)-1] = 255; + p[sizeof(__stack_chk_guard)-2] = '\n'; + p[0] = 0; +} + +void +__stack_chk_fail (void) +{ +#ifndef inhibit_libc +# ifdef __GNU_LIBRARY__ + extern char * __progname; +# else + static const char __progname[] = ""; +# endif + + int fd; + + /* Print error message directly to the tty. This avoids Bad Things + happening if stderr is redirected. */ + fd = open (_PATH_TTY, O_WRONLY); + if (fd != -1) + { + static const char msg1[] = "*** stack smashing detected ***: "; + static const char msg2[] = " terminated\n"; + size_t progname_len, len; + char *buf, *p; + + progname_len = strlen (__progname); + len = sizeof(msg1)-1 + progname_len + sizeof(msg2)-1 + 1; + p = buf = alloca (len); + + memcpy (p, msg1, sizeof(msg1)-1); + p += sizeof(msg1)-1; + memcpy (p, __progname, progname_len); + p += progname_len; + memcpy (p, msg2, sizeof(msg2)); + + while (len > 0) + { + ssize_t wrote = write (fd, buf, len); + if (wrote < 0) + break; + len -= wrote; + } + close (fd); + } + +# ifdef HAVE_SYSLOG_H + /* Only send the error to syslog if there was no tty available. */ + else + syslog (LOG_CRIT, "stack smashing detected: terminated"); +# endif /* HAVE_SYSLOG_H */ +#endif /* inhibit_libc */ + + /* Try very hard to exit. Note that signals may be blocked preventing + the first two options from working. The use of volatile is here to + prevent optimizers from "knowing" that __builtin_trap is called first, + and that it doesn't return, and so "obviously" the rest of the code + is dead. */ + { + volatile int state; + for (state = 0; ; state++) + switch (state) + { + case 0: + __builtin_trap (); + break; + case 1: + *(volatile int *)-1L = 0; + break; + case 2: + _exit (127); + break; + } + } +} +#endif /* TARGET_LIBC_PROVIDES_SSP */ +#endif /* L_stack_chk */ + +#ifdef L_stack_chk_local +#ifndef TARGET_LIBC_PROVIDES_SSP +/* Some targets can avoid loading a GP for calls to hidden functions. + Using this entry point may avoid the load of a GP entirely for the + function, making the overall code smaller. */ + +void +__stack_chk_fail_local (void) +{ + __stack_chk_fail (); +} +#endif /* TARGET_LIBC_PROVIDES_SSP */ +#endif /* L_stack_chk_local */ |