Attachment #159850 for bug #202311

Added Link Here

(-)b/tools/build/options/WITHOUT_FORTIFY (+4 lines)
1	.\" $FreeBSD$
2	Set to not build world with FORTIFY_SOURCE.
3
4	FORTIFY_SOURCE feature provides primitive support for detecting buffer overflows in various functions which operates on memory areas and strings. A limited set of buffer overflows can be detected with this feature, but it provides an additional level of validation for some functions which are potentially an origin of buffer overflow flaws.

Lines 356-361 Link Here

(-)b/sys/sys/stat.h (+5 lines)
356	int mknodat(int, const char *, mode_t, dev_t);	356	int mknodat(int, const char *, mode_t, dev_t);
357	#endif	357	#endif
358	__END_DECLS	358	__END_DECLS
		359
		360	#ifdef __BSD_FORTIFY
		361	#include <secure/_stat.h>
		362	#endif
		363
359	#endif /* !_KERNEL */	364	#endif /* !_KERNEL */
360		365
361	#endif /* !_SYS_STAT_H_ */	366	#endif /* !_SYS_STAT_H_ */

Lines 630-635 Link Here

(-)b/sys/sys/socket.h (+4 lines)
630	int socketpair(int, int, int, int *);	630	int socketpair(int, int, int, int *);
631	__END_DECLS	631	__END_DECLS
632		632
		633	#ifdef __BSD_FORTIFY
		634	#include <secure/_socket.h>
		635	#endif
		636
633	#endif /* !_KERNEL */	637	#endif /* !_KERNEL */
634		638
635	#ifdef _KERNEL	639	#ifdef _KERNEL

Lines 103-108 Link Here

(-)b/sys/sys/select.h (+1 lines)
103	int select(int, fd_set , fd_set , fd_set , struct timeval );	103	int select(int, fd_set , fd_set , fd_set , struct timeval );
104	#endif	104	#endif
105	__END_DECLS	105	__END_DECLS
		106
106	#endif /* !_KERNEL */	107	#endif /* !_KERNEL */
107		108
108	#endif /* _SYS_SELECT_H_ */	109	#endif /* _SYS_SELECT_H_ */

Lines 117-122 Link Here

(-)b/sys/sys/poll.h (+4 lines)
117	#endif	117	#endif
118	__END_DECLS	118	__END_DECLS
119		119
		120	#ifdef __BSD_FORTIFY
		121	#include <secure/_poll.h>
		122	#endif
		123
120	#endif /* !_KERNEL */	124	#endif /* !_KERNEL */
121		125
122	#endif /* !_SYS_POLL_H_ */	126	#endif /* !_SYS_POLL_H_ */




#define	__gnu_inline
#endif

#if __has_attribute(error) || __GNUC_PREREQ__(4, 3)
#define	__error_attr(msg)	__attribute__((__error__(msg)))
#else
#define	__error_attr(msg)
#endif

/* FORTIFY_SOURCE related defines. */
#if __GNUC_PREREQ__(4, 1) && defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 && \
    defined(__OPTIMIZE__) && __OPTIMIZE__ > 0 && !defined(lint)
#define	__BSD_FORTIFY	1
#if _FORTIFY_SOURCE >= 2
#define	__bos(s)	__builtin_object_size((s), 1)
#else
#define	__bos(s)	__builtin_object_size((s), 0)
#endif
#define	__bos0(s)	__builtin_object_size((s), 0)
#define	__FORTIFY_INLINE	extern __inline __always_inline __gnu_inline
#endif /* !_FORTIFY_SOURCE */
#define	__FORTIFY_UNKNOWN_SIZE	((size_t) -1)

/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \
    defined(__GNUC__) && !defined(__INTEL_COMPILER)

Lines 1-5 Link Here

(-)b/sys/boot/zfs/Makefile (+4 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2		2
		3	.include <bsd.opts.mk>
		4
		5	MK_FORTIFY= no
		6
3	LIB= zfsboot	7	LIB= zfsboot
4	INTERNALLIB=	8	INTERNALLIB=
5		9

Lines 2-7 Link Here

(-)b/sys/boot/sparc64/loader/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5	MAN=	6	MAN=
6		7
7	PROG?= loader	8	PROG?= loader

Lines 1-6 Link Here

(-)b/sys/boot/powerpc/uboot/Makefile (+1 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
		4	MK_FORTIFY= no
4		5
5	PROG= ubldr	6	PROG= ubldr
6	NEWVERSWHAT= "U-Boot loader" ${MACHINE_ARCH}	7	NEWVERSWHAT= "U-Boot loader" ${MACHINE_ARCH}

Lines 2-7 Link Here

(-)b/sys/boot/powerpc/ps3/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5	MAN=	6	MAN=
6		7
7	PROG= loader.ps3	8	PROG= loader.ps3

Lines 2-7 Link Here

(-)b/sys/boot/powerpc/ofw/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5	MAN=	6	MAN=
6		7
7	PROG= loader	8	PROG= loader

Lines 2-7 Link Here

(-)b/sys/boot/powerpc/kboot/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5	MAN=	6	MAN=
6		7
7	PROG= loader.kboot	8	PROG= loader.kboot

Lines 2-7 Link Here

(-)b/sys/boot/pc98/loader/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5	MAN=	6	MAN=
6		7
7	LOADER?= loader	8	LOADER?= loader

Lines 31-36 Link Here

(-)b/sys/boot/mips/beri/loader/Makefile (+1 lines)
31		31
32	.include <src.opts.mk>	32	.include <src.opts.mk>
33	MK_SSP= no	33	MK_SSP= no
		34	MK_FORTIFY= no
34	MAN=	35	MAN=
35		36
36	PROG?= loader	37	PROG?= loader

Lines 10-15 Link Here

(-)b/sys/boot/libstand32/Makefile (+1 lines)
10		10
11	.include <src.opts.mk>	11	.include <src.opts.mk>
12	MK_SSP= no	12	MK_SSP= no
		13	MK_FORTIFY= no
13		14
14	LIBSTAND_SRC= ${.CURDIR}/../../../lib/libstand	15	LIBSTAND_SRC= ${.CURDIR}/../../../lib/libstand
15	LIBC_SRC= ${LIBSTAND_SRC}/../libc	16	LIBC_SRC= ${LIBSTAND_SRC}/../libc

Lines 2-7 Link Here

(-)b/sys/boot/i386/loader/Makefile (+1 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4	MK_SSP= no	4	MK_SSP= no
		5	MK_FORTIFY= no
5		6
6	LOADER?= loader	7	LOADER?= loader
7	PROG= ${LOADER}.sym	8	PROG= ${LOADER}.sym

Lines 1-5 Link Here

(-)b/sys/boot/i386/libi386/Makefile (+5 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2	#	2	#
		3
		4	.include <bsd.opts.mk>
		5
		6	MK_FORTIFY= no
		7
3	LIB= i386	8	LIB= i386
4	INTERNALLIB=	9	INTERNALLIB=
5		10

Lines 1-6 Link Here

(-)b/sys/boot/ficl/Makefile (+4 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2	#	2	#
3		3
		4	.include <bsd.opts.mk>
		5
		6	MK_FORTIFY= no
		7
4	FICLDIR?= ${.CURDIR}	8	FICLDIR?= ${.CURDIR}
5		9
6	.if defined(FICL32)	10	.if defined(FICL32)

Lines 1-5 Link Here

(-)b/sys/boot/fdt/Makefile (+4 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2		2
		3	.include <src.opts.mk>
		4
		5	MK_FORTIFY= no
		6
3	.PATH: ${.CURDIR}/../../contrib/libfdt/	7	.PATH: ${.CURDIR}/../../contrib/libfdt/
4		8
5	LIB= fdt	9	LIB= fdt

Lines 8-13 Link Here

(-)b/sys/boot/efi/loader/Makefile (+1 lines)
8	.if ${COMPILER_TYPE} != "gcc"	8	.if ${COMPILER_TYPE} != "gcc"
9		9
10	MK_SSP= no	10	MK_SSP= no
		11	MK_FORTIFY= no
11		12
12	PROG= loader.sym	13	PROG= loader.sym
13	INTERNALPROG=	14	INTERNALPROG=

Lines 1-5 Link Here

(-)b/sys/boot/efi/libefi/Makefile (+4 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2		2
		3	.include <src.opts.mk>
		4
		5	MK_FORTIFY= no
		6
3	LIB= efi	7	LIB= efi
4	INTERNALLIB=	8	INTERNALLIB=
5		9

Lines 2-7 Link Here

(-)b/sys/boot/efi/fdt/Makefile (+2 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4		4
		5	MK_FORTIFY= no
		6
5	.PATH: ${.CURDIR}/../../common	7	.PATH: ${.CURDIR}/../../common
6		8
7	LIB= efi_fdt	9	LIB= efi_fdt

Lines 8-13 Link Here

(-)b/sys/boot/efi/boot1/Makefile (+1 lines)
8	.if ${COMPILER_TYPE} != "gcc"	8	.if ${COMPILER_TYPE} != "gcc"
9		9
10	MK_SSP= no	10	MK_SSP= no
		11	MK_FORTIFY= no
11		12
12	PROG= loader.sym	13	PROG= loader.sym
13	INTERNALPROG=	14	INTERNALPROG=

Lines 2-7 Link Here

(-)b/sys/boot/common/Makefile (+2 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4		4
		5	MK_FORTIFY= no
		6
5	MAN+= loader.8	7	MAN+= loader.8
6	.if ${MK_ZFS} != "no"	8	.if ${MK_ZFS} != "no"
7	MAN+= zfsloader.8	9	MAN+= zfsloader.8

Lines 1-3 Link Here

(-)b/sys/boot/arm64/Makefile (+4 lines)
1	# $FreeBSD$	1	# $FreeBSD$
2		2
		3	.include <src.opts.mk>
		4
		5	MK_FORTIFY= no
		6
3	.include <bsd.subdir.mk>	7	.include <bsd.subdir.mk>

Lines 2-7 Link Here

(-)b/sys/boot/arm/uboot/Makefile (+2 lines)
2		2
3	.include <src.opts.mk>	3	.include <src.opts.mk>
4		4
		5	MK_FORTIFY= no
		6
5	FILES= ubldr ubldr.bin	7	FILES= ubldr ubldr.bin
6		8
7	NEWVERSWHAT= "U-Boot loader" ${MACHINE_ARCH}	9	NEWVERSWHAT= "U-Boot loader" ${MACHINE_ARCH}

Lines 153-158 Link Here

(-)b/share/mk/bsd.sys.mk (+5 lines)
153	CFLAGS+= ${SSP_CFLAGS}	153	CFLAGS+= ${SSP_CFLAGS}
154	.endif # SSP && !ARM && !MIPS	154	.endif # SSP && !ARM && !MIPS
155		155
		156	.if ${MK_FORTIFY} != "no"
		157	FORTIFY_CFLAGS?= -D_FORTIFY_SOURCE=1
		158	CFLAGS+= ${FORTIFY_CFLAGS}
		159	.endif # FORTIFY
		160
156	# Allow user-specified additional warning flags, plus compiler specific flag overrides.	161	# Allow user-specified additional warning flags, plus compiler specific flag overrides.
157	# Unless we've overriden this...	162	# Unless we've overriden this...
158	.if ${MK_WARNS} != "no"	163	.if ${MK_WARNS} != "no"

Lines 51-56 Link Here

(-)b/share/mk/bsd.opts.mk (+1 lines)
51	__DEFAULT_YES_OPTIONS = \	51	__DEFAULT_YES_OPTIONS = \
52	ASSERT_DEBUG \	52	ASSERT_DEBUG \
53	DOCCOMPRESS \	53	DOCCOMPRESS \
		54	FORTIFY \
54	INCLUDES \	55	INCLUDES \
55	INSTALLLIB \	56	INSTALLLIB \
56	KERBEROS \	57	KERBEROS \

Lines 5-10 Link Here

(-)b/rescue/rescue/Makefile (+1 lines)
5		5
6	MAN=	6	MAN=
7	MK_SSP= no	7	MK_SSP= no
		8	MK_FORTIFY= no
8		9
9	PROG= rescue	10	PROG= rescue
10	BINDIR?=/rescue	11	BINDIR?=/rescue

Lines 4-9 Link Here

(-)b/rescue/librescue/Makefile (+1 lines)
4		4
5	.include <src.opts.mk>	5	.include <src.opts.mk>
6	MK_SSP= no	6	MK_SSP= no
		7	MK_FORTIFY= no
7		8
8	# Certain library entries have hard-coded references to	9	# Certain library entries have hard-coded references to
9	# /bin, /sbin, etc, that require those entries to be	10	# /bin, /sbin, etc, that require those entries to be

Lines 6-11 Link Here

(-)b/libexec/rtld-elf/Makefile (+1 lines)
6		6
7	.include <src.opts.mk>	7	.include <src.opts.mk>
8	MK_SSP= no	8	MK_SSP= no
		9	MK_FORTIFY= no
9		10
10	PROG?= ld-elf.so.1	11	PROG?= ld-elf.so.1
11	SRCS= rtld_start.S \	12	SRCS= rtld_start.S \

Lines 12-17 Link Here

(-)b/lib/libthr/Makefile (+1 lines)
12		12
13	.include <src.opts.mk>	13	.include <src.opts.mk>
14	MK_SSP= no	14	MK_SSP= no
		15	MK_FORTIFY= no
15		16
16	LIB=thr	17	LIB=thr
17	SHLIB_MAJOR= 3	18	SHLIB_MAJOR= 3

Lines 61-66 Link Here

(-)b/lib/libstand/stand.h (+6 lines)
61	#ifndef STAND_H	61	#ifndef STAND_H
62	#define STAND_H	62	#define STAND_H
63		63
		64	#undef _FORTIFY_SOURCE
		65	/*
		66	* Yes, this second one is a big hack.
		67	*/
		68	#undef __BSD_FORTIFY
		69
64	#include <sys/types.h>	70	#include <sys/types.h>
65	#include <sys/cdefs.h>	71	#include <sys/cdefs.h>
66	#include <sys/stat.h>	72	#include <sys/stat.h>

Lines 8-13 Link Here

(-)b/lib/libstand/Makefile (+1 lines)
8		8
9	MK_PROFILE= no	9	MK_PROFILE= no
10	MK_SSP= no	10	MK_SSP= no
		11	MK_FORTIFY= no
11		12
12	.include <src.opts.mk>	13	.include <src.opts.mk>
13		14




/*
 * Written by Alexander Kabaev <kan@FreeBSD.org>
 * The file is in public domain.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

void __stack_chk_fail(void);

#ifdef PIC
void
__stack_chk_fail_local_hidden(void)
{

	__stack_chk_fail();
}

__sym_compat(__stack_chk_fail_local, __stack_chk_fail_local_hidden, FBSD_1.0);
#endif




/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $	*/
/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $	*/
/*
 * Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <errno.h>
#include <link.h>
#include <signal.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include "libc_private.h"

extern int __sysctl(const int *name, u_int namelen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen);

long __stack_chk_guard[8] = {0, 0, 0, 0, 0, 0, 0, 0};
static void __guard_setup(void) __attribute__((__constructor__, __used__));
static void __fail(const char *);
void __stack_chk_fail(void);
void __chk_fail(void);

/*LINTED used*/
static void
__guard_setup(void)
{
	static const int mib[2] = { CTL_KERN, KERN_ARND };
	size_t len;
	int error;

	if (__stack_chk_guard[0] != 0)
		return;
	error = _elf_aux_info(AT_CANARY, __stack_chk_guard,
	    sizeof(__stack_chk_guard));
	if (error == 0 && __stack_chk_guard[0] != 0)
		return;

	len = sizeof(__stack_chk_guard);
	if (__sysctl(mib, nitems(mib), __stack_chk_guard, &len, NULL, 0) ==
	    -1 || len != sizeof(__stack_chk_guard)) {
		/* If sysctl was unsuccessful, use the "terminator canary". */
		((unsigned char *)(void *)__stack_chk_guard)[0] = 0;
		((unsigned char *)(void *)__stack_chk_guard)[1] = 0;
		((unsigned char *)(void *)__stack_chk_guard)[2] = '\n';
		((unsigned char *)(void *)__stack_chk_guard)[3] = 255;
	}
}

/*ARGSUSED*/
static void
__fail(const char *msg)
{
	struct sigaction sa;
	sigset_t mask;

	/* Immediately block all signal handlers from running code */
	(void)sigfillset(&mask);
	(void)sigdelset(&mask, SIGABRT);
	(void)sigprocmask(SIG_BLOCK, &mask, NULL);

	/* This may fail on a chroot jail... */
	syslog(LOG_CRIT, "%s", msg);

	(void)memset(&sa, 0, sizeof(sa));
	(void)sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sa.sa_handler = SIG_DFL;
	(void)sigaction(SIGABRT, &sa, NULL);
	(void)kill(getpid(), SIGABRT);
	_exit(127);
}

void
__stack_chk_fail(void)
{
	__fail("stack overflow detected; terminated");
}

void
__chk_fail(void)
{
	__fail("buffer overflow detected; terminated");
}

#ifndef PIC
__weak_reference(__stack_chk_fail, __stack_chk_fail_local);
#endif

Lines 30-35 Link Here

(-)b/lib/libc/sys/readv.c (+1 lines)
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/	31	*/
32		32
		33	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	34	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	35	__FBSDID("$FreeBSD$");
35		36

Lines 30-35 Link Here

(-)b/lib/libc/sys/read.c (+1 lines)
30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	30	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31	*/	31	*/
32		32
		33	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	34	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	35	__FBSDID("$FreeBSD$");
35		36

Lines 56-62 Link Here

(-)b/lib/libc/sys/Symbol.map (-3 lines)
56	bind;	56	bind;
57	chdir;	57	chdir;
58	chflags;	58	chflags;
59	__chk_fail;
60	chmod;	59	chmod;
61	chown;	60	chown;
62	chroot;	61	chroot;
Lines 281-288 Link Here
281	sigwaitinfo;	280	sigwaitinfo;
282	socket;	281	socket;
283	socketpair;	282	socketpair;
284	__stack_chk_fail;
285	__stack_chk_guard;
286	stat;	283	stat;
287	statfs;	284	statfs;
288	swapoff;	285	swapoff;

Lines 21-28 Link Here

(-)b/lib/libc/sys/Makefile.inc (-2 lines)
21		21
22	# Sources common to both syscall interfaces:	22	# Sources common to both syscall interfaces:
23	SRCS+= \	23	SRCS+= \
24	stack_protector.c \
25	stack_protector_compat.c \
26	__error.c \	24	__error.c \
27	interposing_table.c	25	interposing_table.c
28		26

Lines 30-35 Link Here

(-)b/lib/libc/string/strrchr.c (+2 lines)
30	#if defined(LIBC_SCCS) && !defined(lint)	30	#if defined(LIBC_SCCS) && !defined(lint)
31	static char sccsid[] = "@(#)rindex.c 8.1 (Berkeley) 6/4/93";	31	static char sccsid[] = "@(#)rindex.c 8.1 (Berkeley) 6/4/93";
32	#endif /* LIBC_SCCS and not lint */	32	#endif /* LIBC_SCCS and not lint */
		33
		34	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	36	__FBSDID("$FreeBSD$");
35		37

Lines 24-29 Link Here

(-)b/lib/libc/string/strlen.c (+1 lines)
24	* SUCH DAMAGE.	24	* SUCH DAMAGE.
25	*/	25	*/
26		26
		27	#undef _FORTIFY_SOURCE
27	#include <sys/cdefs.h>	28	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");	29	__FBSDID("$FreeBSD$");
29		30

Lines 16-21 Link Here

(-)b/lib/libc/string/strlcpy.c (+1 lines)
16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.	16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17	*/	17	*/
18		18
		19	#undef _FORTIFY_SOURCE
19	#include <sys/cdefs.h>	20	#include <sys/cdefs.h>
20	__FBSDID("$FreeBSD$");	21	__FBSDID("$FreeBSD$");
21		22

Lines 16-21 Link Here

(-)b/lib/libc/string/strlcat.c (+1 lines)
16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.	16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17	*/	17	*/
18		18
		19	#undef _FORTIFY_SOURCE
19	#include <sys/cdefs.h>	20	#include <sys/cdefs.h>
20	__FBSDID("$FreeBSD$");	21	__FBSDID("$FreeBSD$");
21		22

Lines 25-30 Link Here

(-)b/lib/libc/string/strchrnul.c (+1 lines)
25	*	25	*
26	*/	26	*/
27		27
		28	#undef _FORTIFY_SOURCE
28	#include <sys/cdefs.h>	29	#include <sys/cdefs.h>
29	__FBSDID("$FreeBSD$");	30	__FBSDID("$FreeBSD$");
30		31

Lines 30-35 Link Here

(-)b/lib/libc/string/strchr.c (+2 lines)
30	#if defined(LIBC_SCCS) && !defined(lint)	30	#if defined(LIBC_SCCS) && !defined(lint)
31	static char sccsid[] = "@(#)index.c 8.1 (Berkeley) 6/4/93";	31	static char sccsid[] = "@(#)index.c 8.1 (Berkeley) 6/4/93";
32	#endif /* LIBC_SCCS and not lint */	32	#endif /* LIBC_SCCS and not lint */
		33
		34	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	36	__FBSDID("$FreeBSD$");
35		37

Lines 24-29 Link Here

(-)b/lib/libc/string/stpncpy.c (+1 lines)
24	* SUCH DAMAGE.	24	* SUCH DAMAGE.
25	*/	25	*/
26		26
		27	#undef _FORTIFY_SOURCE
27	#include <sys/cdefs.h>	28	#include <sys/cdefs.h>
28	__FBSDID("$FreeBSD$");	29	__FBSDID("$FreeBSD$");
29		30

Lines 33-38 Link Here

(-)b/lib/libc/string/memset.c (+1 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)memset.c 8.1 (Berkeley) 6/4/93";	34	static char sccsid[] = "@(#)memset.c 8.1 (Berkeley) 6/4/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36	#undef _FORTIFY_SOURCE
36	#include <sys/cdefs.h>	37	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	38	__FBSDID("$FreeBSD$");
38		39

Lines 33-38 Link Here

(-)b/lib/libc/string/memchr.c (+2 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)memchr.c 8.1 (Berkeley) 6/4/93";	34	static char sccsid[] = "@(#)memchr.c 8.1 (Berkeley) 6/4/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36
		37	#undef _FORTIFY_SOURCE
36	#include <sys/cdefs.h>	38	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	39	__FBSDID("$FreeBSD$");
38		40

Lines 30-35 Link Here

(-)b/lib/libc/string/memccpy.c (+2 lines)
30	#if defined(LIBC_SCCS) && !defined(lint)	30	#if defined(LIBC_SCCS) && !defined(lint)
31	static char sccsid[] = "@(#)memccpy.c 8.1 (Berkeley) 6/4/93";	31	static char sccsid[] = "@(#)memccpy.c 8.1 (Berkeley) 6/4/93";
32	#endif /* LIBC_SCCS and not lint */	32	#endif /* LIBC_SCCS and not lint */
		33
		34	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	36	__FBSDID("$FreeBSD$");
35		37

Lines 1-3 Link Here

(-)b/lib/libc/string/bzero.c (+1 lines)
		1	#undef _FORTIFY_SOURCE
1	#include <sys/cdefs.h>	2	#include <sys/cdefs.h>
2	__FBSDID("$FreeBSD$");	3	__FBSDID("$FreeBSD$");
3		4

Lines 38-43 Link Here

(-)b/lib/libc/stdio/vsnprintf.c (+2 lines)
38	#if defined(LIBC_SCCS) && !defined(lint)	38	#if defined(LIBC_SCCS) && !defined(lint)
39	static char sccsid[] = "@(#)vsnprintf.c 8.1 (Berkeley) 6/4/93";	39	static char sccsid[] = "@(#)vsnprintf.c 8.1 (Berkeley) 6/4/93";
40	#endif /* LIBC_SCCS and not lint */	40	#endif /* LIBC_SCCS and not lint */
		41
		42	#undef _FORTIFY_SOURCE
41	#include <sys/cdefs.h>	43	#include <sys/cdefs.h>
42	__FBSDID("$FreeBSD$");	44	__FBSDID("$FreeBSD$");
43		45

Lines 38-43 Link Here

(-)b/lib/libc/stdio/sprintf.c (+1 lines)
38	#if defined(LIBC_SCCS) && !defined(lint)	38	#if defined(LIBC_SCCS) && !defined(lint)
39	static char sccsid[] = "@(#)sprintf.c 8.1 (Berkeley) 6/4/93";	39	static char sccsid[] = "@(#)sprintf.c 8.1 (Berkeley) 6/4/93";
40	#endif /* LIBC_SCCS and not lint */	40	#endif /* LIBC_SCCS and not lint */
		41	#undef _FORTIFY_SOURCE
41	#include <sys/cdefs.h>	42	#include <sys/cdefs.h>
42	__FBSDID("$FreeBSD$");	43	__FBSDID("$FreeBSD$");
43		44

Lines 38-43 Link Here

(-)b/lib/libc/stdio/snprintf.c (+2 lines)
38	#if defined(LIBC_SCCS) && !defined(lint)	38	#if defined(LIBC_SCCS) && !defined(lint)
39	static char sccsid[] = "@(#)snprintf.c 8.1 (Berkeley) 6/4/93";	39	static char sccsid[] = "@(#)snprintf.c 8.1 (Berkeley) 6/4/93";
40	#endif /* LIBC_SCCS and not lint */	40	#endif /* LIBC_SCCS and not lint */
		41
		42	#undef _FORTIFY_SOURCE
41	#include <sys/cdefs.h>	43	#include <sys/cdefs.h>
42	__FBSDID("$FreeBSD$");	44	__FBSDID("$FreeBSD$");
43		45

Lines 33-38 Link Here

(-)b/lib/libc/stdio/gets.c (+1 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)gets.c 8.1 (Berkeley) 6/4/93";	34	static char sccsid[] = "@(#)gets.c 8.1 (Berkeley) 6/4/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36
36	#include <sys/cdefs.h>	37	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	38	__FBSDID("$FreeBSD$");
38		39

Lines 33-38 Link Here

(-)b/lib/libc/stdio/fwrite.c (+2 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)fwrite.c 8.1 (Berkeley) 6/4/93";	34	static char sccsid[] = "@(#)fwrite.c 8.1 (Berkeley) 6/4/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36
		37	#undef _FORTIFY_SOURCE
36	#include <sys/cdefs.h>	38	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	39	__FBSDID("$FreeBSD$");
38		40

Lines 33-38 Link Here

(-)b/lib/libc/stdio/fread.c (+2 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)fread.c 8.2 (Berkeley) 12/11/93";	34	static char sccsid[] = "@(#)fread.c 8.2 (Berkeley) 12/11/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36
		37	#undef _FORTIFY_SOURCE
36	#include <sys/cdefs.h>	38	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	39	__FBSDID("$FreeBSD$");
38		40

Lines 33-38 Link Here

(-)b/lib/libc/stdio/fgets.c (+2 lines)
33	#if defined(LIBC_SCCS) && !defined(lint)	33	#if defined(LIBC_SCCS) && !defined(lint)
34	static char sccsid[] = "@(#)fgets.c 8.2 (Berkeley) 12/22/93";	34	static char sccsid[] = "@(#)fgets.c 8.2 (Berkeley) 12/22/93";
35	#endif /* LIBC_SCCS and not lint */	35	#endif /* LIBC_SCCS and not lint */
		36
		37	#undef _FORTIFY_SOURCE
36	#include <sys/cdefs.h>	38	#include <sys/cdefs.h>
37	__FBSDID("$FreeBSD$");	39	__FBSDID("$FreeBSD$");
38		40




/*
 * Written by Alexander Kabaev <kan@FreeBSD.org>
 * The file is in public domain.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

void __stack_chk_fail(void);

#ifdef PIC
void
__stack_chk_fail_local_hidden(void)
{

	__stack_chk_fail();
}

__sym_compat(__stack_chk_fail_local, __stack_chk_fail_local_hidden, FBSD_1.0);
#endif




/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $	*/
/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $	*/
/*
 * Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <secure/security.h>
#include <link.h>
#include "libc_private.h"

extern int __sysctl(const int *name, u_int namelen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen);

long __stack_chk_guard[8] = {0, 0, 0, 0, 0, 0, 0, 0};
static void __guard_setup(void) __attribute__((__constructor__, __used__));
void __stack_chk_fail(void) __dead2;

/*LINTED used*/
static void
__guard_setup(void)
{
	static const int mib[2] = { CTL_KERN, KERN_ARND };
	size_t len;
	int error;

	if (__stack_chk_guard[0] != 0)
		return;
	error = _elf_aux_info(AT_CANARY, __stack_chk_guard,
	    sizeof(__stack_chk_guard));
	if (error == 0 && __stack_chk_guard[0] != 0)
		return;

	len = sizeof(__stack_chk_guard);
	if (__sysctl(mib, nitems(mib), __stack_chk_guard, &len, NULL, 0) ==
	    -1 || len != sizeof(__stack_chk_guard)) {
		/* If sysctl was unsuccessful, use the "terminator canary". */
		((unsigned char *)(void *)__stack_chk_guard)[0] = 0;
		((unsigned char *)(void *)__stack_chk_guard)[1] = 0;
		((unsigned char *)(void *)__stack_chk_guard)[2] = '\n';
		((unsigned char *)(void *)__stack_chk_guard)[3] = 255;
	}
}

void
__stack_chk_fail(void)
{

	__secure_fail("stack overflow detected; terminated");
}

void
__chk_fail(void)
{

	__secure_fail("buffer overflow detected; terminated");
}

#ifndef PIC
__weak_reference(__stack_chk_fail, __stack_chk_fail_local);
#endif




/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $	*/
/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $	*/
/*
 * Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <errno.h>
#include <link.h>
#include <signal.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include "libc_private.h"

static void __fail(const char *) __dead2;

/*ARGSUSED*/
static void
__fail(const char *msg)
{
	struct sigaction sa;
	sigset_t mask;

	/* Immediately block all signal handlers from running code */
	(void)sigfillset(&mask);
	(void)sigdelset(&mask, SIGABRT);
	(void)sigprocmask(SIG_BLOCK, &mask, NULL);

	/* This may fail on a chroot jail... */
	syslog(LOG_CRIT, "%s", msg);

	(void)memset(&sa, 0, sizeof(sa));
	(void)sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sa.sa_handler = SIG_DFL;
	(void)sigaction(SIGABRT, &sa, NULL);
	(void)kill(getpid(), SIGABRT);
	_exit(127);
}

void
__secure_fail(const char *msg)
{

	__fail(msg);
}




/*-
 * Copyright (c) 2015 Olivér Pintér <op@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include "secure/security.h"

void
__fortify_chk_fail(const char* msg)
{

	__secure_fail(msg);
}

int
__fortify_chk_overlap(const void *a, const void *b, size_t len)
{

	return ((a <= b && b <= a + len) || (b <= a && a <= b + len));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "secure/_stdio.h"

int
__vsprintf_chk(char * __restrict d, int flags, size_t bos, const char * __restrict fmt, __va_list va)
{
	int result;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (vsprintf(d, fmt, va));

	result = vsnprintf(d, bos, fmt, va);
	if ((size_t)result >= bos)
		__fortify_chk_fail(
		    "vsprintf: prevented write past end of buffer");

	return (result);
}


int
__sprintf_chk(char * __restrict d, int flags, size_t bos, const char * __restrict fmt, ...)
{
	va_list va;
	int result;

	if (bos == __FORTIFY_UNKNOWN_SIZE) {
		va_start(va, fmt);
		result = vsprintf(d, fmt, va);
		va_end(va);

		return (result);
	}

	va_start(va, fmt);
	result = __vsprintf_chk(d, flags, bos, fmt, va);
	va_end(va);

	return (result);
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "secure/_stdio.h"

int
__vsnprintf_chk(char *d, size_t n, int flags, size_t bos, const char *fmt, va_list va)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (vsnprintf(d, n, fmt, va));

	if (__predict_false(n > bos))
		__fortify_chk_fail(
		    "vsnprintf: prevented write past end of buffer");

	return (vsnprintf(d, n, fmt, va));
}


int
__snprintf_chk(char *d, size_t n, int flags, size_t bos, const char *fmt, ...)
{
	va_list va;
	int result;

	if (bos == __FORTIFY_UNKNOWN_SIZE) {
		va_start(va, fmt);
		result = vsnprintf(d, n, fmt, va);
		va_end(va);

		return (result);
	}

	va_start(va, fmt);
	result = __vsnprintf_chk(d, n, flags, bos, fmt, va);
	va_end(va);

	return (result);
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include "secure/_stat.h"

/*
 * Validate that umask is called with sane mode.
 */
mode_t 
__umask_chk(mode_t mode)
{

	if (__predict_false((mode & 0777) != mode))
		__fortify_chk_fail("umask: called with invalid mask");

	return (umask(mode));
}




/*-
 * Copyright (c) 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include "secure/_string.h"

char *
__strrchr_chk(const char *p, int ch, size_t bos)
{
	char *save;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strrchr(p, ch));

	for (save = NULL;; ++p, bos--) {
		if (bos == 0)
			__fortify_chk_fail(
			    "strrchr: prevented read past end of buffer");
		if (*p == (char)ch)
			save = (char *)p;
		if (!*p)
			return (save);
	}
	/* NOTREACHED */
}

__weak_reference(__strrchr_chk, __rindex_chk);





/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__strncpy_chk(char *__restrict d, const char *__restrict s, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strncpy(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail(
		    "strncpy: prevented write past end of buffer");

	return (strncpy(d, s, n));
}

/*
 * __strncpy_chk2
 *
 * This is a variant of __strncpy_chk, but it also checks to make
 * sure we don't read beyond the end of "src". The code for this is
 * based on the original version of strncpy, but modified to check
 * how much we read from "src" at the end of the copy operation.
 */
char *
__strncpy_chk2(char *__restrict d, const char *__restrict s, size_t n, size_t d_bos, size_t s_bos)
{
	size_t s_copy_len;

	if (__predict_false(d_bos == __FORTIFY_UNKNOWN_SIZE))
		return (strncpy(d, s, n));

	if (__predict_false(s_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strncpy_chk(d, s, n, d_bos));

	if (__predict_false(n > d_bos))
		__fortify_chk_fail("strncpy: prevented write past end of buffer");

	if (n != 0) {
		char *_d = d;
		const char *_s = s;

		do {
			if ((*_d++ = *_s++) == 0) {
				/* NUL pad the remaining n-1 bytes */
				while (--n != 0)
					*_d++ = 0;
				break;
			}
		} while (--n != 0);

		s_copy_len = (size_t)(_s - s);

		if (__predict_false(s_copy_len > s_bos))
			__fortify_chk_fail("strncpy: prevented read past end of buffer");
	}

	return (d);
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__strncat_chk(char *__restrict d, const char *__restrict s, size_t n, size_t bos)
{
	size_t d_len;
	char *_d;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strncat(d, s, n));

	if (n == 0)
		return (d);

	d_len = __strlen_chk(d, bos);
	_d = d + d_len;
	bos -= d_len;

	while (*s != '\0') {
		*_d++ = *s++;
		n--;
		bos--;

		if (__predict_false(bos == 0))
			__fortify_chk_fail("strncat: prevented write past end of buffer");
		if (n == 0)
			break;
	}
	*_d = '\0';

	return (d);
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

/*
 * This test is designed to detect code such as:
 *
 * int main() {
 *   char buf[10];
 *   memcpy(buf, "1234567890", sizeof(buf));
 *   size_t len = strlen(buf); // segfault here with _FORTIFY_SOURCE
 *   printf("%d\n", len);
 *   return 0;
 * }
 *
 * or anytime strlen reads beyond an object boundary.
 */
size_t
__strlen_chk(const char *s, size_t bos)
{
	size_t ret;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strlen(s));

	ret = strlen(s);
	if (__predict_false(ret >= bos))
		__fortify_chk_fail("strlen: prevented read past end of buffer");

	return (ret);
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

size_t
__strlcpy_chk(char *d, const char *s, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strlcpy(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("strlcpy: prevented write past end of buffer");

	return (strlcpy(d, s, n));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

size_t
__strlcat_chk(char *d, const char *s, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strlcat(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("strlcat: prevented write past end of buffer");

	return (strlcat(d, s, n));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__strcpy_chk(char *d, const char *s, size_t bos)
{
	/* TODO: optimize so we don't scan s twice. */
	size_t s_len;

	/*
	 * Compiler doesn 't know destination size.
	 * Fallback to the original function.
	 */
	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strcpy(d, s));

	s_len = strlen(s) + 1;
	if (__predict_false(s_len > bos))
		__fortify_chk_fail("strcpy: prevented write past end of buffer");

	return (strcpy(d, s));
}




/*-
 * Copyright (c) 2015 Pinter Oliver
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include "secure/_string.h"

char *
__strchrnul_chk(const char *p, int ch, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strchrnul(p, ch));

	for (;; ++p, bos--) {
		if (__predict_false(bos == 0))
			__fortify_chk_fail(
			    "strchrnul: prevented read past end of buffer");
		if (*p == (char)(ch))
			return ((char *)(p));
		if (*p == '\0')
			return ((char *)(p));
	}
	/* NOTREACHED */
}




/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include "secure/_string.h"

char *
__strchr_chk(const char *p, int ch, size_t bos)
{
	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (strchr(p, ch));

	for (;; ++p, bos--) {
		if (__predict_false(bos == 0))
			__fortify_chk_fail("strchr: prevented read past end of buffer");
		if (*p == (char)(ch))
			return ((char *)(p));
		if (*p == '\0')
			return (NULL);
	}
	/* NOTREACHED */
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__strcat_chk(char *__restrict d, const char *__restrict s, size_t bos)
{
	char *save = d;
	size_t d_len;

	/*
	 * Compiler doesn 't know destination size.
	 * Fallback to the original function.
	 */
	if (bos == __FORTIFY_UNKNOWN_SIZE)
		return (strcat(d, s));

	d_len = __strlen_chk(d, bos);

	d += d_len;
	bos -= d_len;

	while ((*d++ = *s++) != '\0') {
		bos--;
		if (__predict_false(bos == 0))
			__fortify_chk_fail("strcat: prevented write past end of buffer");
	}

	return (save);
}




/*-
 * Copyright (C) 2014 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */


#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__stpncpy_chk(char *__restrict d, const char *__restrict s, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (stpncpy(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("stpncpy: prevented write past end of buffer");

	return stpncpy(d, s, n);
}

/*
 * __stpncpy_chk2
 *
 * This is a variant of __stpncpy_chk, but it also checks to make
 * sure we don't read beyond the end of "s". The code for this is
 * based on the original version of stpncpy, but modified to check
 * how much we read from "s" at the end of the copy operation.
 */
char *
__stpncpy_chk2(char *__restrict d, const char *__restrict s, size_t n, size_t d_bos, size_t s_bos)
{
	char *_d;
	const char *_s = s;
	size_t s_copy_len ;

	if (__predict_false(d_bos == __FORTIFY_UNKNOWN_SIZE))
		return (stpncpy(d, s, n));

	if (__predict_false(s_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__stpncpy_chk(d, s, n, d_bos));

	if (__predict_false(n > d_bos))
		__fortify_chk_fail("stpncpy: prevented write past end of buffer");

	if (n != 0) {
		_d = d;

		do {
			if ((*_d++ = *_s++) == 0) {
				/* NUL pad the remaining n-1 bytes */
				while (--n != 0)
					*_d++ = 0;
				break;
			}
		} while (--n != 0);

		s_copy_len = (size_t)(_s - s);

		if (__predict_false(s_copy_len > s_bos))
			__fortify_chk_fail("stpncpy: prevented read past end of buffer");
	}

	return (d);
}




/*-
 * Copyright (C) 2014 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

char *
__stpcpy_chk(char *dest, const char *src, size_t bos)
{
	/* TODO:optimize so we don't scan src twice. */
	size_t src_len;

	/*
	 * Compiler doesn 't know destination size.
	 * Fallback to the original function.
	 */
	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (stpcpy(dest, src));

	src_len = strlen(src) + 1;
	if (__predict_false(src_len > bos))
		__fortify_chk_fail("stpcpy: prevented write past end of buffer");

	return (stpcpy(dest, src));
}




/*-
 * Copyright (C) 2013 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <sys/socket.h>
#include <secure/security.h>
#include "secure/_socket.h"

ssize_t 
__recvfrom_chk(int s, void *buf, size_t len, size_t bos,
    int flags, struct sockaddr * __restrict from,
    socklen_t * __restrict fromlen)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (recvfrom(s, buf, len, flags, from, fromlen));

	if (__predict_false(len > bos))
		__fortify_chk_fail("recvfrom: prevented write past end of buffer");

	return (recvfrom(s, buf, len, flags, from, fromlen));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <sys/limits.h>
#include <secure/security.h>
#include <unistd.h>
#include "secure/_unistd.h"

ssize_t
__readlinkat_chk(int dirfd, const char *path, char *buf, size_t size, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (readlinkat(dirfd, path, buf, size));

	if (__predict_false(size > bos))
		__fortify_chk_fail("readlinkat: prevented write past end of buffer");

	if (__predict_false(size > SSIZE_MAX))
		__fortify_chk_fail("readlinkat: size > SSIZE_MAX");

	return (readlinkat(dirfd, path, buf, size));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <sys/limits.h>
#include <secure/security.h>
#include <unistd.h>
#include "secure/_unistd.h"

ssize_t
__readlink_chk(const char *path, char *buf, size_t size, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (readlink(path, buf, size));

	if (__predict_false(size > bos))
		__fortify_chk_fail("readlink: prevented write past end of buffer");

	if (__predict_false(size > SSIZE_MAX))
		__fortify_chk_fail("readlink: size > SSIZE_MAX");

	return (readlink(path, buf, size));
}




/*-
 * Copyright (C) 2013 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * rev: a8993c994e45ec2dc00dcef15910560e22d67be9
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <sys/limits.h>
#include <secure/security.h>
#include <unistd.h>
#include "secure/_unistd.h"

ssize_t
__read_chk(int fd, void *buf, size_t count, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (read(fd, buf, count));

	if (__predict_false(count > bos))
		__fortify_chk_fail("read: prevented write past end of buffer");

	if (__predict_false(count > SSIZE_MAX))
		__fortify_chk_fail("read: count > SSIZE_MAX");

	return (read(fd, buf, count));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <sys/limits.h>
#include <secure/security.h>
#include <unistd.h>
#include "secure/_unistd.h"

ssize_t
__pread_chk(int fd, void *buf, size_t count, off_t offset, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (pread(fd, buf, count, offset));

	if (__predict_false(count > bos))
		__fortify_chk_fail("pread: prevented write past end of buffer");

	if (__predict_false(count > SSIZE_MAX))
		__fortify_chk_fail("pread: count > SSIZE_MAX");

	return (pread(fd, buf, count, offset));
}




/*
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: eeb9f5e41662828989f3913d81ec23229a668434
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <sys/poll.h>
#include "secure/_poll.h"

int
__poll_chk(struct pollfd *fds, nfds_t fd_count, int timeout, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (poll(fds, fd_count, timeout));

	if (__predict_false(bos / sizeof(*fds) < fd_count))
		__fortify_chk_fail("poll: pollfd array smaller than fd count");

	return (poll(fds, fd_count, timeout));
}

int
__ppoll_chk(struct pollfd *fds, nfds_t fd_count, const struct timespec *timeout, const sigset_t *mask, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (ppoll(fds, fd_count, timeout, mask));

	if (__predict_false(bos / sizeof(*fds) < fd_count))
		__fortify_chk_fail("ppoll: pollfd array smaller than fd count");

	return (ppoll(fds, fd_count, timeout, mask));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

void *
__memset_chk(void *d, int c, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return memset(d, c, n);

	if (__predict_false(n > bos))
		__fortify_chk_fail("memset: prevented write past end of buffer");

	return memset(d, c, n);
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include "secure/_string.h"

void *
__memrchr_chk(const void *s, int c, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (memrchr(s, c, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("memrchr: prevented read past end of buffer");

	return (memrchr(s, c, n));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

void *
__memmove_chk(void *d, const void *s, size_t n, size_t bos)
{

	/*
	 * Compiler doesn 't know dination size.
	 * Fallback to the original function.
	 */
	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (memmove(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("memmove: prevented write past end of buffer");

	return (memmove(d, s, n));
}




/*-
 * Copyright (C) 2015 Oliver Pinter
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

void *
__memcpy_chk(void *d, const void *s, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (memcpy(d, s, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("memcpy: prevented write past end of buffer");

	/* See the memcpy(3) for more details. */
	if (__predict_false(__fortify_chk_overlap(d, s, n)))
		__fortify_chk_fail("memcpy: prevented overlaping strings");

	return (memcpy(d, s, n));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include "secure/_string.h"

void *
__memchr_chk(const void *s, int c, size_t n, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (memchr(s, c, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail(
		    "memchr: prevented read past end of buffer");

	return (memchr(s, c, n));
}




/*-
 * Copyright (C) 2015 Oliver Pinter
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <string.h>
#include <stdlib.h>
#include "secure/_string.h"

void *
__memccpy_chk(void *dest, const void *src, int c, size_t n, size_t bos)
{
	void *ret;
	size_t len;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (memccpy(dest, src, c, n));

	if (__predict_false(n > bos))
		__fortify_chk_fail("memccpy: prevented write past end of buffer");

	/*
	 * If n was copied, then return NULL, otherwise
	 * a pointer to the byte after the copy of c in the string
	 * dest is returned.
	 *
	 * See the memccpy(3) manpage for more details.
	 */
	ret = memccpy(dest, src, c, n);
	if (ret != NULL)
		len = ret - dest;

	if (__predict_false(__fortify_chk_overlap(dest, src, len)))
		__fortify_chk_fail("memccpy: prevented overlapping strings");

	return (ret);
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 7e919daeaad62515ebbbf7b06badc77625a14d90
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <unistd.h>
#include "secure/_unistd.h"

char *
__getcwd_chk(char* buf, size_t size, size_t bos)
{

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (getcwd(buf, size));

	if (__predict_false(size > bos))
		__fortify_chk_fail("getcwd: prevented write past end of buffer");

	return (getcwd(buf, size));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: fed2659869ec41a93f655be8058568ddab419e01
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE
#include <sys/cdefs.h>
#include <secure/security.h>
#include <stdio.h>
#include "secure/_stdio.h"

size_t
__fwrite_chk(const void * __restrict ptr, size_t size, size_t nmemb, FILE * __restrict stream, size_t bos)
{
	size_t total;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (fwrite(ptr, size, nmemb, stream));

	if (__predict_false(__size_mul_overflow(size, nmemb, &total))) {
		// overflow: trigger the error path in fwrite
		return (fwrite(ptr, size, nmemb, stream));
	}

	if (__predict_false(total > bos))
		__fortify_chk_fail("fwrite: prevented read past end of buffer");

	return (fwrite(ptr, size, nmemb, stream));
}




/*-
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: fed2659869ec41a93f655be8058568ddab419e01
 *
 * $FreeBSD$
 */

#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <stdio.h>
#include "secure/_stdio.h"

size_t
__fread_chk(void *__restrict ptr, size_t size, size_t nmemb, FILE * __restrict stream, size_t bos)
{
	size_t total;

	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
		return (fread(ptr, size, nmemb, stream));

	if (__predict_false(__size_mul_overflow(size, nmemb, &total))) {
		//overflow: trigger the error path in fread
		return (fread(ptr, size, nmemb, stream));
	}
	if (__predict_false(total > bos))
		__fortify_chk_fail("fread: prevented write past end of buffer");

	return (fread(ptr, size, nmemb, stream));
}




/*-
 * Copyright (C) 2012 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299 
 *
 * $FreeBSD$
 */


#undef _FORTIFY_SOURCE

#include <sys/cdefs.h>
#include <secure/security.h>
#include <stdio.h>
#include <stdlib.h>
#include "secure/_stdio.h"

char *
__fgets_chk(char *buf, int n, FILE *stream, size_t bos)
{

	if (bos == __FORTIFY_UNKNOWN_SIZE)
		return (fgets(buf, n, stream));

	if (n < 0)
		__fortify_chk_fail("fgets: buffer size < 0");

	if (((size_t)n) > bos)
		__fortify_chk_fail("fgets: prevented write past end of buffer");

	return (fgets(buf, n, stream));
}




.\"	$NetBSD: __builtin_object_size.3,v 1.10 2012/07/19 06:44:12 wiz Exp $
.\"
.\" Copyright (c) 2007 The NetBSD Foundation, Inc.
.\" All rights reserved.
.\"
.\" This code is derived from software contributed to The NetBSD Foundation
.\" by Christos Zoulas.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
.\" ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
.\" TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
.\" PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
.\" BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
.\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
.\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
.\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
.\" POSSIBILITY OF SUCH DAMAGE.
.\"
.\"
.Dd July 18, 2012
.Dt __BUILTIN_OBJECT_SIZE 3
.Os
.Sh NAME
.Nm __builtin_object_size
.Nd return the size of the given object
.Sh SYNOPSIS
.Ft size_t
.Fn __builtin_object_size "void *ptr" "int type"
.Sh DESCRIPTION
The
.Fn __builtin_object_size
function is a
.Xr gcc 1
built-in function that returns the size of the
.Fa ptr
object if known at compile time and the object does not have any side
effects.
.Sh RETURN VALUES
If the size of the object is not known or it has side effects the
.Fn __builtin_object_size
function returns:
.Bl -tag -width (size_t)\-1 -offset indent
.It Dv (size_t)\-1
for
.Fa type
.Dv 0
and
.Dv 1 .
.It Dv (size_t)0
for
.Fa type
.Dv 2
and
.Dv 3 .
.El
.Pp
If the size of the object is known, then the
.Fn __builtin_object_size
function returns the maximum size of all the objects that the compiler
knows that they can be pointed to by
.Fa ptr
when
.Fa type
.Dv \*[Am] 2 == 0 ,
and the minimum size when
.Fa type
.Dv \*[Am] 2 != 0 .
.Sh SEE ALSO
.Xr gcc 1 ,
.Xr __builtin_return_address 3 ,
.Xr attribute 3 ,
.Xr ssp 3
.Sh HISTORY
The
.Fn __builtin_object_size
appeared in
.Tn GCC 4.1 .
.Sh CAVEATS
This is a non-standard, compiler-specific extension.
.Pp
Note that currently the object size calculation pass is only done at -O1
or above, meaning that this function always returns \-1 when the optimizer
is off.
.Pp
There are some discussions about always doing the object size pass, but
the issue is that without the optimization pass data sizes are not going
to be correct.
.Pp
For that reason currently code fortification (size-checked replacement
functions) is disabled when optimization is off.




/*
 * $FreeBSD$
 */

/*
 * It'd be nice to have this automatically generated, but we don't
 * know to what version they will eventually belong, so for now
 * it has to be manual.
 */
FBSD_1.0 {
	__chk_fail;
	__stack_chk_fail;
	__stack_chk_guard;
};

FBSD_1.1 {
};

FBSD_1.2 {
};

FBSD_1.3 {
};

FBSD_1.4 {
	__fgets_chk;
	__fortify_chk_fail;
	__fread_chk;
	__fwrite_chk;
	__getcwd_chk;
	__memccpy_chk;
	__memchr_chk;
	__memcpy_chk;
	__memmove_chk;
	__memrchr_chk;
	__memset_chk;
	__poll_chk;
	__ppoll_chk;
	__pread_chk;
	__read_chk;
	__readlink_chk;
	__readlinkat_chk;
	__recvfrom_chk;
	__rindex_chk;
	__snprintf_chk;
	__sprintf_chk;
	__stpcpy_chk;
	__stpncpy_chk;
	__stpncpy_chk2;
	__strcat_chk;
	__strchr_chk;
	__strchrnul_chk;
	__strcpy_chk;
	__strlcat_chk;
	__strlcpy_chk;
	__strlen_chk;
	__strncat_chk;
	__strncpy_chk;
	__strncpy_chk2;
	__strrchr_chk;
	__umask_chk;
	__vsnprintf_chk;
	__vsprintf_chk;
	__secure_fail;
};

FBSDprivate_1.0 {
};




# secure sources
.PATH: ${LIBC_SRCTOP}/secure

# Sources common to both syscall interfaces:
SRCS+=	\
	fortify_source.c \
	secure_common.c \
	stack_protector.c \
	stack_protector_compat.c

# Sources which contains FORTIFY_SOURCE functions:
SRCS+=	\
	__fgets_chk.c \
	__fread_chk.c \
	__fwrite_chk.c \
	__getcwd_chk.c \
	__memccpy_chk.c \
	__memchr_chk.c \
	__memcpy_chk.c \
	__memmove_chk.c \
	__memrchr_chk.c \
	__memset_chk.c \
	__pread_chk.c \
	__read_chk.c \
	__readlink_chk.c \
	__readlinkat_chk.c \
	__stpcpy_chk.c \
	__stpncpy_chk.c \
	__strcat_chk.c \
	__strchr_chk.c \
	__strchrnul_chk.c \
	__strcpy_chk.c \
	__strlcat_chk.c \
	__strlcpy_chk.c \
	__strlen_chk.c \
	__strncat_chk.c \
	__strncpy_chk.c \
	__strrchr_chk.c \
	__vsnprintf_chk.c \
	__vsprintf_chk.c

# Sources which contains FORTIFY_SOURCE functions,
# but live in .h files under sys/sys
SRCS+=	\
	__poll_chk.c \
	__recvfrom_chk.c \
	__umask_chk.c

SYM_MAPS+=    ${LIBC_SRCTOP}/secure/Symbol.map

MAN+=   __builtin_object_size.3


Lines 30-35 Link Here

(-)b/lib/libc/gen/getcwd.c (+2 lines)
30	#if defined(LIBC_SCCS) && !defined(lint)	30	#if defined(LIBC_SCCS) && !defined(lint)
31	static char sccsid[] = "@(#)getcwd.c 8.5 (Berkeley) 2/7/95";	31	static char sccsid[] = "@(#)getcwd.c 8.5 (Berkeley) 2/7/95";
32	#endif /* LIBC_SCCS and not lint */	32	#endif /* LIBC_SCCS and not lint */
		33
		34	#undef _FORTIFY_SOURCE
33	#include <sys/cdefs.h>	35	#include <sys/cdefs.h>
34	__FBSDID("$FreeBSD$");	36	__FBSDID("$FreeBSD$");
35		37

Lines 95-100 Link Here

(-)b/lib/libc/Makefile (+1 lines)
95	.include "${LIBC_SRCTOP}/stdtime/Makefile.inc"	95	.include "${LIBC_SRCTOP}/stdtime/Makefile.inc"
96	.include "${LIBC_SRCTOP}/string/Makefile.inc"	96	.include "${LIBC_SRCTOP}/string/Makefile.inc"
97	.include "${LIBC_SRCTOP}/sys/Makefile.inc"	97	.include "${LIBC_SRCTOP}/sys/Makefile.inc"
		98	.include "${LIBC_SRCTOP}/secure/Makefile.inc"
98	.include "${LIBC_SRCTOP}/rpc/Makefile.inc"	99	.include "${LIBC_SRCTOP}/rpc/Makefile.inc"
99	.include "${LIBC_SRCTOP}/uuid/Makefile.inc"	100	.include "${LIBC_SRCTOP}/uuid/Makefile.inc"
100	.include "${LIBC_SRCTOP}/xdr/Makefile.inc"	101	.include "${LIBC_SRCTOP}/xdr/Makefile.inc"

Lines 589-592 Link Here

(-)b/include/unistd.h (+4 lines)
589	#endif /* __BSD_VISIBLE */	589	#endif /* __BSD_VISIBLE */
590	__END_DECLS	590	__END_DECLS
591		591
		592	#if defined(__BSD_FORTIFY)
		593	#include <secure/_unistd.h>
		594	#endif
		595
592	#endif /* !_UNISTD_H_ */	596	#endif /* !_UNISTD_H_ */

Lines 68-71 Link Here

(-)b/include/strings.h (+4 lines)
68	#endif	68	#endif
69	__END_DECLS	69	__END_DECLS
70		70
		71	#if defined(__BSD_FORTIFY)
		72	#include <secure/_strings.h>
		73	#endif
		74
71	#endif /* _STRINGS_H_ */	75	#endif /* _STRINGS_H_ */

Lines 141-144 Link Here

(-)b/include/string.h (+4 lines)
141	#endif	141	#endif
142	__END_DECLS	142	__END_DECLS
143		143
		144	#if defined(__BSD_FORTIFY)
		145	#include <secure/_string.h>
		146	#endif
		147
144	#endif /* _STRING_H_ */	148	#endif /* _STRING_H_ */

Lines 521-524 Link Here

(-)b/include/stdio.h (+5 lines)
521	#endif /* __cplusplus */	521	#endif /* __cplusplus */
522		522
523	__END_DECLS	523	__END_DECLS
		524
		525	#if defined(__BSD_FORTIFY)
		526	#include <secure/_stdio.h>
		527	#endif
		528
524	#endif /* !_STDIO_H_ */	529	#endif /* !_STDIO_H_ */




/*-
 * Copyright (c) 2015 Olivér Pintér
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#ifndef _SECURE_SECURITY_
#define	_SECURE_SECURITY_

#include <sys/cdefs.h>
#include <sys/types.h>

#ifndef __clang__
#if __GNUC_PREREQ__(4, 3)
#define	__errordecl(name, msg)	extern void name(void) __error_attr(msg)
#else
#define	__errordecl(name, msg)		\
static void name(void) __dead2;		\
static void name(void)			\
{					\
					\
	__fortify_chk_fail(msg);	\
}
#endif	/* __GNUC_PREREQ(4, 3) */
#else	/* !__clang__ */
#define	__errordecl(name, msg)
#endif	/* !__clang__ */

#define	__RENAME(x)	__asm__(#x)

#if __has_builtin(__builtin_umul_overflow) || __GNUC_PREREQ__(5, 0)
#if __LP64__
#define	__size_mul_overflow(a, b, result)	__builtin_umull_overflow(a, b, result)
#else
#define	__size_mul_overflow(a, b, result)	__builtin_umul_overflow(a, b, result)
#endif
#else
static __inline __always_inline int
__size_mul_overflow(__SIZE_TYPE__ a, __SIZE_TYPE__ b, __SIZE_TYPE__ *result)
{
    static const __SIZE_TYPE__ mul_no_overflow = 1UL << (sizeof(__SIZE_TYPE__) * 4);

    *result = a * b;

    return (a >= mul_no_overflow || b >= mul_no_overflow) && a > 0 && (__SIZE_TYPE__)-1 / a < b;
}
#endif

__BEGIN_DECLS

/* Common fail function. */
void	__secure_fail(const char *msg) __dead2 __nonnull(1);

/* SSP related fail functions. */
void	__chk_fail(void) __dead2;
void	__stack_chk_fail(void) __dead2;

/* FORTIFY_SOURCE related fail function. */
void	__fortify_chk_fail(const char* msg) __dead2 __nonnull(1);
int	__fortify_chk_overlap(const void *a, const void *b, size_t len);

__END_DECLS

#endif /* !_SECURE_SECURITY_ */




/*-
 * Copyright (c) 2015 Olivér Pintér
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * rev: 9ef26a3c4cd2e6d469f771815a07cb820800beb6
 *
 * $FreeBSD$
 */

#ifndef _UNISTD_H_
#error "You should not use <secure/_unistd.h> directly; include <unistd.h> instead."
#endif

#ifndef _SECURE_UNISTD_H_
#define	_SECURE_UNISTD_H_

#include <sys/limits.h>
#include <secure/security.h>

__BEGIN_DECLS

extern char	*__getcwd_chk(char*, size_t, size_t);
extern char	*__getcwd_real(char*, size_t) __RENAME(getcwd);
__errordecl(__getcwd_dest_size_error, "getcwd called with size bigger than destination");
extern ssize_t	 __pread_chk(int, void *, size_t, off_t, size_t);
extern ssize_t	 __pread_real(int, void *, size_t, off_t) __RENAME(pread);
__errordecl(__pread_dest_size_error, "pread called with size bigger than destination");
__errordecl(__pread_count_toobig_error, "pread called with count > SSIZE_MAX");
extern ssize_t	 __read_chk(int, void *, size_t, size_t);
extern ssize_t	 __read_real(int, void *, size_t) __RENAME(read);
__errordecl(__read_dest_size_error, "read called with size bigger than destination");
__errordecl(__read_count_toobig_error, "read called with count > SSIZE_MAX");
extern ssize_t	 __readlink_chk(const char *, char *, size_t, size_t);
extern ssize_t	 __readlink_real(const char *, char *, size_t) __RENAME(readlink);
__errordecl(__readlink_dest_size_error, "readlink called with size bigger than destination");
__errordecl(__readlink_size_toobig_error, "readlink called with size > SSIZE_MAX");
extern ssize_t	 __readlinkat_chk(int, const char *, char *, size_t, size_t);
extern ssize_t	 __readlinkat_real(int, const char *, char *, size_t) __RENAME(readlinkat);
__errordecl(__readlinkat_dest_size_error, "readlinkat called with size bigger than destination");
__errordecl(__readlinkat_size_toobig_error, "readlinkat called with size > SSIZE_MAX");

#ifdef __BSD_FORTIFY

__FORTIFY_INLINE
char *
getcwd(char *_buf, size_t _size)
{
	size_t	_bos = __bos(_buf);

#ifdef __clang__
	/*
	 * Work around LLVM's incorrect __builtin_object_size implementation
	 * here to avoid needing the workaround in the __getcwd_chk ABI
	 * forever.
	 * 
	 * https://llvm.org/bugs/show_bug.cgi?id=23277
	 */
	if (_buf == NULL)
		_bos = __FORTIFY_UNKNOWN_SIZE;
#else
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__getcwd_real(_buf, _size));
	if (__builtin_constant_p(_size) && (_size > _bos))
		__getcwd_dest_size_error();
	if (__builtin_constant_p(_size) && (_size <= _bos))
		return (__getcwd_real(_buf, _size));
#endif

	return (__getcwd_chk(_buf, _size, _bos));
}


/* 1003.1-2008 */
#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE
__FORTIFY_INLINE ssize_t
pread(int _fd, void *_buf, size_t _count, off_t _offset)
{
	size_t _bos = __bos0(_buf);

#ifndef __clang__
	if (__builtin_constant_p(_count) && (_count > SSIZE_MAX))
		__pread_count_toobig_error();

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__pread_real(_fd, _buf, _count, _offset));

	if (__builtin_constant_p(_count) && (_count > _bos))
		__pread_dest_size_error();

	if (__builtin_constant_p(_count) && (_count <= _bos))
		return (__pread_real(_fd, _buf, _count, _offset));
#endif

	return (__pread_chk(_fd, _buf, _count, _offset, _bos));
}
#endif /* __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE */


__FORTIFY_INLINE ssize_t
read(int _fd, void *_buf, size_t _count)
{
	size_t _bos = __bos0(_buf);

#ifndef __clang__
	if (__builtin_constant_p(_count) && (_count > SSIZE_MAX))
		__read_count_toobig_error();

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__read_real(_fd, _buf, _count));

	if (__builtin_constant_p(_count) && (_count > _bos))
		__read_dest_size_error();

	if (__builtin_constant_p(_count) && (_count <= _bos))
		return (__read_real(_fd, _buf, _count));
#endif

	return (__read_chk(_fd, _buf, _count, _bos));
}


/* 1003.1-2001 */
#if __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE
__FORTIFY_INLINE ssize_t
readlink(const char *_path, char *_buf, size_t _size)
{
	size_t _bos = __bos(_buf);

#ifndef __clang__
	if (__builtin_constant_p(_size) && (_size > SSIZE_MAX))
		__readlink_size_toobig_error();

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__readlink_real(_path, _buf, _size));

	if (__builtin_constant_p(_size) && (_size > _bos))
		__readlink_dest_size_error();

	if (__builtin_constant_p(_size) && (_size <= _bos))
		return (__readlink_real(_path, _buf, _size));
#endif

	return (__readlink_chk(_path, _buf, _size, _bos));
}
#endif /* __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE */


#if __POSIX_VISIBLE >= 200809
__FORTIFY_INLINE ssize_t
readlinkat(int _dirfd, const char *_path, char *_buf, size_t _size)
{
	size_t _bos = __bos(_buf);

#ifndef __clang__
	if (__builtin_constant_p(_size) && (_size > SSIZE_MAX))
		(__readlinkat_size_toobig_error());

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__readlinkat_real(_dirfd, _path, _buf, _size));

	if (__builtin_constant_p(_size) && (_size > _bos))
		__readlinkat_dest_size_error();

	if (__builtin_constant_p(_size) && (_size <= _bos))
		return (__readlinkat_real(_dirfd, _path, _buf, _size));
#endif

	return (__readlinkat_chk(_dirfd, _path, _buf, _size, _bos));
}
#endif /* __POSIX_VISIBLE >= 200809 */

#endif	/* defined(__BSD_FORTIFY) */

__END_DECLS

#endif	/* !_SECURE_UNISTD_H_ */




/*-
 * Copyright (C) 2015 Olivér Pintér
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#ifndef _STRINGS_H_
#error "You should not use <secure/_strings.h> directly; include <sys/strings.h> instead."
#endif

#ifndef _SECURE_STRINGS_H_
#define _SECURE_STRINGS_H_

#include <secure/security.h>

__BEGIN_DECLS

extern void	*__bcopy_chk(void *, const void *, size_t, size_t) __RENAME(__memmove_chk);
extern void	 __bcopy_real(const void *, void *, size_t) __RENAME(bcopy);
extern void	*__bzero_chk(void *, int, size_t, size_t) __RENAME(__memset_chk);
extern void	 __bzero_real(void *, size_t) __RENAME(bzero);
extern char	*__rindex_chk(const char *, int, size_t);
extern char	*__rindex_real(const char *, int) __RENAME(rindex);

#ifdef __BSD_FORTIFY
#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
__FORTIFY_INLINE void
bcopy(const void *_s, void *_d, size_t _l)
{
	size_t _bos = __bos0(_d);

#ifndef __clang__
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		__bcopy_real(_s, _d, _l);
#endif

	(void)(__bcopy_chk(_d, _s, _l, _bos));
}
#endif


#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
__FORTIFY_INLINE void
bzero(void *_s, size_t _n)
{
	size_t _bos = __bos(_s);

#ifndef __clang__
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		__bzero_real(_s, _n);
#endif

	(void)(__bzero_chk(_s, '\0', _n, _bos));
}
#endif


#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
__FORTIFY_INLINE char *
rindex(const char *_s, int _c)
{
	size_t _bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	/* Compiler doesn't know destination size. Don't call __strrchr_chk. */
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__rindex_real(_s, _c));

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __rindex_chk.
	 */
	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen) && (_slen < _bos))
		return (__rindex_real(_s, _c));
#endif

	return (__rindex_chk(_s, _c, _bos));
}
#endif


#endif /* !__BSD_FORTIFY */

__END_DECLS

#endif /* !defined(_SECURE_STRINGS_H_) */




/*-
 * Copyright (c) 2015 Olivér Pintér
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: 9ef26a3c4cd2e6d469f771815a07cb820800beb6
 *
 * $FreeBSD$
 */

#ifndef _STRING_H_
#error "You should not use <secure/_string.h> directly; include <string.h> instead."
#endif

#ifndef _SECURE_STRING_H_
#define	_SECURE_STRING_H_

#include <secure/security.h>

__BEGIN_DECLS

extern void 	*__memccpy_chk(void *, const void *, int, size_t, size_t);
extern void	*__memccpy_real(void *, const void *, int, size_t) __RENAME(memccpy);
extern void	*__memchr_chk(const void *, int, size_t, size_t);
extern void	*__memchr_real(const void *, int, size_t) __RENAME(memchr);
extern void	*__memcpy_chk(void *, const void *, size_t, size_t);
extern void	*__memcpy_real(void *, const void *, size_t) __RENAME(memcpy);
__errordecl(__memchr_buf_size_error, "memchr called with size bigger than buffer");
extern void	*__memmove_chk(void *, const void *, size_t, size_t);
extern void	*__memmove_real(void *, const void *, size_t) __RENAME(memmove);
extern void	*__memrchr_chk(const void *, int, size_t, size_t);
extern void	*__memrchr_real(const void *, int, size_t) __RENAME(memrchr);
__errordecl(__memrchr_buf_size_error, "memrchr called with size bigger than buffer");
extern void	*__memset_chk(void *, int, size_t, size_t);
extern void	*__memset_real(void *, int, size_t) __RENAME(memset);
extern char	*__strcat_chk(char *__restrict, const char *__restrict, size_t);
extern char	*__strcat_real(char *__restrict, const char *__restrict) __RENAME(strcat);
extern char	*__strncat_chk(char *__restrict, const char *__restrict, size_t, size_t);
extern char	*__strncat_real(char *__restrict, const char *__restrict, size_t) __RENAME(strncat);
extern char	*__stpcpy_chk(char *, const char *, size_t);
extern char	*__stpcpy_real(char *, const char *) __RENAME(stpcpy);
extern char	*__stpncpy_chk(char * __restrict, const char * __restrict, size_t, size_t);
extern char	*__stpncpy_chk2(char * __restrict, const char * __restrict, size_t, size_t, size_t);
extern char	*__stpncpy_real(char * __restrict, const char * __restrict, size_t) __RENAME(stpncpy);
extern char	*__strcpy_chk(char *, const char *, size_t);
extern char	*__strcpy_real(char *, const char *) __RENAME(strcpy);
extern char	*__strncpy_chk(char *, const char *, size_t, size_t);
extern char	*__strncpy_chk2(char * __restrict, const char * __restrict, size_t, size_t, size_t);
extern char	*__strncpy_real(char *, const char *, size_t) __RENAME(strncpy);
extern size_t	 __strlcpy_chk(char *, const char *, size_t, size_t);
extern size_t	 __strlcpy_real(char * __restrict, const char * __restrict, size_t) __RENAME(strlcpy);
extern size_t	 __strlcat_chk(char * __restrict, const char * __restrict, size_t, size_t);
extern size_t	 __strlcat_real(char * __restrict, const char * __restrict, size_t) __RENAME(strlcat);
extern size_t	 __strlen_chk(const char *, size_t);
extern size_t	 __strlen_real(const char *) __RENAME(strlen);
extern char	*__strchr_chk(const char *, int, size_t);
extern char	*__strchr_real(const char *, int) __RENAME(strchr);
extern char	*__strchrnul_chk(const char *, int, size_t);
extern char	*__strchrnul_real(const char *, int) __RENAME(strchrnul);
extern char	*__strrchr_chk(const char *, int, size_t);
extern char	*__strrchr_real(const char *, int) __RENAME(strrchr);

#ifdef __BSD_FORTIFY

#if __XSI_VISIBLE >= 600
__FORTIFY_INLINE void *
memccpy(void * __restrict _d, const void * __restrict _s, int _c, size_t _n)
{
	size_t _bos = __bos0(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memccpy_real(_d, _s, _c, _n));
#endif

	return (__memccpy_chk(_d, _s, _c, _n, _bos));
}
#endif /* __XSI_VISIBLE */


__FORTIFY_INLINE void *
memchr(const void *_s, int _c, size_t _n)
{
	size_t _bos = __bos(_s);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memchr_real(_s, _c, _n));

	if (__builtin_constant_p(_n) && (_n > _bos))
		__memchr_buf_size_error();

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __memchr_chk.
	 */
	if (__builtin_constant_p(_n) && (_n <= _bos))
		return (__memchr_real(_s, _c, _n));
#endif

	return (__memchr_chk(_s, _c, _n, _bos));
}


#if __BSD_VISIBLE
__FORTIFY_INLINE void *
memrchr(const void *_s, int _c, size_t _n)
{
	size_t _bos = __bos(_s);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memrchr_real(_s, _c, _n));

	if (__builtin_constant_p(_n) && (_n > _bos))
		(__memrchr_buf_size_error());

	if (__builtin_constant_p(_n) && (_n <= _bos))
		return __memrchr_real(_s, _c, _n);
#endif

	return (__memrchr_chk(_s, _c, _n, _bos));
}
#endif /* __BSD_VISIBLE */


__FORTIFY_INLINE void *
memcpy(void * __restrict _d, const void * __restrict _s, size_t _n)
{
	size_t _bos = __bos0(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memcpy_real(_d, _s, _n));
#endif

	return (__memcpy_chk(_d, _s, _n, _bos));
}


__FORTIFY_INLINE void *
memmove(void *_d, const void *_s, size_t _n)
{
	size_t _bos = __bos0(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memmove_real(_d, _s, _n));
#endif

	return (__memmove_chk(_d, _s, _n, _bos));
}


#if __POSIX_VISIBLE >= 200809
__FORTIFY_INLINE char *
stpcpy(char * __restrict _d, const char * __restrict _s)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__stpcpy_real(_d, _s));
#endif

	return (__stpcpy_chk(_d, _s, _bos));
}
#endif /* __POSIX_VISIBLE */


__FORTIFY_INLINE char *
strcpy(char * __restrict _d, const char * __restrict _s)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strcpy_real(_d, _s));
#endif

	return (__strcpy_chk(_d, _s, _bos));
}


#if __POSIX_VISIBLE >= 200809
__FORTIFY_INLINE char *
stpncpy(char * __restrict _d, const char * __restrict _s, size_t _n)
{
	size_t _d_bos = __bos(_d);
	size_t _s_bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	if (_d_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__stpncpy_real(_d, _s, _n));

	if (_s_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__stpncpy_chk(_d, _s, _n, _d_bos));

	if (__builtin_constant_p(_n) && (_n <= _s_bos))
		return (__stpncpy_chk(_d, _s, _n, _d_bos));

	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen))
		return (__stpncpy_chk(_d, _s, _n, _d_bos));
#endif

	return (__stpncpy_chk2(_d, _s, _n, _d_bos, _s_bos));
}
#endif /* __POSIX_VISIBLE */


__FORTIFY_INLINE char *
strncpy(char * __restrict _d, const char * __restrict _s, size_t _n)
{
	size_t _d_bos = __bos(_d);
	size_t _s_bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	if (_d_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__strncpy_real(_d, _s, _n));

	if (_s_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__strncpy_chk(_d, _s, _n, _d_bos));

	if (__builtin_constant_p(_n) && (_n <= _s_bos))
		return (__strncpy_chk(_d, _s, _n, _d_bos));

	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen))
		return (__strncpy_chk(_d, _s, _n, _d_bos));
#endif

	return (__strncpy_chk2(_d, _s, _n, _d_bos, _s_bos));
}


__FORTIFY_INLINE char *
strcat(char * __restrict _d, const char * __restrict _s)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strcat_real(_d, _s));
#endif

	return (__strcat_chk(_d, _s, _bos));
}


__FORTIFY_INLINE char *
strncat(char * __restrict _d, const char * __restrict _s, size_t _n)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strncat_real(_d, _s, _n));
#endif

	return (__strncat_chk(_d, _s, _n, _bos));
}


__FORTIFY_INLINE void *
memset(void *_s, int _c, size_t _n)
{
	size_t _bos = __bos(_s);

#ifndef __clang__
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__memset_real(_s, _c, _n));
#endif

	return (__memset_chk(_s, _c, _n, _bos));
}


#if __BSD_VISIBLE
__FORTIFY_INLINE size_t
strlcpy(char * __restrict _d, const char * __restrict _s, size_t _n)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	/* Compiler doesn't know destination size. Don't call __strlcpy_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strlcpy_real(_d, _s, _n));

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __strlcpy_chk.
	 */
	if (__builtin_constant_p(_n) && (_n <= _bos))
		return (__strlcpy_real(_d, _s, _n));
#endif

	return (__strlcpy_chk(_d, _s, _n, _bos));
}
#endif /* __BSD_VISIBLE */


#if __BSD_VISIBLE
__FORTIFY_INLINE size_t
strlcat(char * __restrict _d, const char * __restrict _s, size_t _n)
{
	size_t _bos = __bos(_d);

#ifndef __clang__
	/* Compiler doesn't know destination size. Don't call __strlcat_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strlcat_real(_d, _s, _n));

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __strlcat_chk.
	 */
	if (__builtin_constant_p(_n) && (_n <= _bos))
		return (__strlcat_real(_d, _s, _n));
#endif

	return (__strlcat_chk(_d, _s, _n, _bos));
}
#endif /* __BSD_VISIBLE */


__FORTIFY_INLINE size_t
strlen(const char *_s)
{
	size_t _bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	/* Compiler doesn't know destination size. Don't call __strlen_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strlen_real(_s));

	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen))
		return (_slen);
#endif

	return (__strlen_chk(_s, _bos));
}

__FORTIFY_INLINE char *
strchr(const char *_s, int _c)
{
	size_t _bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	/* Compiler doesn't know destination size. Don't call __strchr_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strchr_real(_s, _c));

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __strlchr_chk.
	 */
	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen) && (_slen < _bos))
		return (__strchr_real(_s, _c));
#endif

	return (__strchr_chk(_s, _c, _bos));
}


#if __BSD_VISIBLE
__FORTIFY_INLINE char *
strchrnul(const char *_s, int _c)
{
	size_t _bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	/* Compiler doesn't know destination size. Don't call __strchr_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strchrnul_real(_s, _c));
	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __strlchrnul_chk.
	 */
	_slen = __builtin_strlen(_s);
	if (__builtin_constant_p(_slen) && (_slen < _bos))
		return (__strchrnul_real(_s, _c));
#endif

	return (__strchrnul_chk(_s, _c, _bos));
}
#endif


__FORTIFY_INLINE char *
strrchr(const char *_s, int _c)
{
	size_t _bos = __bos(_s);
#ifndef __clang__
	size_t _slen;

	/* Compiler doesn't know destination size. Don't call __strrchr_chk. */
	if (__predict_false(_bos == __FORTIFY_UNKNOWN_SIZE))
		return (__strrchr_real(_s, _c));

	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size. Don't call __strlen_chk.
	 */
	_slen = __strlen_real(_s);
	if (__builtin_constant_p(_slen) && (_slen < _bos))
		return (__strrchr_real(_s, _c));
#endif

	return (__strrchr_chk(_s, _c, _bos));
}


#endif /* defined(__BSD_FORTIFY) */

__END_DECLS

#endif /* !_SECURE_STRING_H */




/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Chris Torek.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)stdio.h	5.17 (Berkeley) 6/3/91
 *	$OpenBSD: stdio.h,v 1.35 2006/01/13 18:10:09 miod Exp $
 *	$NetBSD: stdio.h,v 1.18 1996/04/25 18:29:21 jtc Exp $
 *	bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
 *	$FreeBSD$
 */

#ifndef _STDIO_H_
#error "You should not use <secure/_stdio.h> directly; include <stdio.h> instead."
#endif

#ifndef	_SECURE_STDIO_H_
#define	_SECURE_STDIO_H_

#include <secure/security.h>
#include <stdarg.h>

__BEGIN_DECLS

extern char	*__fgets_chk(char *, int, FILE *, size_t);
extern char	*__fgets_real(char *, int, FILE *) __RENAME(fgets);
__errordecl(__fgets_too_big_error, "fgets called with size bigger than buffer");
__errordecl(__fgets_too_small_error, "fgets called with size less than zero");
extern size_t	__fread_chk(void * __restrict, size_t, size_t, FILE * __restrict, size_t);
extern size_t	__fread_real(void * __restrict, size_t, size_t, FILE * __restrict) __RENAME(fread);
__errordecl(__fread_too_big_error, "fread called with size * count bigger than buffer");
__errordecl(__fread_overflow, "fread called with overflowing size * count");
extern size_t	__fwrite_chk(const void * __restrict, size_t, size_t, FILE * __restrict, size_t);
extern size_t	__fwrite_real(const void * __restrict, size_t, size_t, FILE * __restrict) __RENAME(fwrite);
__errordecl(__fwrite_too_big_error, "fwrite called with size * count bigger than buffer");
__errordecl(__fwrite_overflow, "fwrite called with overflowing size * count");
extern int	__sprintf_chk(char * __restrict, int, size_t, const char * __restrict, ...);
extern int	__sprintf_real(char * __restrict, const char * __restrict, ...) __RENAME(sprintf);
extern int	__vsprintf_chk(char * __restrict, int, size_t, const char * __restrict, __va_list);
extern int	__vsprintf_real(char * __restrict, const char * __restrict, __va_list) __RENAME(vsprintf);

#if __ISO_C_VISIBLE >= 1999
extern int	__snprintf_chk(char * __restrict, size_t, int, size_t, const char * __restrict, ...);
extern int	__snprintf_real(char * __restrict, size_t, const char * __restrict, ...) __RENAME(snprintf) __printflike(3, 4);
extern int	__vsnprintf_chk(char * __restrict, size_t, int, size_t, const char * __restrict, __va_list);
extern int	__vsnprintf_real(char * __restrict, size_t, const char * __restrict, __va_list) __RENAME(vsnprintf) __printflike(3, 0);
#endif

#ifdef __BSD_FORTIFY

#if __ISO_C_VISIBLE >= 1999
__FORTIFY_INLINE __printflike(3, 0) int
vsnprintf(char *_dest, size_t _size, const char *_format, __va_list _ap)
{
	size_t _bos = __bos(_dest);

#ifndef __clang__
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__vsnprintf_real(_dest, _size, _format, _ap));
#endif

	return (__vsnprintf_chk(_dest, _size, 0, _bos, _format, _ap));
}
#endif /* __ISO_C_VISIBLE */

__FORTIFY_INLINE __printflike(2, 0) int
vsprintf(char *_dest, const char *_format, __va_list _ap)
{
	size_t _bos = __bos(_dest);

#ifndef __clang__
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__vsprintf_real(_dest, _format, _ap));
#endif

	return (__vsprintf_chk(_dest, 0, _bos, _format, _ap));
}


#if __ISO_C_VISIBLE >= 1999
#if !__has_builtin(__builtin_va_arg_pack) && !__GNUC_PREREQ__(4, 3)	/* defined(__clang__) */
#if !defined(snprintf) && !defined(__cplusplus)
#define	__wrap_snprintf(_dest, _size, ...)	__snprintf_chk(_dest, _size, 0, __bos(_dest), __VA_ARGS__)
#define	snprintf(...)	__wrap_snprintf(__VA_ARGS__)
#endif /* !snprintf */
#else /* __GNUC_PREREQ__(4, 3) */
__FORTIFY_INLINE __printflike(3, 4) int
snprintf(char *_dest, size_t _size, const char *_format, ...)
{
	size_t _bos = __bos(_dest);

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__snprintf_real(_dest, _size, _format,
		    __builtin_va_arg_pack()));

	return (__snprintf_chk(_dest, _size, 0, _bos, _format,
	    __builtin_va_arg_pack()));
}
#endif /* !__GNUC_PREREQ__(4, 3) */
#endif /* __ISO_C_VISIBLE */

#if !__has_builtin(__builtin_va_arg_pack) && !__GNUC_PREREQ__(4, 3)	/* defined(__clang__) */
#if !defined(sprintf) && !defined(__cplusplus)
#define	__wrap_sprintf(_dest, ...)	__sprintf_chk(_dest, 0, __bos(_dest), __VA_ARGS__)
#define	sprintf(...)	__wrap_sprintf(__VA_ARGS__)
#endif /* !sprintf */
#else /* __GNUC_PREREQ__(4, 3) */
__FORTIFY_INLINE __printflike(2, 3) int
sprintf(char *_dest, const char *_format, ...)
{
	size_t _bos = __bos(_dest);

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__sprintf_real(_dest, _format,
		    __builtin_va_arg_pack()));

	return (__sprintf_chk(_dest, 0, _bos, _format,
	    __builtin_va_arg_pack()));
}

#endif /* !__GNUC_PREREQ__(4, 3) */

__FORTIFY_INLINE char *
fgets(char *_buf, int _n, FILE *_stream)
{
	size_t _bos = __bos(_buf);

#ifndef __clang__
	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always negative.
	 * Force a compiler error.
	 */
	if (__builtin_constant_p(_n) && (_n < 0))
		__fgets_too_small_error();
	/*
	 * Compiler doesn 't know destination size.
	 * Don' t call __fgets_chk.
	 */
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__fgets_real(_buf, _n, _stream));
	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always <= the actual object size.
	 * Don 't call __fgets_chk.
	 */
	if (__builtin_constant_p(_n) && (_n <= (int)_bos))
		return (__fgets_real(_buf, _n, _stream));
	/*
	 * Compiler can prove, at compile time, that the passed in size
	 * is always > the actual object size.
	 * Force a compiler error.
	 */
	if (__builtin_constant_p(_n) && (_n > (int)_bos))
		__fgets_too_big_error();
#endif
	return (__fgets_chk(_buf, _n, _stream, _bos));
}


__FORTIFY_INLINE size_t
fread(void * __restrict _ptr, size_t _size, size_t _nmemb, FILE * __restrict _stream)
{
	size_t _bos = __bos0(_ptr);
#ifndef __clang__
	size_t _total;

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__fread_real(_ptr, _size, _nmemb, _stream));

	if (__builtin_constant_p(_size) && __builtin_constant_p(_nmemb)) {
		if (__size_mul_overflow(_size, _nmemb, &_total))
			__fread_overflow();

		if (_total > _bos)
			__fread_too_big_error();

		return (__fread_real(_ptr, _size, _nmemb, _stream));
	}
#endif

	return (__fread_chk(_ptr, _size, _nmemb, _stream, _bos));
}


__FORTIFY_INLINE size_t
fwrite(const void * __restrict _ptr, size_t _size, size_t _nmemb, FILE * __restrict _stream)
{
	size_t _bos = __bos0(_ptr);
#ifndef __clang__
	size_t _total;

	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return __fwrite_real(_ptr, _size, _nmemb, _stream);

	if (__builtin_constant_p(_size) && __builtin_constant_p(_nmemb)) {
		if (__size_mul_overflow(_size, _nmemb, &_total))
			__fwrite_overflow();

		if (_total > _bos)
			__fwrite_too_big_error();

		return (__fwrite_real(_ptr, _size, _nmemb, _stream));
	}
#endif

	return (__fwrite_chk(_ptr, _size, _nmemb, _stream, _bos));
}

#endif /* defined(__BSD_FORTIFY) */

__END_DECLS

#endif /* !_SECURE_STDIO_H_ */




/*-
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: d807b9a12d3e49132b095df3d883618452033b51
 *
 * $FreeBSD$
 */

#ifndef _SYS_STAT_H_
#error "You should not use <secure/_stat.h> directly; include <sys/stat.h> instead."
#endif

#ifndef _SECURE_STAT_H_
#define	_SECURE_STAT_H_

#include <secure/security.h>

__BEGIN_DECLS

extern mode_t __umask_chk(mode_t);
#ifndef __FORTIFY_UMASK_REAL
#define	__FORTIFY_UMASK_REAL	1
extern mode_t __umask_real(mode_t) __RENAME(umask);
#endif
__errordecl(__umask_invalid_mode, "umask called with invalid mode");

#ifdef __BSD_FORTIFY

__FORTIFY_INLINE mode_t
umask(mode_t _mode)
{
#ifndef __clang__
	if (__builtin_constant_p(_mode)) {
		if ((_mode & 0777) != _mode)
			__umask_invalid_mode();

		return (__umask_real(_mode));
	}
#endif
	return (__umask_chk(_mode));
}
#endif /* defined(__BSD_FORTIFY) */

__END_DECLS

#endif /* !_SECURE_STAT_H_ */




/*
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9 
 *
 * $FreeBSD$
 */


#ifndef _SYS_SOCKET_H_
#error "You should not use <secure/_socket.h> directly; include <sys/socket.h> instead."
#endif

#ifndef _SECURE_SOCKET_H_
#define _SECURE_SOCKET_H_

#include <sys/_null.h>
#include <secure/security.h>

__BEGIN_DECLS

extern ssize_t	__recvfrom_chk(int, void *, size_t, size_t, int, struct sockaddr * __restrict, socklen_t * __restrict);
extern ssize_t	__recvfrom_real(int, void *, size_t, int, const struct sockaddr *, socklen_t *) __RENAME(recvfrom);
__errordecl(__recvfrom_error, "recvfrom called with size bigger than buffer");

#ifdef __BSD_FORTIFY

__FORTIFY_INLINE ssize_t
recvfrom(int _s, void *_buf, size_t _len, int _flags, struct sockaddr * __restrict _from, socklen_t * __restrict _fromlen)
{
	size_t _bos = __bos0(_buf);

#ifndef __clang__
	if (_bos == __FORTIFY_UNKNOWN_SIZE)
		return (__recvfrom_real(_s, _buf, _len, _flags, _from, _fromlen));

	if (__builtin_constant_p(_len) && (_len <= _bos))
		return (__recvfrom_real(_s, _buf, _len, _flags, _from, _fromlen));

	if (__builtin_constant_p(_len) && (_len > _bos))
		__recvfrom_error();
#endif

	return (__recvfrom_chk(_s, _buf, _len, _bos, _flags, _from, _fromlen));
}


__FORTIFY_INLINE ssize_t
recv(int _s, void *_buf, size_t _len, int _flags)
{

	return recvfrom(_s, _buf, _len, _flags, NULL, 0);
}

#endif /* !__BSD_FORTIFY */

__END_DECLS

#endif /* !_SECURE_SOCKET_H */




/*
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * bionic rev: eeb9f5e41662828989f3913d81ec23229a668434
 *
 * $FreeBSD$
 */

#ifndef _SYS_POLL_H_
#error "You should not use <secure/_poll.h> directly; include <sys/poll.h> instead."
#endif

#ifndef _SECURE_POLL_H_
#define _SECURE_POLL_H_

#include <secure/security.h>

__BEGIN_DECLS

int	__poll_chk(struct pollfd *, nfds_t, int, size_t);
int	__poll_real(struct pollfd *, nfds_t, int) __RENAME(poll);
__errordecl(__poll_too_small_error, "poll: pollfd array smaller than fd count");

int	__ppoll_chk(struct pollfd *, nfds_t, const struct timespec *, const sigset_t *, size_t);
int	__ppoll_real(struct pollfd *, nfds_t, const struct timespec *, const sigset_t *) __RENAME(ppoll);
__errordecl(__ppoll_too_small_error, "ppoll: pollfd array smaller than fd count");

#ifdef __BSD_FORTIFY

__FORTIFY_INLINE int
poll(struct pollfd *_fds, nfds_t _fd_count, int _timeout)
{
	size_t _bos = __bos(_fds);

#ifdef __clang__
	return (__poll_chk(_fds, _fd_count, _timeout, _bos));
#else
	if (_bos != __FORTIFY_UNKNOWN_SIZE) {
		if (!__builtin_constant_p(_fd_count))
			return (__poll_chk(_fds, _fd_count, _timeout, _bos));
		else if (_bos / sizeof(*_fds) < _fd_count)
			__poll_too_small_error();
	}
	return (__poll_real(_fds, _fd_count, _timeout));
#endif
}

#if __BSD_VISIBLE
__FORTIFY_INLINE int
ppoll(struct pollfd *_fds, nfds_t _fd_count, const struct timespec *_timeout, const sigset_t *_mask)
{
	size_t _bos = __bos(_fds);

#ifdef __clang__
	return (__ppoll_chk(_fds, _fd_count, _timeout, _mask, _bos));
#else
	if (_bos != __FORTIFY_UNKNOWN_SIZE) {
		if (!__builtin_constant_p(_fd_count))
			return (__ppoll_chk(_fds, _fd_count, _timeout, _mask, _bos));
		else if (_bos / sizeof(*_fds) < _fd_count)
			__ppoll_too_small_error();
	}
	return (__ppoll_real(_fds, _fd_count, _timeout, _mask));
#endif
}
#endif

#endif

__END_DECLS

#endif	/* !_SECURE_POLL_H_ */

Added Link Here

(-)b/include/secure/Makefile (+6 lines)
1	# $FreeBSD$
2
3	INCS= security.h _poll.h _socket.h _stat.h _stdio.h _string.h _strings.h _unistd.h
4	INCSDIR= ${INCLUDEDIR}/secure
5
6	.include <bsd.prog.mk>

Lines 6-12 Link Here

(-)b/include/Makefile (-1 / +1 lines)
6	.include <src.opts.mk>	6	.include <src.opts.mk>
7		7
8	CLEANFILES= osreldate.h version vers.c	8	CLEANFILES= osreldate.h version vers.c
9	SUBDIR= arpa protocols rpcsvc rpc xlocale	9	SUBDIR= arpa protocols rpcsvc rpc secure xlocale
10	INCS= a.out.h ar.h assert.h bitstring.h complex.h cpio.h _ctype.h ctype.h \	10	INCS= a.out.h ar.h assert.h bitstring.h complex.h cpio.h _ctype.h ctype.h \
11	db.h \	11	db.h \
12	dirent.h dlfcn.h elf.h elf-hints.h err.h fmtmsg.h fnmatch.h fstab.h \	12	dirent.h dlfcn.h elf.h elf-hints.h err.h fmtmsg.h fnmatch.h fstab.h \

Lines 321-326 Link Here

(-)b/etc/mtree/BSD.include.dist (+2 lines)
321	mac_partition	321	mac_partition
322	..	322	..
323	..	323	..
		324	secure
		325	..
324	ssp	326	ssp
325	..	327	..
326	sys	328	sys

Return to bug 202311

Lines 545-550 Link Here

(-)b/sys/sys/cdefs.h (+20 lines)
545	#define __gnu_inline	545	#define __gnu_inline
546	#endif	546	#endif
547		547
		548	#if __has_attribute(error) \|\| __GNUC_PREREQ__(4, 3)
		549	#define __error_attr(msg) __attribute__((__error__(msg)))
		550	#else
		551	#define __error_attr(msg)
		552	#endif
		553
		554	/* FORTIFY_SOURCE related defines. */
		555	#if __GNUC_PREREQ__(4, 1) && defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 && \
		556	defined(__OPTIMIZE__) && __OPTIMIZE__ > 0 && !defined(lint)
		557	#define __BSD_FORTIFY 1
		558	#if _FORTIFY_SOURCE >= 2
		559	#define __bos(s) __builtin_object_size((s), 1)
		560	#else
		561	#define __bos(s) __builtin_object_size((s), 0)
		562	#endif
		563	#define __bos0(s) __builtin_object_size((s), 0)
		564	#define __FORTIFY_INLINE extern __inline __always_inline __gnu_inline
		565	#endif /* !_FORTIFY_SOURCE */
		566	#define __FORTIFY_UNKNOWN_SIZE ((size_t) -1)
		567
548	/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */	568	/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
549	#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \	569	#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \
550	defined(__GNUC__) && !defined(__INTEL_COMPILER)	570	defined(__GNUC__) && !defined(__INTEL_COMPILER)

Removed Link Here

(-)a/lib/libc/sys/stack_protector_compat.c (-20 lines)
1	/*
2	* Written by Alexander Kabaev <kan@FreeBSD.org>
3	* The file is in public domain.
4	*/
5
6	#include <sys/cdefs.h>
7	__FBSDID("$FreeBSD$");
8
9	void __stack_chk_fail(void);
10
11	#ifdef PIC
12	void
13	__stack_chk_fail_local_hidden(void)
14	{
15
16	__stack_chk_fail();
17	}
18
19	__sym_compat(__stack_chk_fail_local, __stack_chk_fail_local_hidden, FBSD_1.0);
20	#endif

Removed Link Here

(-)a/lib/libc/sys/stack_protector.c (-117 lines)
1	/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $ */
2	/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $ */
3	/*
4	* Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.
15	*
16	* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
17	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19	* DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
20	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26	* POSSIBILITY OF SUCH DAMAGE.
27	*
28	*/
29
30	#include <sys/cdefs.h>
31	__FBSDID("$FreeBSD$");
32
33	#include <sys/param.h>
34	#include <sys/sysctl.h>
35	#include <sys/types.h>
36	#include <errno.h>
37	#include <link.h>
38	#include <signal.h>
39	#include <string.h>
40	#include <syslog.h>
41	#include <unistd.h>
42	#include "libc_private.h"
43
44	extern int __sysctl(const int name, u_int namelen, void oldp,
45	size_t oldlenp, void newp, size_t newlen);
46
47	long __stack_chk_guard[8] = {0, 0, 0, 0, 0, 0, 0, 0};
48	static void __guard_setup(void) __attribute__((__constructor__, __used__));
49	static void __fail(const char *);
50	void __stack_chk_fail(void);
51	void __chk_fail(void);
52
53	/LINTED used/
54	static void
55	__guard_setup(void)
56	{
57	static const int mib[2] = { CTL_KERN, KERN_ARND };
58	size_t len;
59	int error;
60
61	if (__stack_chk_guard[0] != 0)
62	return;
63	error = _elf_aux_info(AT_CANARY, __stack_chk_guard,
64	sizeof(__stack_chk_guard));
65	if (error == 0 && __stack_chk_guard[0] != 0)
66	return;
67
68	len = sizeof(__stack_chk_guard);
69	if (__sysctl(mib, nitems(mib), __stack_chk_guard, &len, NULL, 0) ==
70	-1 \|\| len != sizeof(__stack_chk_guard)) {
71	/* If sysctl was unsuccessful, use the "terminator canary". */
72	((unsigned char )(void )__stack_chk_guard)[0] = 0;
73	((unsigned char )(void )__stack_chk_guard)[1] = 0;
74	((unsigned char )(void )__stack_chk_guard)[2] = '\n';
75	((unsigned char )(void )__stack_chk_guard)[3] = 255;
76	}
77	}
78
79	/ARGSUSED/
80	static void
81	__fail(const char *msg)
82	{
83	struct sigaction sa;
84	sigset_t mask;
85
86	/* Immediately block all signal handlers from running code */
87	(void)sigfillset(&mask);
88	(void)sigdelset(&mask, SIGABRT);
89	(void)sigprocmask(SIG_BLOCK, &mask, NULL);
90
91	/* This may fail on a chroot jail... */
92	syslog(LOG_CRIT, "%s", msg);
93
94	(void)memset(&sa, 0, sizeof(sa));
95	(void)sigemptyset(&sa.sa_mask);
96	sa.sa_flags = 0;
97	sa.sa_handler = SIG_DFL;
98	(void)sigaction(SIGABRT, &sa, NULL);
99	(void)kill(getpid(), SIGABRT);
100	_exit(127);
101	}
102
103	void
104	__stack_chk_fail(void)
105	{
106	__fail("stack overflow detected; terminated");
107	}
108
109	void
110	__chk_fail(void)
111	{
112	__fail("buffer overflow detected; terminated");
113	}
114
115	#ifndef PIC
116	__weak_reference(__stack_chk_fail, __stack_chk_fail_local);
117	#endif

Added Link Here

(-)b/lib/libc/secure/stack_protector_compat.c (+20 lines)
1	/*
2	* Written by Alexander Kabaev <kan@FreeBSD.org>
3	* The file is in public domain.
4	*/
5
6	#include <sys/cdefs.h>
7	__FBSDID("$FreeBSD$");
8
9	void __stack_chk_fail(void);
10
11	#ifdef PIC
12	void
13	__stack_chk_fail_local_hidden(void)
14	{
15
16	__stack_chk_fail();
17	}
18
19	__sym_compat(__stack_chk_fail_local, __stack_chk_fail_local_hidden, FBSD_1.0);
20	#endif

Added Link Here

(-)b/lib/libc/secure/stack_protector.c (+89 lines)
1	/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $ */
2	/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $ */
3	/*
4	* Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.
15	*
16	* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
17	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19	* DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
20	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26	* POSSIBILITY OF SUCH DAMAGE.
27	*
28	*/
29
30	#include <sys/cdefs.h>
31	__FBSDID("$FreeBSD$");
32
33	#include <sys/param.h>
34	#include <sys/sysctl.h>
35	#include <sys/types.h>
36	#include <secure/security.h>
37	#include <link.h>
38	#include "libc_private.h"
39
40	extern int __sysctl(const int name, u_int namelen, void oldp,
41	size_t oldlenp, void newp, size_t newlen);
42
43	long __stack_chk_guard[8] = {0, 0, 0, 0, 0, 0, 0, 0};
44	static void __guard_setup(void) __attribute__((__constructor__, __used__));
45	void __stack_chk_fail(void) __dead2;
46
47	/LINTED used/
48	static void
49	__guard_setup(void)
50	{
51	static const int mib[2] = { CTL_KERN, KERN_ARND };
52	size_t len;
53	int error;
54
55	if (__stack_chk_guard[0] != 0)
56	return;
57	error = _elf_aux_info(AT_CANARY, __stack_chk_guard,
58	sizeof(__stack_chk_guard));
59	if (error == 0 && __stack_chk_guard[0] != 0)
60	return;
61
62	len = sizeof(__stack_chk_guard);
63	if (__sysctl(mib, nitems(mib), __stack_chk_guard, &len, NULL, 0) ==
64	-1 \|\| len != sizeof(__stack_chk_guard)) {
65	/* If sysctl was unsuccessful, use the "terminator canary". */
66	((unsigned char )(void )__stack_chk_guard)[0] = 0;
67	((unsigned char )(void )__stack_chk_guard)[1] = 0;
68	((unsigned char )(void )__stack_chk_guard)[2] = '\n';
69	((unsigned char )(void )__stack_chk_guard)[3] = 255;
70	}
71	}
72
73	void
74	__stack_chk_fail(void)
75	{
76
77	__secure_fail("stack overflow detected; terminated");
78	}
79
80	void
81	__chk_fail(void)
82	{
83
84	__secure_fail("buffer overflow detected; terminated");
85	}
86
87	#ifndef PIC
88	__weak_reference(__stack_chk_fail, __stack_chk_fail_local);
89	#endif

Added Link Here

(-)b/lib/libc/secure/secure_common.c (+75 lines)
1	/* $NetBSD: stack_protector.c,v 1.4 2006/11/22 17:23:25 christos Exp $ */
2	/* $OpenBSD: stack_protector.c,v 1.10 2006/03/31 05:34:44 deraadt Exp $ */
3	/*
4	* Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat.
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.
15	*
16	* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
17	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19	* DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
20	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26	* POSSIBILITY OF SUCH DAMAGE.
27	*
28	*/
29
30	#include <sys/cdefs.h>
31	__FBSDID("$FreeBSD$");
32
33	#include <sys/param.h>
34	#include <sys/sysctl.h>
35	#include <sys/types.h>
36	#include <errno.h>
37	#include <link.h>
38	#include <signal.h>
39	#include <string.h>
40	#include <syslog.h>
41	#include <unistd.h>
42	#include "libc_private.h"
43
44	static void __fail(const char *) __dead2;
45
46	/ARGSUSED/
47	static void
48	__fail(const char *msg)
49	{
50	struct sigaction sa;
51	sigset_t mask;
52
53	/* Immediately block all signal handlers from running code */
54	(void)sigfillset(&mask);
55	(void)sigdelset(&mask, SIGABRT);
56	(void)sigprocmask(SIG_BLOCK, &mask, NULL);
57
58	/* This may fail on a chroot jail... */
59	syslog(LOG_CRIT, "%s", msg);
60
61	(void)memset(&sa, 0, sizeof(sa));
62	(void)sigemptyset(&sa.sa_mask);
63	sa.sa_flags = 0;
64	sa.sa_handler = SIG_DFL;
65	(void)sigaction(SIGABRT, &sa, NULL);
66	(void)kill(getpid(), SIGABRT);
67	_exit(127);
68	}
69
70	void
71	__secure_fail(const char *msg)
72	{
73
74	__fail(msg);
75	}

Added Link Here

(-)b/lib/libc/secure/fortify_source.c (+47 lines)
1	/*-
2	* Copyright (c) 2015 Olivér Pintér <op@FreeBSD.org>
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	*
14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24	* SUCH DAMAGE.
25	*
26	* $FreeBSD$
27	*/
28
29	#include <sys/cdefs.h>
30	#include <sys/param.h>
31	#include <sys/sysctl.h>
32	#include <sys/types.h>
33	#include "secure/security.h"
34
35	void
36	__fortify_chk_fail(const char* msg)
37	{
38
39	__secure_fail(msg);
40	}
41
42	int
43	__fortify_chk_overlap(const void a, const void b, size_t len)
44	{
45
46	return ((a <= b && b <= a + len) \|\| (b <= a && a <= b + len));
47	}

Added Link Here

(-)b/lib/libc/secure/__vsprintf_chk.c (+78 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <stdio.h>
38	#include <stdlib.h>
39	#include <stdarg.h>
40	#include "secure/_stdio.h"
41
42	int
43	__vsprintf_chk(char * __restrict d, int flags, size_t bos, const char * __restrict fmt, __va_list va)
44	{
45	int result;
46
47	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
48	return (vsprintf(d, fmt, va));
49
50	result = vsnprintf(d, bos, fmt, va);
51	if ((size_t)result >= bos)
52	__fortify_chk_fail(
53	"vsprintf: prevented write past end of buffer");
54
55	return (result);
56	}
57
58
59	int
60	__sprintf_chk(char * __restrict d, int flags, size_t bos, const char * __restrict fmt, ...)
61	{
62	va_list va;
63	int result;
64
65	if (bos == __FORTIFY_UNKNOWN_SIZE) {
66	va_start(va, fmt);
67	result = vsprintf(d, fmt, va);
68	va_end(va);
69
70	return (result);
71	}
72
73	va_start(va, fmt);
74	result = __vsprintf_chk(d, flags, bos, fmt, va);
75	va_end(va);
76
77	return (result);
78	}

Added Link Here

(-)b/lib/libc/secure/__vsnprintf_chk.c (+76 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <stdio.h>
38	#include <stdlib.h>
39	#include <stdarg.h>
40	#include "secure/_stdio.h"
41
42	int
43	__vsnprintf_chk(char d, size_t n, int flags, size_t bos, const char fmt, va_list va)
44	{
45
46	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
47	return (vsnprintf(d, n, fmt, va));
48
49	if (__predict_false(n > bos))
50	__fortify_chk_fail(
51	"vsnprintf: prevented write past end of buffer");
52
53	return (vsnprintf(d, n, fmt, va));
54	}
55
56
57	int
58	__snprintf_chk(char d, size_t n, int flags, size_t bos, const char fmt, ...)
59	{
60	va_list va;
61	int result;
62
63	if (bos == __FORTIFY_UNKNOWN_SIZE) {
64	va_start(va, fmt);
65	result = vsnprintf(d, n, fmt, va);
66	va_end(va);
67
68	return (result);
69	}
70
71	va_start(va, fmt);
72	result = __vsnprintf_chk(d, n, flags, bos, fmt, va);
73	va_end(va);
74
75	return (result);
76	}

Added Link Here

(-)b/lib/libc/secure/__umask_chk.c (+53 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <sys/types.h>
38	#include <sys/stat.h>
39	#include <stdlib.h>
40	#include "secure/_stat.h"
41
42	/*
43	* Validate that umask is called with sane mode.
44	*/
45	mode_t
46	__umask_chk(mode_t mode)
47	{
48
49	if (__predict_false((mode & 0777) != mode))
50	__fortify_chk_fail("umask: called with invalid mask");
51
52	return (umask(mode));
53	}

Added Link Here

(-)b/lib/libc/secure/__strrchr_chk.c (+62 lines)
1	/*-
2	* Copyright (c) 1988 Regents of the University of California.
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
30	*
31	* $FreeBSD$
32	*/
33
34	#undef _FORTIFY_SOURCE
35
36	#include <sys/cdefs.h>
37	#include <secure/security.h>
38	#include <string.h>
39	#include "secure/_string.h"
40
41	char *
42	__strrchr_chk(const char *p, int ch, size_t bos)
43	{
44	char *save;
45
46	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
47	return (strrchr(p, ch));
48
49	for (save = NULL;; ++p, bos--) {
50	if (bos == 0)
51	__fortify_chk_fail(
52	"strrchr: prevented read past end of buffer");
53	if (*p == (char)ch)
54	save = (char *)p;
55	if (!*p)
56	return (save);
57	}
58	/* NOTREACHED */
59	}
60
61	__weak_reference(__strrchr_chk, __rindex_chk);
62

Added Link Here

(-)b/lib/libc/secure/__strncpy_chk.c (+97 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	char *
42	__strncpy_chk(char __restrict d, const char __restrict s, size_t n, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (strncpy(d, s, n));
47
48	if (__predict_false(n > bos))
49	__fortify_chk_fail(
50	"strncpy: prevented write past end of buffer");
51
52	return (strncpy(d, s, n));
53	}
54
55	/*
56	* __strncpy_chk2
57	*
58	* This is a variant of __strncpy_chk, but it also checks to make
59	* sure we don't read beyond the end of "src". The code for this is
60	* based on the original version of strncpy, but modified to check
61	* how much we read from "src" at the end of the copy operation.
62	*/
63	char *
64	__strncpy_chk2(char __restrict d, const char __restrict s, size_t n, size_t d_bos, size_t s_bos)
65	{
66	size_t s_copy_len;
67
68	if (__predict_false(d_bos == __FORTIFY_UNKNOWN_SIZE))
69	return (strncpy(d, s, n));
70
71	if (__predict_false(s_bos == __FORTIFY_UNKNOWN_SIZE))
72	return (__strncpy_chk(d, s, n, d_bos));
73
74	if (__predict_false(n > d_bos))
75	__fortify_chk_fail("strncpy: prevented write past end of buffer");
76
77	if (n != 0) {
78	char *_d = d;
79	const char *_s = s;
80
81	do {
82	if ((_d++ = _s++) == 0) {
83	/* NUL pad the remaining n-1 bytes */
84	while (--n != 0)
85	*_d++ = 0;
86	break;
87	}
88	} while (--n != 0);
89
90	s_copy_len = (size_t)(_s - s);
91
92	if (__predict_false(s_copy_len > s_bos))
93	__fortify_chk_fail("strncpy: prevented read past end of buffer");
94	}
95
96	return (d);
97	}

Added Link Here

(-)b/lib/libc/secure/__strncat_chk.c (+70 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	char *
42	__strncat_chk(char __restrict d, const char __restrict s, size_t n, size_t bos)
43	{
44	size_t d_len;
45	char *_d;
46
47	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
48	return (strncat(d, s, n));
49
50	if (n == 0)
51	return (d);
52
53	d_len = __strlen_chk(d, bos);
54	_d = d + d_len;
55	bos -= d_len;
56
57	while (*s != '\0') {
58	_d++ = s++;
59	n--;
60	bos--;
61
62	if (__predict_false(bos == 0))
63	__fortify_chk_fail("strncat: prevented write past end of buffer");
64	if (n == 0)
65	break;
66	}
67	*_d = '\0';
68
69	return (d);
70	}

Added Link Here

(-)b/lib/libc/secure/__strlen_chk.c (+67 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	/*
42	* This test is designed to detect code such as:
43	*
44	* int main() {
45	* char buf[10];
46	* memcpy(buf, "1234567890", sizeof(buf));
47	* size_t len = strlen(buf); // segfault here with _FORTIFY_SOURCE
48	* printf("%d\n", len);
49	* return 0;
50	* }
51	*
52	* or anytime strlen reads beyond an object boundary.
53	*/
54	size_t
55	__strlen_chk(const char *s, size_t bos)
56	{
57	size_t ret;
58
59	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
60	return (strlen(s));
61
62	ret = strlen(s);
63	if (__predict_false(ret >= bos))
64	__fortify_chk_fail("strlen: prevented read past end of buffer");
65
66	return (ret);
67	}

Added Link Here

(-)b/lib/libc/secure/__strlcpy_chk.c (+52 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	size_t
42	__strlcpy_chk(char d, const char s, size_t n, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (strlcpy(d, s, n));
47
48	if (__predict_false(n > bos))
49	__fortify_chk_fail("strlcpy: prevented write past end of buffer");
50
51	return (strlcpy(d, s, n));
52	}

Added Link Here

(-)b/lib/libc/secure/__strlcat_chk.c (+52 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	size_t
42	__strlcat_chk(char d, const char s, size_t n, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (strlcat(d, s, n));
47
48	if (__predict_false(n > bos))
49	__fortify_chk_fail("strlcat: prevented write past end of buffer");
50
51	return (strlcat(d, s, n));
52	}

Added Link Here

(-)b/lib/libc/secure/__strcpy_chk.c (+59 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	char *
42	__strcpy_chk(char d, const char s, size_t bos)
43	{
44	/* TODO: optimize so we don't scan s twice. */
45	size_t s_len;
46
47	/*
48	* Compiler doesn 't know destination size.
49	* Fallback to the original function.
50	*/
51	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
52	return (strcpy(d, s));
53
54	s_len = strlen(s) + 1;
55	if (__predict_false(s_len > bos))
56	__fortify_chk_fail("strcpy: prevented write past end of buffer");
57
58	return (strcpy(d, s));
59	}

Added Link Here

(-)b/lib/libc/secure/__strchrnul_chk.c (+59 lines)
1	/*-
2	* Copyright (c) 2015 Pinter Oliver
3	* Copyright (c) 1990 The Regents of the University of California.
4	* All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	* 3. Neither the name of the University nor the names of its contributors
15	* may be used to endorse or promote products derived from this software
16	* without specific prior written permission.
17	*
18	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28	* SUCH DAMAGE.
29	*
30	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
31	*
32	* $FreeBSD$
33	*/
34
35	#undef _FORTIFY_SOURCE
36
37	#include <sys/cdefs.h>
38	#include <secure/security.h>
39	#include <string.h>
40	#include "secure/_string.h"
41
42	char *
43	__strchrnul_chk(const char *p, int ch, size_t bos)
44	{
45
46	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
47	return (strchrnul(p, ch));
48
49	for (;; ++p, bos--) {
50	if (__predict_false(bos == 0))
51	__fortify_chk_fail(
52	"strchrnul: prevented read past end of buffer");
53	if (*p == (char)(ch))
54	return ((char *)(p));
55	if (*p == '\0')
56	return ((char *)(p));
57	}
58	/* NOTREACHED */
59	}

Added Link Here

(-)b/lib/libc/secure/__strchr_chk.c (+56 lines)
1	/*-
2	* Copyright (c) 1990 The Regents of the University of California.
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
30	*
31	* $FreeBSD$
32	*/
33
34	#undef _FORTIFY_SOURCE
35
36	#include <sys/cdefs.h>
37	#include <secure/security.h>
38	#include <string.h>
39	#include "secure/_string.h"
40
41	char *
42	__strchr_chk(const char *p, int ch, size_t bos)
43	{
44	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
45	return (strchr(p, ch));
46
47	for (;; ++p, bos--) {
48	if (__predict_false(bos == 0))
49	__fortify_chk_fail("strchr: prevented read past end of buffer");
50	if (*p == (char)(ch))
51	return ((char *)(p));
52	if (*p == '\0')
53	return (NULL);
54	}
55	/* NOTREACHED */
56	}

Added Link Here

(-)b/lib/libc/secure/__strcat_chk.c (+66 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	char *
42	__strcat_chk(char __restrict d, const char __restrict s, size_t bos)
43	{
44	char *save = d;
45	size_t d_len;
46
47	/*
48	* Compiler doesn 't know destination size.
49	* Fallback to the original function.
50	*/
51	if (bos == __FORTIFY_UNKNOWN_SIZE)
52	return (strcat(d, s));
53
54	d_len = __strlen_chk(d, bos);
55
56	d += d_len;
57	bos -= d_len;
58
59	while ((d++ = s++) != '\0') {
60	bos--;
61	if (__predict_false(bos == 0))
62	__fortify_chk_fail("strcat: prevented write past end of buffer");
63	}
64
65	return (save);
66	}

Added Link Here

(-)b/lib/libc/secure/__stpncpy_chk.c (+98 lines)
1	/*-
2	* Copyright (C) 2014 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33
34	#undef _FORTIFY_SOURCE
35
36	#include <sys/cdefs.h>
37	#include <secure/security.h>
38	#include <string.h>
39	#include <stdlib.h>
40	#include "secure/_string.h"
41
42	char *
43	__stpncpy_chk(char __restrict d, const char __restrict s, size_t n, size_t bos)
44	{
45
46	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
47	return (stpncpy(d, s, n));
48
49	if (__predict_false(n > bos))
50	__fortify_chk_fail("stpncpy: prevented write past end of buffer");
51
52	return stpncpy(d, s, n);
53	}
54
55	/*
56	* __stpncpy_chk2
57	*
58	* This is a variant of __stpncpy_chk, but it also checks to make
59	* sure we don't read beyond the end of "s". The code for this is
60	* based on the original version of stpncpy, but modified to check
61	* how much we read from "s" at the end of the copy operation.
62	*/
63	char *
64	__stpncpy_chk2(char __restrict d, const char __restrict s, size_t n, size_t d_bos, size_t s_bos)
65	{
66	char *_d;
67	const char *_s = s;
68	size_t s_copy_len ;
69
70	if (__predict_false(d_bos == __FORTIFY_UNKNOWN_SIZE))
71	return (stpncpy(d, s, n));
72
73	if (__predict_false(s_bos == __FORTIFY_UNKNOWN_SIZE))
74	return (__stpncpy_chk(d, s, n, d_bos));
75
76	if (__predict_false(n > d_bos))
77	__fortify_chk_fail("stpncpy: prevented write past end of buffer");
78
79	if (n != 0) {
80	_d = d;
81
82	do {
83	if ((_d++ = _s++) == 0) {
84	/* NUL pad the remaining n-1 bytes */
85	while (--n != 0)
86	*_d++ = 0;
87	break;
88	}
89	} while (--n != 0);
90
91	s_copy_len = (size_t)(_s - s);
92
93	if (__predict_false(s_copy_len > s_bos))
94	__fortify_chk_fail("stpncpy: prevented read past end of buffer");
95	}
96
97	return (d);
98	}

Added Link Here

(-)b/lib/libc/secure/__stpcpy_chk.c (+59 lines)
1	/*-
2	* Copyright (C) 2014 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: d807b9a12d3e49132b095df3d883618452033b51
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	char *
42	__stpcpy_chk(char dest, const char src, size_t bos)
43	{
44	/* TODO:optimize so we don't scan src twice. */
45	size_t src_len;
46
47	/*
48	* Compiler doesn 't know destination size.
49	* Fallback to the original function.
50	*/
51	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
52	return (stpcpy(dest, src));
53
54	src_len = strlen(src) + 1;
55	if (__predict_false(src_len > bos))
56	__fortify_chk_fail("stpcpy: prevented write past end of buffer");
57
58	return (stpcpy(dest, src));
59	}

Added Link Here

(-)b/lib/libc/secure/__recvfrom_chk.c (+53 lines)
1	/*-
2	* Copyright (C) 2013 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <sys/socket.h>
37	#include <secure/security.h>
38	#include "secure/_socket.h"
39
40	ssize_t
41	__recvfrom_chk(int s, void *buf, size_t len, size_t bos,
42	int flags, struct sockaddr * __restrict from,
43	socklen_t * __restrict fromlen)
44	{
45
46	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
47	return (recvfrom(s, buf, len, flags, from, fromlen));
48
49	if (__predict_false(len > bos))
50	__fortify_chk_fail("recvfrom: prevented write past end of buffer");
51
52	return (recvfrom(s, buf, len, flags, from, fromlen));
53	}

Added Link Here

(-)b/lib/libc/secure/__readlinkat_chk.c (+55 lines)
1	/*-
2	* Copyright (C) 2015 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <sys/limits.h>
37	#include <secure/security.h>
38	#include <unistd.h>
39	#include "secure/_unistd.h"
40
41	ssize_t
42	__readlinkat_chk(int dirfd, const char path, char buf, size_t size, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (readlinkat(dirfd, path, buf, size));
47
48	if (__predict_false(size > bos))
49	__fortify_chk_fail("readlinkat: prevented write past end of buffer");
50
51	if (__predict_false(size > SSIZE_MAX))
52	__fortify_chk_fail("readlinkat: size > SSIZE_MAX");
53
54	return (readlinkat(dirfd, path, buf, size));
55	}

Added Link Here

(-)b/lib/libc/secure/__readlink_chk.c (+55 lines)
1	/*-
2	* Copyright (C) 2015 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <sys/limits.h>
37	#include <secure/security.h>
38	#include <unistd.h>
39	#include "secure/_unistd.h"
40
41	ssize_t
42	__readlink_chk(const char path, char buf, size_t size, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (readlink(path, buf, size));
47
48	if (__predict_false(size > bos))
49	__fortify_chk_fail("readlink: prevented write past end of buffer");
50
51	if (__predict_false(size > SSIZE_MAX))
52	__fortify_chk_fail("readlink: size > SSIZE_MAX");
53
54	return (readlink(path, buf, size));
55	}

Added Link Here

(-)b/lib/libc/secure/__read_chk.c (+55 lines)
1	/*-
2	* Copyright (C) 2013 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* rev: a8993c994e45ec2dc00dcef15910560e22d67be9
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <sys/limits.h>
37	#include <secure/security.h>
38	#include <unistd.h>
39	#include "secure/_unistd.h"
40
41	ssize_t
42	__read_chk(int fd, void *buf, size_t count, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (read(fd, buf, count));
47
48	if (__predict_false(count > bos))
49	__fortify_chk_fail("read: prevented write past end of buffer");
50
51	if (__predict_false(count > SSIZE_MAX))
52	__fortify_chk_fail("read: count > SSIZE_MAX");
53
54	return (read(fd, buf, count));
55	}

Added Link Here

(-)b/lib/libc/secure/__pread_chk.c (+55 lines)
1	/*-
2	* Copyright (C) 2015 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: a8993c994e45ec2dc00dcef15910560e22d67be9
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <sys/limits.h>
37	#include <secure/security.h>
38	#include <unistd.h>
39	#include "secure/_unistd.h"
40
41	ssize_t
42	__pread_chk(int fd, void *buf, size_t count, off_t offset, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return (pread(fd, buf, count, offset));
47
48	if (__predict_false(count > bos))
49	__fortify_chk_fail("pread: prevented write past end of buffer");
50
51	if (__predict_false(count > SSIZE_MAX))
52	__fortify_chk_fail("pread: count > SSIZE_MAX");
53
54	return (pread(fd, buf, count, offset));
55	}

Added Link Here

(-)b/lib/libc/secure/__poll_chk.c (+64 lines)
1	/*
2	* Copyright (C) 2015 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: eeb9f5e41662828989f3913d81ec23229a668434
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <sys/poll.h>
38	#include "secure/_poll.h"
39
40	int
41	__poll_chk(struct pollfd *fds, nfds_t fd_count, int timeout, size_t bos)
42	{
43
44	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
45	return (poll(fds, fd_count, timeout));
46
47	if (__predict_false(bos / sizeof(*fds) < fd_count))
48	__fortify_chk_fail("poll: pollfd array smaller than fd count");
49
50	return (poll(fds, fd_count, timeout));
51	}
52
53	int
54	__ppoll_chk(struct pollfd fds, nfds_t fd_count, const struct timespec timeout, const sigset_t *mask, size_t bos)
55	{
56
57	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
58	return (ppoll(fds, fd_count, timeout, mask));
59
60	if (__predict_false(bos / sizeof(*fds) < fd_count))
61	__fortify_chk_fail("ppoll: pollfd array smaller than fd count");
62
63	return (ppoll(fds, fd_count, timeout, mask));
64	}

Added Link Here

(-)b/lib/libc/secure/__memset_chk.c (+52 lines)
1	/*-
2	* Copyright (C) 2012 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include <stdlib.h>
39	#include "secure/_string.h"
40
41	void *
42	__memset_chk(void *d, int c, size_t n, size_t bos)
43	{
44
45	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
46	return memset(d, c, n);
47
48	if (__predict_false(n > bos))
49	__fortify_chk_fail("memset: prevented write past end of buffer");
50
51	return memset(d, c, n);
52	}

Added Link Here

(-)b/lib/libc/secure/__memrchr_chk.c (+51 lines)
1	/*-
2	* Copyright (C) 2015 The Android Open Source Project
3	* All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* * Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in
12	* the documentation and/or other materials provided with the
13	* distribution.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22	* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26	* SUCH DAMAGE.
27	*
28	* bionic rev: 6cc98af72b0c48c58b2ab5fdb5f7abb842175299
29	*
30	* $FreeBSD$
31	*/
32
33	#undef _FORTIFY_SOURCE
34
35	#include <sys/cdefs.h>
36	#include <secure/security.h>
37	#include <string.h>
38	#include "secure/_string.h"
39
40	void *
41	__memrchr_chk(const void *s, int c, size_t n, size_t bos)
42	{
43
44	if (__predict_false(bos == __FORTIFY_UNKNOWN_SIZE))
45	return (memrchr(s, c, n));
46
47	if (__predict_false(n > bos))
48	__fortify_chk_fail("memrchr: prevented read past end of buffer");
49
50	return (memrchr(s, c, n));
51	}