From patchwork Wed Jan 5 01:39:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Siddhesh Poyarekar X-Patchwork-Id: 49541 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 695763858431 for ; Wed, 5 Jan 2022 01:41:46 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 695763858431 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1641346906; bh=rWiIVHqPcbTek2N9LM2fjt0TDjkq6LrScurm/SDcmWE=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=OQ82oB60l8dnr7UUOyNVaC52vPz4dy5GjU908NRe8/nW9gv1RxaBDzF7RGjyVdOyH n4CBl+Gq72OXoLHg2oVGV6lMqM8ds+D+ZyTj4aZbEhlrWjUfoPImYfJ1lYGeByeAt2 jGfRsDTGEFoE8vW005LJZ3O8I519iFAdd3NNcFLc= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from fossa.birch.relay.mailchannels.net (fossa.birch.relay.mailchannels.net [23.83.209.62]) by sourceware.org (Postfix) with ESMTPS id 5AD5F3858C2C for ; Wed, 5 Jan 2022 01:39:59 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5AD5F3858C2C X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id 4171720FAA for ; Wed, 5 Jan 2022 01:39:58 +0000 (UTC) Received: from pdx1-sub0-mail-a306.dreamhost.com (unknown [127.0.0.6]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id C6E44212CA for ; Wed, 5 Jan 2022 01:39:57 +0000 (UTC) X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from pdx1-sub0-mail-a306.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384) by 100.118.248.123 (trex/6.4.3); Wed, 05 Jan 2022 01:39:58 +0000 X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Cooing-Power: 0698bca94cb399fd_1641346798108_415747594 X-MC-Loop-Signature: 1641346798108:1146493321 X-MC-Ingress-Time: 1641346798108 Received: from rhbox.intra.reserved-bit.com (unknown [1.186.123.58]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a306.dreamhost.com (Postfix) with ESMTPSA id 4JTBxR4Xy3z1T for ; Tue, 4 Jan 2022 17:39:55 -0800 (PST) To: libc-alpha@sourceware.org Subject: [PATCH 1/2] debug: Refactor and expand _FORTIFY_SOURCE tests Date: Wed, 5 Jan 2022 07:09:45 +0530 Message-Id: <20220105013946.2646963-2-siddhesh@sourceware.org> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20220105013946.2646963-1-siddhesh@sourceware.org> References: <20220105013946.2646963-1-siddhesh@sourceware.org> MIME-Version: 1.0 X-Spam-Status: No, score=-3494.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_NONE, KAM_DMARC_STATUS, KAM_SHORT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H5, RCVD_IN_MSPIKE_WL, RCVD_IN_SBL, SPF_HELO_NONE, SPF_NEUTRAL, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Siddhesh Poyarekar via Libc-alpha From: Siddhesh Poyarekar Reply-To: Siddhesh Poyarekar Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Rename all debug/tst-chk* tests to reflect the fortification level they're testing and any additional macros so that rules for them can be autogenerated. tst-chk0* are without fortification, tst-chk1 for _FORTIFY_SOURCE=1 and so on. This allows easier replication of the tests to check additional macros. The change also expands the -lfs tests to include _FORTIFY_SOURCE=3. Signed-off-by: Siddhesh Poyarekar --- debug/Makefile | 75 +- debug/tst-chk0-lfs.c | 2 + debug/tst-chk0.c | 1726 ++++++++++++++++++ debug/tst-chk0cc-lfs.cc | 2 + debug/tst-chk0cc.cc | 1 + debug/{tst-lfschk1.c => tst-chk1-lfs.c} | 0 debug/tst-chk1.c | 1728 +------------------ debug/{tst-lfschk4.cc => tst-chk1cc-lfs.cc} | 0 debug/{tst-chk5.cc => tst-chk1cc.cc} | 2 +- debug/{tst-lfschk2.c => tst-chk2-lfs.c} | 0 debug/tst-chk2.c | 4 +- debug/{tst-lfschk5.cc => tst-chk2cc-lfs.cc} | 0 debug/{tst-chk6.cc => tst-chk2cc.cc} | 2 +- debug/{tst-lfschk3.c => tst-chk3-lfs.c} | 0 debug/tst-chk3.c | 4 +- debug/{tst-lfschk6.cc => tst-chk3cc-lfs.cc} | 0 debug/{tst-chk8.cc => tst-chk3cc.cc} | 2 +- debug/tst-chk4.cc | 1 - debug/tst-chk7.c | 2 - 19 files changed, 1773 insertions(+), 1778 deletions(-) create mode 100644 debug/tst-chk0-lfs.c create mode 100644 debug/tst-chk0.c create mode 100644 debug/tst-chk0cc-lfs.cc create mode 100644 debug/tst-chk0cc.cc rename debug/{tst-lfschk1.c => tst-chk1-lfs.c} (100%) rename debug/{tst-lfschk4.cc => tst-chk1cc-lfs.cc} (100%) rename debug/{tst-chk5.cc => tst-chk1cc.cc} (54%) rename debug/{tst-lfschk2.c => tst-chk2-lfs.c} (100%) rename debug/{tst-lfschk5.cc => tst-chk2cc-lfs.cc} (100%) rename debug/{tst-chk6.cc => tst-chk2cc.cc} (54%) rename debug/{tst-lfschk3.c => tst-chk3-lfs.c} (100%) rename debug/{tst-lfschk6.cc => tst-chk3cc-lfs.cc} (100%) rename debug/{tst-chk8.cc => tst-chk3cc.cc} (54%) delete mode 100644 debug/tst-chk4.cc delete mode 100644 debug/tst-chk7.c diff --git a/debug/Makefile b/debug/Makefile index bc37e466ee..fe94cd3072 100644 --- a/debug/Makefile +++ b/debug/Makefile @@ -1,4 +1,5 @@ # Copyright (C) 1998-2021 Free Software Foundation, Inc. +# Copyright The GNU Toolchain Authors. # This file is part of the GNU C Library. # The GNU C Library is free software; you can redistribute it and/or @@ -110,32 +111,31 @@ CFLAGS-tst-longjmp_chk3.c += -fexceptions -fasynchronous-unwind-tables CPPFLAGS-tst-longjmp_chk3.c += -D_FORTIFY_SOURCE=1 CPPFLAGS-tst-realpath-chk.c += -D_FORTIFY_SOURCE=2 +# _FORTIFY_SOURCE tests. +tests-chk = $(addprefix tst-chk, 0 1 2 3) +tests-chk-cc = $(addsuffix cc, $(tests-chk)) +tests-chk-lfs = $(addsuffix -lfs, $(tests-chk)) +tests-chk-cc-lfs = $(addsuffix -lfs, $(tests-chk-cc)) + # We know these tests have problems with format strings, this is what # we are testing. Disable that warning. They are also testing # deprecated functions (notably gets) so disable that warning as well. # And they also generate warnings from warning attributes, which # cannot be disabled via pragmas, so require -Wno-error to be used. -CFLAGS-tst-chk1.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk2.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk3.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk4.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk5.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk6.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk7.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-chk8.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk1.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk2.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk3.c += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk4.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk5.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -CFLAGS-tst-lfschk6.cc += -Wno-format -Wno-deprecated-declarations -Wno-error -LDLIBS-tst-chk4 = -lstdc++ -LDLIBS-tst-chk5 = -lstdc++ -LDLIBS-tst-chk6 = -lstdc++ -LDLIBS-tst-chk8 = -lstdc++ -LDLIBS-tst-lfschk4 = -lstdc++ -LDLIBS-tst-lfschk5 = -lstdc++ -LDLIBS-tst-lfschk6 = -lstdc++ +define disable-warnings +CFLAGS-$(1).$(2) += -Wno-format -Wno-deprecated-declarations -Wno-error +endef + +$(foreach t,$(tests-chk) $(tests-chk-lfs), \ + $(eval $(call disable-warnings,$(t),c))) + +$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs), \ + $(eval $(call disable-warnings,$(t),cc))) + +define link-cc +LDLIBS-$(1) = -lstdc++ +endef +$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs), $(eval $(call link-cc,$(t)))) # backtrace_symbols only works if we link with -rdynamic. backtrace # requires unwind tables on most architectures. @@ -152,19 +152,18 @@ LDFLAGS-tst-backtrace6 = -rdynamic CFLAGS-tst-ssp-1.c += -fstack-protector-all -tests = backtrace-tst tst-longjmp_chk tst-chk1 tst-chk2 tst-chk3 \ - tst-lfschk1 tst-lfschk2 tst-lfschk3 test-strcpy_chk test-stpcpy_chk \ - tst-chk4 tst-chk5 tst-chk6 tst-chk7 tst-chk8 tst-lfschk4 tst-lfschk5 \ - tst-lfschk6 tst-longjmp_chk2 tst-backtrace2 tst-backtrace3 \ - tst-backtrace4 tst-backtrace5 tst-backtrace6 tst-realpath-chk +tests = backtrace-tst tst-longjmp_chk \ + test-strcpy_chk test-stpcpy_chk \ + tst-longjmp_chk2 tst-backtrace2 tst-backtrace3 \ + tst-backtrace4 tst-backtrace5 tst-backtrace6 tst-realpath-chk \ + $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs) ifeq ($(have-ssp),yes) tests += tst-ssp-1 endif ifeq (,$(CXX)) -tests-unsupported = tst-chk4 tst-chk5 tst-chk6 tst-chk8 \ - tst-lfschk4 tst-lfschk5 tst-lfschk6 +tests-unsupported = $(tests-chk-cc) $(tests-chk-cc-lfs) endif extra-libs = libSegFault libpcprofile @@ -191,20 +190,12 @@ ifeq ($(run-built-tests),yes) LOCALES := de_DE.UTF-8 include ../gen-locales.mk -$(objpfx)tst-chk1.out: $(gen-locales) -$(objpfx)tst-chk2.out: $(gen-locales) -$(objpfx)tst-chk3.out: $(gen-locales) -$(objpfx)tst-chk4.out: $(gen-locales) -$(objpfx)tst-chk5.out: $(gen-locales) -$(objpfx)tst-chk6.out: $(gen-locales) -$(objpfx)tst-chk7.out: $(gen-locales) -$(objpfx)tst-chk8.out: $(gen-locales) -$(objpfx)tst-lfschk1.out: $(gen-locales) -$(objpfx)tst-lfschk2.out: $(gen-locales) -$(objpfx)tst-lfschk3.out: $(gen-locales) -$(objpfx)tst-lfschk4.out: $(gen-locales) -$(objpfx)tst-lfschk5.out: $(gen-locales) -$(objpfx)tst-lfschk6.out: $(gen-locales) +define chk-gen-locales +$(objpfx)$(1).out: $(gen-locales) +endef +$(foreach t, \ + $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs), \ + $(eval $(call link-cc,$(t)))) endif sLIBdir := $(shell echo $(slibdir) | sed 's,lib\(\|64\)$$,\\\\$$LIB,') diff --git a/debug/tst-chk0-lfs.c b/debug/tst-chk0-lfs.c new file mode 100644 index 0000000000..2460b6baad --- /dev/null +++ b/debug/tst-chk0-lfs.c @@ -0,0 +1,2 @@ +#define _FILE_OFFSET_BITS 64 +#include "tst-chk0.c" diff --git a/debug/tst-chk0.c b/debug/tst-chk0.c new file mode 100644 index 0000000000..d11e536f87 --- /dev/null +++ b/debug/tst-chk0.c @@ -0,0 +1,1726 @@ +/* Copyright (C) 2004-2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* This file tests gets. Force it to be declared. */ +#include +#undef __GLIBC_USE_DEPRECATED_GETS +#define __GLIBC_USE_DEPRECATED_GETS 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define obstack_chunk_alloc malloc +#define obstack_chunk_free free + +char *temp_filename; +static void do_prepare (void); +static int do_test (void); +#define PREPARE(argc, argv) do_prepare () +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +static void +do_prepare (void) +{ + int temp_fd = create_temp_file ("tst-chk1.", &temp_filename); + if (temp_fd == -1) + { + printf ("cannot create temporary file: %m\n"); + exit (1); + } + + const char *strs = "abcdefgh\nABCDEFGHI\nabcdefghij\nABCDEFGHIJ"; + if ((size_t) write (temp_fd, strs, strlen (strs)) != strlen (strs)) + { + puts ("could not write test strings into file"); + unlink (temp_filename); + exit (1); + } +} + +volatile int chk_fail_ok; +volatile int ret; +jmp_buf chk_fail_buf; + +static void +handler (int sig) +{ + if (chk_fail_ok) + { + chk_fail_ok = 0; + longjmp (chk_fail_buf, 1); + } + else + _exit (127); +} + +#if __USE_FORTIFY_LEVEL == 3 +volatile size_t buf_size = 10; +#else +char buf[10]; +wchar_t wbuf[10]; +#define buf_size sizeof (buf) +#endif + +volatile size_t l0; +volatile char *p; +volatile wchar_t *wp; +const char *str1 = "JIHGFEDCBA"; +const char *str2 = "F"; +const char *str3 = "%s%n%s%n"; +const char *str4 = "Hello, "; +const char *str5 = "World!\n"; +const wchar_t *wstr1 = L"JIHGFEDCBA"; +const wchar_t *wstr2 = L"F"; +const wchar_t *wstr3 = L"%s%n%s%n"; +const wchar_t *wstr4 = L"Hello, "; +const wchar_t *wstr5 = L"World!\n"; +char buf2[10] = "%s"; +int num1 = 67; +int num2 = 987654; + +#define FAIL() \ + do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) +#define CHK_FAIL_START \ + chk_fail_ok = 1; \ + if (! setjmp (chk_fail_buf)) \ + { +#define CHK_FAIL_END \ + chk_fail_ok = 0; \ + FAIL (); \ + } +#if __USE_FORTIFY_LEVEL >= 2 && (!defined __cplusplus || defined __va_arg_pack) +# define CHK_FAIL2_START CHK_FAIL_START +# define CHK_FAIL2_END CHK_FAIL_END +#else +# define CHK_FAIL2_START +# define CHK_FAIL2_END +#endif + +static int +do_test (void) +{ +#if __USE_FORTIFY_LEVEL == 3 + char *buf = (char *) malloc (buf_size); + wchar_t *wbuf = (wchar_t *) malloc (buf_size * sizeof (wchar_t)); +#endif + set_fortify_handler (handler); + + struct A { char buf1[9]; char buf2[1]; } a; + struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa; + + printf ("Test checking routines at fortify level %d\n", +#ifdef __USE_FORTIFY_LEVEL + (int) __USE_FORTIFY_LEVEL +#else + 0 +#endif + ); + +#if defined __USE_FORTIFY_LEVEL && !defined __fortify_function + printf ("Test skipped"); + if (l0 == 0) + return 0; +#endif + + /* These ops can be done without runtime checking of object size. */ + memcpy (buf, "abcdefghij", 10); + memmove (buf + 1, buf, 9); + if (memcmp (buf, "aabcdefghi", 10)) + FAIL (); + + memcpy (buf, "abcdefghij", 10); + bcopy (buf, buf + 1, 9); + if (memcmp (buf, "aabcdefghi", 10)) + FAIL (); + + if (mempcpy (buf + 5, "abcde", 5) != buf + 10 + || memcmp (buf, "aabcdabcde", 10)) + FAIL (); + + memset (buf + 8, 'j', 2); + if (memcmp (buf, "aabcdabcjj", 10)) + FAIL (); + + bzero (buf + 8, 2); + if (memcmp (buf, "aabcdabc\0\0", 10)) + FAIL (); + + explicit_bzero (buf + 6, 4); + if (memcmp (buf, "aabcda\0\0\0\0", 10)) + FAIL (); + + strcpy (buf + 4, "EDCBA"); + if (memcmp (buf, "aabcEDCBA", 10)) + FAIL (); + + if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10)) + FAIL (); + + strncpy (buf + 6, "X", 4); + if (memcmp (buf, "aabcEDX\0\0", 10)) + FAIL (); + + if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10)) + FAIL (); + + if (snprintf (buf + 7, 3, "%s", "987654") != 6 + || memcmp (buf, "aabcEDX98", 10)) + FAIL (); + + /* These ops need runtime checking, but shouldn't __chk_fail. */ + memcpy (buf, "abcdefghij", l0 + 10); + memmove (buf + 1, buf, l0 + 9); + if (memcmp (buf, "aabcdefghi", 10)) + FAIL (); + + memcpy (buf, "abcdefghij", l0 + 10); + bcopy (buf, buf + 1, l0 + 9); + if (memcmp (buf, "aabcdefghi", 10)) + FAIL (); + + if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10 + || memcmp (buf, "aabcdabcde", 10)) + FAIL (); + + memset (buf + 8, 'j', l0 + 2); + if (memcmp (buf, "aabcdabcjj", 10)) + FAIL (); + + bzero (buf + 8, l0 + 2); + if (memcmp (buf, "aabcdabc\0\0", 10)) + FAIL (); + + explicit_bzero (buf + 6, l0 + 4); + if (memcmp (buf, "aabcda\0\0\0\0", 10)) + FAIL (); + + strcpy (buf + 4, str1 + 5); + if (memcmp (buf, "aabcEDCBA", 10)) + FAIL (); + + if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10)) + FAIL (); + + strncpy (buf + 6, "X", l0 + 4); + if (memcmp (buf, "aabcEDX\0\0", 10)) + FAIL (); + + if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7 + || memcmp (buf, "aabcEcd\0\0", 10)) + FAIL (); + + if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10)) + FAIL (); + + if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10)) + FAIL (); + + buf[l0 + 8] = '\0'; + strcat (buf, "A"); + if (memcmp (buf, "aabcEcd9A", 10)) + FAIL (); + + buf[l0 + 7] = '\0'; + strncat (buf, "ZYXWV", l0 + 2); + if (memcmp (buf, "aabcEcdZY", 10)) + FAIL (); + + /* The following tests are supposed to succeed at all fortify + levels, even though they overflow a.buf1 into a.buf2. */ + memcpy (a.buf1, "abcdefghij", l0 + 10); + memmove (a.buf1 + 1, a.buf1, l0 + 9); + if (memcmp (a.buf1, "aabcdefghi", 10)) + FAIL (); + + memcpy (a.buf1, "abcdefghij", l0 + 10); + bcopy (a.buf1, a.buf1 + 1, l0 + 9); + if (memcmp (a.buf1, "aabcdefghi", 10)) + FAIL (); + + if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10 + || memcmp (a.buf1, "aabcdabcde", 10)) + FAIL (); + + memset (a.buf1 + 8, 'j', l0 + 2); + if (memcmp (a.buf1, "aabcdabcjj", 10)) + FAIL (); + + bzero (a.buf1 + 8, l0 + 2); + if (memcmp (a.buf1, "aabcdabc\0\0", 10)) + FAIL (); + + explicit_bzero (a.buf1 + 6, l0 + 4); + if (memcmp (a.buf1, "aabcda\0\0\0\0", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL < 2 + /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2 + and sufficient GCC support, as the string operations overflow + from a.buf1 into a.buf2. */ + strcpy (a.buf1 + 4, str1 + 5); + if (memcmp (a.buf1, "aabcEDCBA", 10)) + FAIL (); + + if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9 + || memcmp (a.buf1, "aabcEDCBF", 10)) + FAIL (); + + strncpy (a.buf1 + 6, "X", l0 + 4); + if (memcmp (a.buf1, "aabcEDX\0\0", 10)) + FAIL (); + + if (sprintf (a.buf1 + 7, "%d", num1) != 2 + || memcmp (a.buf1, "aabcEDX67", 10)) + FAIL (); + + if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6 + || memcmp (a.buf1, "aabcEDX98", 10)) + FAIL (); + + a.buf1[l0 + 8] = '\0'; + strcat (a.buf1, "A"); + if (memcmp (a.buf1, "aabcEDX9A", 10)) + FAIL (); + + a.buf1[l0 + 7] = '\0'; + strncat (a.buf1, "ZYXWV", l0 + 2); + if (memcmp (a.buf1, "aabcEDXZY", 10)) + FAIL (); + +#endif + +#if __USE_FORTIFY_LEVEL >= 1 + /* Now check if all buffer overflows are caught at runtime. + N.B. All tests involving a length parameter need to be done + twice: once with the length a compile-time constant, once without. */ + + CHK_FAIL_START + memcpy (buf + 1, "abcdefghij", 10); + CHK_FAIL_END + + CHK_FAIL_START + memcpy (buf + 1, "abcdefghij", l0 + 10); + CHK_FAIL_END + + CHK_FAIL_START + memmove (buf + 2, buf + 1, 9); + CHK_FAIL_END + + CHK_FAIL_START + memmove (buf + 2, buf + 1, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + bcopy (buf + 1, buf + 2, 9); + CHK_FAIL_END + + CHK_FAIL_START + bcopy (buf + 1, buf + 2, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + p = (char *) mempcpy (buf + 6, "abcde", 5); + CHK_FAIL_END + + CHK_FAIL_START + p = (char *) mempcpy (buf + 6, "abcde", l0 + 5); + CHK_FAIL_END + + CHK_FAIL_START + memset (buf + 9, 'j', 2); + CHK_FAIL_END + + CHK_FAIL_START + memset (buf + 9, 'j', l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + bzero (buf + 9, 2); + CHK_FAIL_END + + CHK_FAIL_START + bzero (buf + 9, l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + explicit_bzero (buf + 9, 2); + CHK_FAIL_END + + CHK_FAIL_START + explicit_bzero (buf + 9, l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + strcpy (buf + 5, str1 + 5); + CHK_FAIL_END + + CHK_FAIL_START + p = stpcpy (buf + 9, str2); + CHK_FAIL_END + + CHK_FAIL_START + strncpy (buf + 7, "X", 4); + CHK_FAIL_END + + CHK_FAIL_START + strncpy (buf + 7, "X", l0 + 4); + CHK_FAIL_END + + CHK_FAIL_START + stpncpy (buf + 6, "cd", 5); + CHK_FAIL_END + + CHK_FAIL_START + stpncpy (buf + 6, "cd", l0 + 5); + CHK_FAIL_END + +# if !defined __cplusplus || defined __va_arg_pack + CHK_FAIL_START + sprintf (buf + 8, "%d", num1); + CHK_FAIL_END + + CHK_FAIL_START + snprintf (buf + 8, 3, "%d", num2); + CHK_FAIL_END + + CHK_FAIL_START + snprintf (buf + 8, l0 + 3, "%d", num2); + CHK_FAIL_END + + CHK_FAIL_START + swprintf (wbuf + 8, 3, L"%d", num1); + CHK_FAIL_END + + CHK_FAIL_START + swprintf (wbuf + 8, l0 + 3, L"%d", num1); + CHK_FAIL_END +# endif + + memcpy (buf, str1 + 2, 9); + CHK_FAIL_START + strcat (buf, "AB"); + CHK_FAIL_END + + memcpy (buf, str1 + 3, 8); + CHK_FAIL_START + strncat (buf, "ZYXWV", 3); + CHK_FAIL_END + + memcpy (buf, str1 + 3, 8); + CHK_FAIL_START + strncat (buf, "ZYXWV", l0 + 3); + CHK_FAIL_END + + CHK_FAIL_START + memcpy (a.buf1 + 1, "abcdefghij", 10); + CHK_FAIL_END + + CHK_FAIL_START + memcpy (a.buf1 + 1, "abcdefghij", l0 + 10); + CHK_FAIL_END + + CHK_FAIL_START + memmove (a.buf1 + 2, a.buf1 + 1, 9); + CHK_FAIL_END + + CHK_FAIL_START + memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + bcopy (a.buf1 + 1, a.buf1 + 2, 9); + CHK_FAIL_END + + CHK_FAIL_START + bcopy (a.buf1 + 1, a.buf1 + 2, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + p = (char *) mempcpy (a.buf1 + 6, "abcde", 5); + CHK_FAIL_END + + CHK_FAIL_START + p = (char *) mempcpy (a.buf1 + 6, "abcde", l0 + 5); + CHK_FAIL_END + + CHK_FAIL_START + memset (a.buf1 + 9, 'j', 2); + CHK_FAIL_END + + CHK_FAIL_START + memset (a.buf1 + 9, 'j', l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + bzero (a.buf1 + 9, 2); + CHK_FAIL_END + + CHK_FAIL_START + bzero (a.buf1 + 9, l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + explicit_bzero (a.buf1 + 9, 2); + CHK_FAIL_END + + CHK_FAIL_START + explicit_bzero (a.buf1 + 9, l0 + 2); + CHK_FAIL_END + +# if __USE_FORTIFY_LEVEL >= 2 +# define O 0 +# else +# define O 1 +# endif + + CHK_FAIL_START + strcpy (a.buf1 + (O + 4), str1 + 5); + CHK_FAIL_END + + CHK_FAIL_START + p = stpcpy (a.buf1 + (O + 8), str2); + CHK_FAIL_END + + CHK_FAIL_START + strncpy (a.buf1 + (O + 6), "X", 4); + CHK_FAIL_END + + CHK_FAIL_START + strncpy (a.buf1 + (O + 6), "X", l0 + 4); + CHK_FAIL_END + +# if !defined __cplusplus || defined __va_arg_pack + CHK_FAIL_START + sprintf (a.buf1 + (O + 7), "%d", num1); + CHK_FAIL_END + + CHK_FAIL_START + snprintf (a.buf1 + (O + 7), 3, "%d", num2); + CHK_FAIL_END + + CHK_FAIL_START + snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2); + CHK_FAIL_END +# endif + + memcpy (a.buf1, str1 + (3 - O), 8 + O); + CHK_FAIL_START + strcat (a.buf1, "AB"); + CHK_FAIL_END + + memcpy (a.buf1, str1 + (4 - O), 7 + O); + CHK_FAIL_START + strncat (a.buf1, "ZYXWV", l0 + 3); + CHK_FAIL_END +#endif + + + /* These ops can be done without runtime checking of object size. */ + wmemcpy (wbuf, L"abcdefghij", 10); + wmemmove (wbuf + 1, wbuf, 9); + if (wmemcmp (wbuf, L"aabcdefghi", 10)) + FAIL (); + + if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10 + || wmemcmp (wbuf, L"aabcdabcde", 10)) + FAIL (); + + wmemset (wbuf + 8, L'j', 2); + if (wmemcmp (wbuf, L"aabcdabcjj", 10)) + FAIL (); + + wcscpy (wbuf + 4, L"EDCBA"); + if (wmemcmp (wbuf, L"aabcEDCBA", 10)) + FAIL (); + + if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10)) + FAIL (); + + wcsncpy (wbuf + 6, L"X", 4); + if (wmemcmp (wbuf, L"aabcEDX\0\0", 10)) + FAIL (); + + if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0 + || wmemcmp (wbuf, L"aabcEDX98", 10)) + FAIL (); + + if (swprintf (wbuf + 7, 3, L"64") != 2 + || wmemcmp (wbuf, L"aabcEDX64", 10)) + FAIL (); + + /* These ops need runtime checking, but shouldn't __chk_fail. */ + wmemcpy (wbuf, L"abcdefghij", l0 + 10); + wmemmove (wbuf + 1, wbuf, l0 + 9); + if (wmemcmp (wbuf, L"aabcdefghi", 10)) + FAIL (); + + if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10 + || wmemcmp (wbuf, L"aabcdabcde", 10)) + FAIL (); + + wmemset (wbuf + 8, L'j', l0 + 2); + if (wmemcmp (wbuf, L"aabcdabcjj", 10)) + FAIL (); + + wcscpy (wbuf + 4, wstr1 + 5); + if (wmemcmp (wbuf, L"aabcEDCBA", 10)) + FAIL (); + + if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10)) + FAIL (); + + wcsncpy (wbuf + 6, L"X", l0 + 4); + if (wmemcmp (wbuf, L"aabcEDX\0\0", 10)) + FAIL (); + + if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7 + || wmemcmp (wbuf, L"aabcEcd\0\0", 10)) + FAIL (); + + if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0 + || wmemcmp (wbuf, L"aabcEcd98", 10)) + FAIL (); + + wbuf[l0 + 8] = L'\0'; + wcscat (wbuf, L"A"); + if (wmemcmp (wbuf, L"aabcEcd9A", 10)) + FAIL (); + + wbuf[l0 + 7] = L'\0'; + wcsncat (wbuf, L"ZYXWV", l0 + 2); + if (wmemcmp (wbuf, L"aabcEcdZY", 10)) + FAIL (); + + wmemcpy (wa.buf1, L"abcdefghij", l0 + 10); + wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9); + if (wmemcmp (wa.buf1, L"aabcdefghi", 10)) + FAIL (); + + if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10 + || wmemcmp (wa.buf1, L"aabcdabcde", 10)) + FAIL (); + + wmemset (wa.buf1 + 8, L'j', l0 + 2); + if (wmemcmp (wa.buf1, L"aabcdabcjj", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL < 2 + /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2 + and sufficient GCC support, as the string operations overflow + from a.buf1 into a.buf2. */ + wcscpy (wa.buf1 + 4, wstr1 + 5); + if (wmemcmp (wa.buf1, L"aabcEDCBA", 10)) + FAIL (); + + if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9 + || wmemcmp (wa.buf1, L"aabcEDCBF", 10)) + FAIL (); + + wcsncpy (wa.buf1 + 6, L"X", l0 + 4); + if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10)) + FAIL (); + + if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0 + || wmemcmp (wa.buf1, L"aabcEDX98", 10)) + FAIL (); + + wa.buf1[l0 + 8] = L'\0'; + wcscat (wa.buf1, L"A"); + if (wmemcmp (wa.buf1, L"aabcEDX9A", 10)) + FAIL (); + + wa.buf1[l0 + 7] = L'\0'; + wcsncat (wa.buf1, L"ZYXWV", l0 + 2); + if (wmemcmp (wa.buf1, L"aabcEDXZY", 10)) + FAIL (); + +#endif + +#if __USE_FORTIFY_LEVEL >= 1 + /* Now check if all buffer overflows are caught at runtime. + N.B. All tests involving a length parameter need to be done + twice: once with the length a compile-time constant, once without. */ + + CHK_FAIL_START + wmemcpy (wbuf + 1, L"abcdefghij", 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemcpy (wbuf + 9, L"abcdefghij", 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemcpy (wbuf + 9, L"abcdefghij", l0 + 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemmove (wbuf + 2, wbuf + 1, 9); + CHK_FAIL_END + + CHK_FAIL_START + wmemmove (wbuf + 2, wbuf + 1, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + wp = wmempcpy (wbuf + 6, L"abcde", 5); + CHK_FAIL_END + + CHK_FAIL_START + wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5); + CHK_FAIL_END + + CHK_FAIL_START + wmemset (wbuf + 9, L'j', 2); + CHK_FAIL_END + + CHK_FAIL_START + wmemset (wbuf + 9, L'j', l0 + 2); + CHK_FAIL_END + + CHK_FAIL_START + wcscpy (wbuf + 5, wstr1 + 5); + CHK_FAIL_END + + CHK_FAIL_START + wp = wcpcpy (wbuf + 9, wstr2); + CHK_FAIL_END + + CHK_FAIL_START + wcsncpy (wbuf + 7, L"X", 4); + CHK_FAIL_END + + CHK_FAIL_START + wcsncpy (wbuf + 7, L"X", l0 + 4); + CHK_FAIL_END + + CHK_FAIL_START + wcsncpy (wbuf + 9, L"XABCDEFGH", 8); + CHK_FAIL_END + + CHK_FAIL_START + wcpncpy (wbuf + 9, L"XABCDEFGH", 8); + CHK_FAIL_END + + CHK_FAIL_START + wcpncpy (wbuf + 6, L"cd", 5); + CHK_FAIL_END + + CHK_FAIL_START + wcpncpy (wbuf + 6, L"cd", l0 + 5); + CHK_FAIL_END + + wmemcpy (wbuf, wstr1 + 2, 9); + CHK_FAIL_START + wcscat (wbuf, L"AB"); + CHK_FAIL_END + + wmemcpy (wbuf, wstr1 + 3, 8); + CHK_FAIL_START + wcsncat (wbuf, L"ZYXWV", l0 + 3); + CHK_FAIL_END + + CHK_FAIL_START + wmemcpy (wa.buf1 + 1, L"abcdefghij", 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10); + CHK_FAIL_END + + CHK_FAIL_START + wmemmove (wa.buf1 + 2, wa.buf1 + 1, 9); + CHK_FAIL_END + + CHK_FAIL_START + wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9); + CHK_FAIL_END + + CHK_FAIL_START + wp = wmempcpy (wa.buf1 + 6, L"abcde", 5); + CHK_FAIL_END + + CHK_FAIL_START + wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5); + CHK_FAIL_END + + CHK_FAIL_START + wmemset (wa.buf1 + 9, L'j', 2); + CHK_FAIL_END + + CHK_FAIL_START + wmemset (wa.buf1 + 9, L'j', l0 + 2); + CHK_FAIL_END + +#if __USE_FORTIFY_LEVEL >= 2 +# define O 0 +#else +# define O 1 +#endif + + CHK_FAIL_START + wcscpy (wa.buf1 + (O + 4), wstr1 + 5); + CHK_FAIL_END + + CHK_FAIL_START + wp = wcpcpy (wa.buf1 + (O + 8), wstr2); + CHK_FAIL_END + + CHK_FAIL_START + wcsncpy (wa.buf1 + (O + 6), L"X", 4); + CHK_FAIL_END + + CHK_FAIL_START + wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4); + CHK_FAIL_END + + wmemcpy (wa.buf1, wstr1 + (3 - O), 8 + O); + CHK_FAIL_START + wcscat (wa.buf1, L"AB"); + CHK_FAIL_END + + wmemcpy (wa.buf1, wstr1 + (4 - O), 7 + O); + CHK_FAIL_START + wcsncat (wa.buf1, L"ZYXWV", l0 + 3); + CHK_FAIL_END +#endif + + + /* Now checks for %n protection. */ + + /* Constant literals passed directly are always ok + (even with warnings about possible bugs from GCC). */ + int n1, n2; + if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2 + || n1 != 1 || n2 != 2) + FAIL (); + + /* In this case the format string is not known at compile time, + but resides in read-only memory, so is ok. */ + if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2 + || n1 != 1 || n2 != 2) + FAIL (); + + strcpy (buf2 + 2, "%n%s%n"); + /* When the format string is writable and contains %n, + with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ + CHK_FAIL2_START + if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2) + FAIL (); + CHK_FAIL2_END + + CHK_FAIL2_START + if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2) + FAIL (); + CHK_FAIL2_END + + /* But if there is no %n, even writable format string + should work. */ + buf2[6] = '\0'; + if (sprintf (buf, buf2 + 4, str2) != 1) + FAIL (); + + /* Constant literals passed directly are always ok + (even with warnings about possible bugs from GCC). */ + if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14 + || n1 != 7 || n2 != 14) + FAIL (); + + /* In this case the format string is not known at compile time, + but resides in read-only memory, so is ok. */ + if (printf (str3, str4, &n1, str5, &n2) != 14 + || n1 != 7 || n2 != 14) + FAIL (); + + strcpy (buf2 + 2, "%n%s%n"); + /* When the format string is writable and contains %n, + with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ + CHK_FAIL2_START + if (printf (buf2, str4, &n1, str5, &n1) != 14) + FAIL (); + CHK_FAIL2_END + + /* But if there is no %n, even writable format string + should work. */ + buf2[6] = '\0'; + if (printf (buf2 + 4, str5) != 7) + FAIL (); + + FILE *fp = stdout; + + /* Constant literals passed directly are always ok + (even with warnings about possible bugs from GCC). */ + if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14 + || n1 != 7 || n2 != 14) + FAIL (); + + /* In this case the format string is not known at compile time, + but resides in read-only memory, so is ok. */ + if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14 + || n1 != 7 || n2 != 14) + FAIL (); + + strcpy (buf2 + 2, "%n%s%n"); + /* When the format string is writable and contains %n, + with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ + CHK_FAIL2_START + if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14) + FAIL (); + CHK_FAIL2_END + + /* But if there is no %n, even writable format string + should work. */ + buf2[6] = '\0'; + if (fprintf (fp, buf2 + 4, str5) != 7) + FAIL (); + + char *my_ptr = NULL; + strcpy (buf2 + 2, "%n%s%n"); + /* When the format string is writable and contains %n, + with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ + CHK_FAIL2_START + if (asprintf (&my_ptr, buf2, str4, &n1, str5, &n1) != 14) + FAIL (); + else + free (my_ptr); + CHK_FAIL2_END + + struct obstack obs; + obstack_init (&obs); + CHK_FAIL2_START + if (obstack_printf (&obs, buf2, str4, &n1, str5, &n1) != 14) + FAIL (); + CHK_FAIL2_END + obstack_free (&obs, NULL); + + my_ptr = NULL; + if (asprintf (&my_ptr, "%s%n%s%n", str4, &n1, str5, &n1) != 14) + FAIL (); + else + free (my_ptr); + + obstack_init (&obs); + if (obstack_printf (&obs, "%s%n%s%n", str4, &n1, str5, &n1) != 14) + FAIL (); + obstack_free (&obs, NULL); + + if (freopen (temp_filename, "r", stdin) == NULL) + { + puts ("could not open temporary file"); + exit (1); + } + + if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9)) + FAIL (); + if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (gets (buf) != buf) + FAIL (); + CHK_FAIL_END +#endif + + rewind (stdin); + + if (fgets (buf, buf_size, stdin) != buf + || memcmp (buf, "abcdefgh\n", 10)) + FAIL (); + if (fgets (buf, buf_size, stdin) != buf || memcmp (buf, "ABCDEFGHI", 10)) + FAIL (); + + rewind (stdin); + + if (fgets (buf, l0 + buf_size, stdin) != buf + || memcmp (buf, "abcdefgh\n", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (fgets (buf, buf_size + 1, stdin) != buf) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (fgets (buf, l0 + buf_size + 1, stdin) != buf) + FAIL (); + CHK_FAIL_END +#endif + + rewind (stdin); + + if (fgets_unlocked (buf, buf_size, stdin) != buf + || memcmp (buf, "abcdefgh\n", 10)) + FAIL (); + if (fgets_unlocked (buf, buf_size, stdin) != buf + || memcmp (buf, "ABCDEFGHI", 10)) + FAIL (); + + rewind (stdin); + + if (fgets_unlocked (buf, l0 + buf_size, stdin) != buf + || memcmp (buf, "abcdefgh\n", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (fgets_unlocked (buf, buf_size + 1, stdin) != buf) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (fgets_unlocked (buf, l0 + buf_size + 1, stdin) != buf) + FAIL (); + CHK_FAIL_END +#endif + + rewind (stdin); + + if (fread (buf, 1, buf_size, stdin) != buf_size + || memcmp (buf, "abcdefgh\nA", 10)) + FAIL (); + if (fread (buf, buf_size, 1, stdin) != 1 + || memcmp (buf, "BCDEFGHI\na", 10)) + FAIL (); + + rewind (stdin); + + if (fread (buf, l0 + 1, buf_size, stdin) != buf_size + || memcmp (buf, "abcdefgh\nA", 10)) + FAIL (); + if (fread (buf, buf_size, l0 + 1, stdin) != 1 + || memcmp (buf, "BCDEFGHI\na", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (fread (buf, 1, buf_size + 1, stdin) != buf_size + 1) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (fread (buf, buf_size + 1, l0 + 1, stdin) != 1) + FAIL (); + CHK_FAIL_END +#endif + + rewind (stdin); + + if (fread_unlocked (buf, 1, buf_size, stdin) != buf_size + || memcmp (buf, "abcdefgh\nA", 10)) + FAIL (); + if (fread_unlocked (buf, buf_size, 1, stdin) != 1 + || memcmp (buf, "BCDEFGHI\na", 10)) + FAIL (); + + rewind (stdin); + + if (fread_unlocked (buf, 1, 4, stdin) != 4 + || memcmp (buf, "abcdFGHI\na", 10)) + FAIL (); + if (fread_unlocked (buf, 4, 1, stdin) != 1 + || memcmp (buf, "efghFGHI\na", 10)) + FAIL (); + + rewind (stdin); + + if (fread_unlocked (buf, l0 + 1, buf_size, stdin) != buf_size + || memcmp (buf, "abcdefgh\nA", 10)) + FAIL (); + if (fread_unlocked (buf, buf_size, l0 + 1, stdin) != 1 + || memcmp (buf, "BCDEFGHI\na", 10)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (fread_unlocked (buf, 1, buf_size + 1, stdin) != buf_size + 1) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (fread_unlocked (buf, buf_size + 1, l0 + 1, stdin) != 1) + FAIL (); + CHK_FAIL_END +#endif + + lseek (fileno (stdin), 0, SEEK_SET); + + if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1 + || memcmp (buf, "abcdefgh\n", 9)) + FAIL (); + if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1 + || memcmp (buf, "ABCDEFGHI", 9)) + FAIL (); + + lseek (fileno (stdin), 0, SEEK_SET); + + if (read (fileno (stdin), buf, l0 + buf_size - 1) != buf_size - 1 + || memcmp (buf, "abcdefgh\n", 9)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (read (fileno (stdin), buf, buf_size + 1) != buf_size + 1) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (read (fileno (stdin), buf, l0 + buf_size + 1) != buf_size + 1) + FAIL (); + CHK_FAIL_END +#endif + + if (pread (fileno (stdin), buf, buf_size - 1, buf_size - 2) + != buf_size - 1 + || memcmp (buf, "\nABCDEFGH", 9)) + FAIL (); + if (pread (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1 + || memcmp (buf, "abcdefgh\n", 9)) + FAIL (); + if (pread (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3) + != buf_size - 1 + || memcmp (buf, "h\nABCDEFG", 9)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (pread (fileno (stdin), buf, buf_size + 1, 2 * buf_size) + != buf_size + 1) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (pread (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size) + != buf_size + 1) + FAIL (); + CHK_FAIL_END +#endif + + if (pread64 (fileno (stdin), buf, buf_size - 1, buf_size - 2) + != buf_size - 1 + || memcmp (buf, "\nABCDEFGH", 9)) + FAIL (); + if (pread64 (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1 + || memcmp (buf, "abcdefgh\n", 9)) + FAIL (); + if (pread64 (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3) + != buf_size - 1 + || memcmp (buf, "h\nABCDEFG", 9)) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (pread64 (fileno (stdin), buf, buf_size + 1, 2 * buf_size) + != buf_size + 1) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (pread64 (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size) + != buf_size + 1) + FAIL (); + CHK_FAIL_END +#endif + + if (freopen (temp_filename, "r", stdin) == NULL) + { + puts ("could not open temporary file"); + exit (1); + } + + if (fseek (stdin, 9 + 10 + 11, SEEK_SET)) + { + puts ("could not seek in test file"); + exit (1); + } + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (gets (buf) != buf) + FAIL (); + CHK_FAIL_END +#endif + + /* Check whether missing N$ formats are detected. */ + CHK_FAIL2_START + printf ("%3$d\n", 1, 2, 3, 4); + CHK_FAIL2_END + + CHK_FAIL2_START + fprintf (stdout, "%3$d\n", 1, 2, 3, 4); + CHK_FAIL2_END + + CHK_FAIL2_START + sprintf (buf, "%3$d\n", 1, 2, 3, 4); + CHK_FAIL2_END + + CHK_FAIL2_START + snprintf (buf, buf_size, "%3$d\n", 1, 2, 3, 4); + CHK_FAIL2_END + + int sp[2]; + if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp)) + FAIL (); + else + { + const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n"; + if ((size_t) send (sp[0], sendstr, strlen (sendstr), 0) + != strlen (sendstr)) + FAIL (); + + char recvbuf[12]; + if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK) + != sizeof recvbuf + || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0) + FAIL (); + + if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK) + != sizeof recvbuf - 7 + || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK) + != sizeof recvbuf) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK) + != sizeof recvbuf - 3) + FAIL (); + CHK_FAIL_END +#endif + + socklen_t sl; + struct sockaddr_un sa_un; + + sl = sizeof (sa_un); + if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK, + (struct sockaddr *) &sa_un, &sl) + != sizeof recvbuf + || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0) + FAIL (); + + sl = sizeof (sa_un); + if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK, + (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 7 + || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + sl = sizeof (sa_un); + if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK, + (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + sl = sizeof (sa_un); + if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK, + (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 3) + FAIL (); + CHK_FAIL_END +#endif + + close (sp[0]); + close (sp[1]); + } + + char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo"; + char *enddir = strchr (fname, '\0'); + if (mkdtemp (fname) == NULL) + { + printf ("mkdtemp failed: %m\n"); + return 1; + } + *enddir = '/'; + if (symlink ("bar", fname) != 0) + FAIL (); + + char readlinkbuf[4]; + if (readlink (fname, readlinkbuf, 4) != 3 + || memcmp (readlinkbuf, "bar", 3) != 0) + FAIL (); + if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3 + || memcmp (readlinkbuf, "bbar", 4) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (readlink (fname, readlinkbuf + 3, 4) != 3) + FAIL (); + CHK_FAIL_END +#endif + + int tmpfd = open ("/tmp", O_RDONLY | O_DIRECTORY); + if (tmpfd < 0) + FAIL (); + + if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf, 4) != 3 + || memcmp (readlinkbuf, "bar", 3) != 0) + FAIL (); + if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 1, + l0 + 3) != 3 + || memcmp (readlinkbuf, "bbar", 4) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 2, + l0 + 3) != 3) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 3, + 4) != 3) + FAIL (); + CHK_FAIL_END +#endif + + close (tmpfd); + + char *cwd1 = getcwd (NULL, 0); + if (cwd1 == NULL) + FAIL (); + + char *cwd2 = getcwd (NULL, 250); + if (cwd2 == NULL) + FAIL (); + + if (cwd1 && cwd2) + { + if (strcmp (cwd1, cwd2) != 0) + FAIL (); + + *enddir = '\0'; + if (chdir (fname)) + FAIL (); + + char *cwd3 = getcwd (NULL, 0); + if (cwd3 == NULL) + FAIL (); + if (strcmp (fname, cwd3) != 0) + printf ("getcwd after chdir is '%s' != '%s'," + "get{c,}wd tests skipped\n", cwd3, fname); + else + { + char getcwdbuf[sizeof fname - 3]; + + char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf); + if (cwd4 != getcwdbuf + || strcmp (getcwdbuf, fname) != 0) + FAIL (); + + cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1); + if (cwd4 != getcwdbuf + 1 + || getcwdbuf[0] != fname[0] + || strcmp (getcwdbuf + 1, fname) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf) + != getcwdbuf + 2) + FAIL (); + CHK_FAIL_END + + CHK_FAIL_START + if (getcwd (getcwdbuf + 2, sizeof getcwdbuf) + != getcwdbuf + 2) + FAIL (); + CHK_FAIL_END +#endif + + if (getwd (getcwdbuf) != getcwdbuf + || strcmp (getcwdbuf, fname) != 0) + FAIL (); + + if (getwd (getcwdbuf + 1) != getcwdbuf + 1 + || strcmp (getcwdbuf + 1, fname) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + if (getwd (getcwdbuf + 2) != getcwdbuf + 2) + FAIL (); + CHK_FAIL_END +#endif + } + + if (chdir (cwd1) != 0) + FAIL (); + free (cwd3); + } + + free (cwd1); + free (cwd2); + *enddir = '/'; + if (unlink (fname) != 0) + FAIL (); + + *enddir = '\0'; + if (rmdir (fname) != 0) + FAIL (); + + +#if PATH_MAX > 0 + char largebuf[PATH_MAX]; + char *realres = realpath (".", largebuf); + if (realres != largebuf) + FAIL (); + +# if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char realbuf[1]; + realres = realpath (".", realbuf); + if (realres != realbuf) + FAIL (); + CHK_FAIL_END +# endif +#endif + + if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL) + { + assert (MB_CUR_MAX <= 10); + + /* First a simple test. */ + char enough[10]; + if (wctomb (enough, L'A') != 1) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + /* We know the wchar_t encoding is ISO 10646. So pick a + character which has a multibyte representation which does not + fit. */ + CHK_FAIL_START + char smallbuf[2]; + if (wctomb (smallbuf, L'\x100') != 2) + FAIL (); + CHK_FAIL_END +#endif + + mbstate_t s; + memset (&s, '\0', sizeof (s)); + if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D') + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + /* We know the wchar_t encoding is ISO 10646. So pick a + character which has a multibyte representation which does not + fit. */ + CHK_FAIL_START + char smallbuf[2]; + if (wcrtomb (smallbuf, L'\x100', &s) != 2) + FAIL (); + CHK_FAIL_END +#endif + + wchar_t wenough[10]; + memset (&s, '\0', sizeof (s)); + const char *cp = "A"; + if (mbsrtowcs (wenough, &cp, 10, &s) != 1 + || wcscmp (wenough, L"A") != 0) + FAIL (); + + cp = "BC"; + if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2 + || wcscmp (wenough, L"BC") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + wchar_t wsmallbuf[2]; + cp = "ABC"; + mbsrtowcs (wsmallbuf, &cp, 10, &s); + CHK_FAIL_END +#endif + + cp = "A"; + if (mbstowcs (wenough, cp, 10) != 1 + || wcscmp (wenough, L"A") != 0) + FAIL (); + + cp = "DEF"; + if (mbstowcs (wenough, cp, l0 + 10) != 3 + || wcscmp (wenough, L"DEF") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + wchar_t wsmallbuf[2]; + cp = "ABC"; + mbstowcs (wsmallbuf, cp, 10); + CHK_FAIL_END +#endif + + memset (&s, '\0', sizeof (s)); + cp = "ABC"; + wcscpy (wenough, L"DEF"); + if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1 + || wcscmp (wenough, L"AEF") != 0) + FAIL (); + + cp = "IJ"; + if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1 + || wcscmp (wenough, L"IEF") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + wchar_t wsmallbuf[2]; + cp = "ABC"; + mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s); + CHK_FAIL_END +#endif + + memset (&s, '\0', sizeof (s)); + const wchar_t *wcp = L"A"; + if (wcsrtombs (enough, &wcp, 10, &s) != 1 + || strcmp (enough, "A") != 0) + FAIL (); + + wcp = L"BC"; + if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2 + || strcmp (enough, "BC") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[2]; + wcp = L"ABC"; + wcsrtombs (smallbuf, &wcp, 10, &s); + CHK_FAIL_END +#endif + + memset (enough, 'Z', sizeof (enough)); + wcp = L"EF"; + if (wcstombs (enough, wcp, 10) != 2 + || strcmp (enough, "EF") != 0) + FAIL (); + + wcp = L"G"; + if (wcstombs (enough, wcp, l0 + 10) != 1 + || strcmp (enough, "G") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[2]; + wcp = L"ABC"; + wcstombs (smallbuf, wcp, 10); + CHK_FAIL_END +#endif + + memset (&s, '\0', sizeof (s)); + wcp = L"AB"; + if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1 + || strcmp (enough, "A") != 0) + FAIL (); + + wcp = L"BCD"; + if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1 + || strcmp (enough, "B") != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[2]; + wcp = L"ABC"; + wcsnrtombs (smallbuf, &wcp, 3, 10, &s); + CHK_FAIL_END +#endif + } + else + { + puts ("cannot set locale"); + ret = 1; + } + + int fd = posix_openpt (O_RDWR); + if (fd != -1) + { + char enough[1000]; + if (ptsname_r (fd, enough, sizeof (enough)) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[2]; + if (ptsname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0) + FAIL (); + CHK_FAIL_END +#endif + close (fd); + } + +#if PATH_MAX > 0 + confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf)); +# if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[1]; + confstr (_CS_GNU_LIBC_VERSION, smallbuf, sizeof (largebuf)); + CHK_FAIL_END +# endif +#endif + + gid_t grpslarge[5]; + int ngr = getgroups (5, grpslarge); + asm volatile ("" : : "r" (ngr)); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[1]; + ngr = getgroups (5, (gid_t *) smallbuf); + asm volatile ("" : : "r" (ngr)); + CHK_FAIL_END +#endif + + fd = open (_PATH_TTY, O_RDONLY); + if (fd != -1) + { + char enough[1000]; + if (ttyname_r (fd, enough, sizeof (enough)) != 0) + FAIL (); + +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[2]; + if (ttyname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0) + FAIL (); + CHK_FAIL_END +#endif + close (fd); + } + + char hostnamelarge[1000]; + gethostname (hostnamelarge, sizeof (hostnamelarge)); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[1]; + gethostname (smallbuf, sizeof (hostnamelarge)); + CHK_FAIL_END +#endif + + char loginlarge[1000]; + getlogin_r (loginlarge, sizeof (hostnamelarge)); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[1]; + getlogin_r (smallbuf, sizeof (loginlarge)); + CHK_FAIL_END +#endif + + char domainnamelarge[1000]; + int res = getdomainname (domainnamelarge, sizeof (domainnamelarge)); + asm volatile ("" : : "r" (res)); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + char smallbuf[1]; + res = getdomainname (smallbuf, sizeof (domainnamelarge)); + asm volatile ("" : : "r" (res)); + CHK_FAIL_END +#endif + + fd_set s; + FD_ZERO (&s); + + FD_SET (FD_SETSIZE - 1, &s); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + FD_SET (FD_SETSIZE, &s); + CHK_FAIL_END + + CHK_FAIL_START + FD_SET (l0 + FD_SETSIZE, &s); + CHK_FAIL_END +#endif + + FD_CLR (FD_SETSIZE - 1, &s); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + FD_CLR (FD_SETSIZE, &s); + CHK_FAIL_END + + CHK_FAIL_START + FD_SET (l0 + FD_SETSIZE, &s); + CHK_FAIL_END +#endif + + FD_ISSET (FD_SETSIZE - 1, &s); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + FD_ISSET (FD_SETSIZE, &s); + CHK_FAIL_END + + CHK_FAIL_START + FD_ISSET (l0 + FD_SETSIZE, &s); + CHK_FAIL_END +#endif + + struct pollfd fds[1]; + fds[0].fd = STDOUT_FILENO; + fds[0].events = POLLOUT; + poll (fds, 1, 0); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + poll (fds, 2, 0); + CHK_FAIL_END + + CHK_FAIL_START + poll (fds, l0 + 2, 0); + CHK_FAIL_END +#endif + ppoll (fds, 1, NULL, NULL); +#if __USE_FORTIFY_LEVEL >= 1 + CHK_FAIL_START + ppoll (fds, 2, NULL, NULL); + CHK_FAIL_END + + CHK_FAIL_START + ppoll (fds, l0 + 2, NULL, NULL); + CHK_FAIL_END +#endif + + return ret; +} diff --git a/debug/tst-chk0cc-lfs.cc b/debug/tst-chk0cc-lfs.cc new file mode 100644 index 0000000000..2460b6baad --- /dev/null +++ b/debug/tst-chk0cc-lfs.cc @@ -0,0 +1,2 @@ +#define _FILE_OFFSET_BITS 64 +#include "tst-chk0.c" diff --git a/debug/tst-chk0cc.cc b/debug/tst-chk0cc.cc new file mode 100644 index 0000000000..c467a9f84b --- /dev/null +++ b/debug/tst-chk0cc.cc @@ -0,0 +1 @@ +#include "tst-chk0.c" diff --git a/debug/tst-lfschk1.c b/debug/tst-chk1-lfs.c similarity index 100% rename from debug/tst-lfschk1.c rename to debug/tst-chk1-lfs.c diff --git a/debug/tst-chk1.c b/debug/tst-chk1.c index d11e536f87..c09b01df34 100644 --- a/debug/tst-chk1.c +++ b/debug/tst-chk1.c @@ -1,1726 +1,2 @@ -/* Copyright (C) 2004-2021 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - . */ - -/* This file tests gets. Force it to be declared. */ -#include -#undef __GLIBC_USE_DEPRECATED_GETS -#define __GLIBC_USE_DEPRECATED_GETS 1 - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#define obstack_chunk_alloc malloc -#define obstack_chunk_free free - -char *temp_filename; -static void do_prepare (void); -static int do_test (void); -#define PREPARE(argc, argv) do_prepare () -#define TEST_FUNCTION do_test () -#include "../test-skeleton.c" - -static void -do_prepare (void) -{ - int temp_fd = create_temp_file ("tst-chk1.", &temp_filename); - if (temp_fd == -1) - { - printf ("cannot create temporary file: %m\n"); - exit (1); - } - - const char *strs = "abcdefgh\nABCDEFGHI\nabcdefghij\nABCDEFGHIJ"; - if ((size_t) write (temp_fd, strs, strlen (strs)) != strlen (strs)) - { - puts ("could not write test strings into file"); - unlink (temp_filename); - exit (1); - } -} - -volatile int chk_fail_ok; -volatile int ret; -jmp_buf chk_fail_buf; - -static void -handler (int sig) -{ - if (chk_fail_ok) - { - chk_fail_ok = 0; - longjmp (chk_fail_buf, 1); - } - else - _exit (127); -} - -#if __USE_FORTIFY_LEVEL == 3 -volatile size_t buf_size = 10; -#else -char buf[10]; -wchar_t wbuf[10]; -#define buf_size sizeof (buf) -#endif - -volatile size_t l0; -volatile char *p; -volatile wchar_t *wp; -const char *str1 = "JIHGFEDCBA"; -const char *str2 = "F"; -const char *str3 = "%s%n%s%n"; -const char *str4 = "Hello, "; -const char *str5 = "World!\n"; -const wchar_t *wstr1 = L"JIHGFEDCBA"; -const wchar_t *wstr2 = L"F"; -const wchar_t *wstr3 = L"%s%n%s%n"; -const wchar_t *wstr4 = L"Hello, "; -const wchar_t *wstr5 = L"World!\n"; -char buf2[10] = "%s"; -int num1 = 67; -int num2 = 987654; - -#define FAIL() \ - do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0) -#define CHK_FAIL_START \ - chk_fail_ok = 1; \ - if (! setjmp (chk_fail_buf)) \ - { -#define CHK_FAIL_END \ - chk_fail_ok = 0; \ - FAIL (); \ - } -#if __USE_FORTIFY_LEVEL >= 2 && (!defined __cplusplus || defined __va_arg_pack) -# define CHK_FAIL2_START CHK_FAIL_START -# define CHK_FAIL2_END CHK_FAIL_END -#else -# define CHK_FAIL2_START -# define CHK_FAIL2_END -#endif - -static int -do_test (void) -{ -#if __USE_FORTIFY_LEVEL == 3 - char *buf = (char *) malloc (buf_size); - wchar_t *wbuf = (wchar_t *) malloc (buf_size * sizeof (wchar_t)); -#endif - set_fortify_handler (handler); - - struct A { char buf1[9]; char buf2[1]; } a; - struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa; - - printf ("Test checking routines at fortify level %d\n", -#ifdef __USE_FORTIFY_LEVEL - (int) __USE_FORTIFY_LEVEL -#else - 0 -#endif - ); - -#if defined __USE_FORTIFY_LEVEL && !defined __fortify_function - printf ("Test skipped"); - if (l0 == 0) - return 0; -#endif - - /* These ops can be done without runtime checking of object size. */ - memcpy (buf, "abcdefghij", 10); - memmove (buf + 1, buf, 9); - if (memcmp (buf, "aabcdefghi", 10)) - FAIL (); - - memcpy (buf, "abcdefghij", 10); - bcopy (buf, buf + 1, 9); - if (memcmp (buf, "aabcdefghi", 10)) - FAIL (); - - if (mempcpy (buf + 5, "abcde", 5) != buf + 10 - || memcmp (buf, "aabcdabcde", 10)) - FAIL (); - - memset (buf + 8, 'j', 2); - if (memcmp (buf, "aabcdabcjj", 10)) - FAIL (); - - bzero (buf + 8, 2); - if (memcmp (buf, "aabcdabc\0\0", 10)) - FAIL (); - - explicit_bzero (buf + 6, 4); - if (memcmp (buf, "aabcda\0\0\0\0", 10)) - FAIL (); - - strcpy (buf + 4, "EDCBA"); - if (memcmp (buf, "aabcEDCBA", 10)) - FAIL (); - - if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10)) - FAIL (); - - strncpy (buf + 6, "X", 4); - if (memcmp (buf, "aabcEDX\0\0", 10)) - FAIL (); - - if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10)) - FAIL (); - - if (snprintf (buf + 7, 3, "%s", "987654") != 6 - || memcmp (buf, "aabcEDX98", 10)) - FAIL (); - - /* These ops need runtime checking, but shouldn't __chk_fail. */ - memcpy (buf, "abcdefghij", l0 + 10); - memmove (buf + 1, buf, l0 + 9); - if (memcmp (buf, "aabcdefghi", 10)) - FAIL (); - - memcpy (buf, "abcdefghij", l0 + 10); - bcopy (buf, buf + 1, l0 + 9); - if (memcmp (buf, "aabcdefghi", 10)) - FAIL (); - - if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10 - || memcmp (buf, "aabcdabcde", 10)) - FAIL (); - - memset (buf + 8, 'j', l0 + 2); - if (memcmp (buf, "aabcdabcjj", 10)) - FAIL (); - - bzero (buf + 8, l0 + 2); - if (memcmp (buf, "aabcdabc\0\0", 10)) - FAIL (); - - explicit_bzero (buf + 6, l0 + 4); - if (memcmp (buf, "aabcda\0\0\0\0", 10)) - FAIL (); - - strcpy (buf + 4, str1 + 5); - if (memcmp (buf, "aabcEDCBA", 10)) - FAIL (); - - if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10)) - FAIL (); - - strncpy (buf + 6, "X", l0 + 4); - if (memcmp (buf, "aabcEDX\0\0", 10)) - FAIL (); - - if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7 - || memcmp (buf, "aabcEcd\0\0", 10)) - FAIL (); - - if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10)) - FAIL (); - - if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10)) - FAIL (); - - buf[l0 + 8] = '\0'; - strcat (buf, "A"); - if (memcmp (buf, "aabcEcd9A", 10)) - FAIL (); - - buf[l0 + 7] = '\0'; - strncat (buf, "ZYXWV", l0 + 2); - if (memcmp (buf, "aabcEcdZY", 10)) - FAIL (); - - /* The following tests are supposed to succeed at all fortify - levels, even though they overflow a.buf1 into a.buf2. */ - memcpy (a.buf1, "abcdefghij", l0 + 10); - memmove (a.buf1 + 1, a.buf1, l0 + 9); - if (memcmp (a.buf1, "aabcdefghi", 10)) - FAIL (); - - memcpy (a.buf1, "abcdefghij", l0 + 10); - bcopy (a.buf1, a.buf1 + 1, l0 + 9); - if (memcmp (a.buf1, "aabcdefghi", 10)) - FAIL (); - - if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10 - || memcmp (a.buf1, "aabcdabcde", 10)) - FAIL (); - - memset (a.buf1 + 8, 'j', l0 + 2); - if (memcmp (a.buf1, "aabcdabcjj", 10)) - FAIL (); - - bzero (a.buf1 + 8, l0 + 2); - if (memcmp (a.buf1, "aabcdabc\0\0", 10)) - FAIL (); - - explicit_bzero (a.buf1 + 6, l0 + 4); - if (memcmp (a.buf1, "aabcda\0\0\0\0", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL < 2 - /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2 - and sufficient GCC support, as the string operations overflow - from a.buf1 into a.buf2. */ - strcpy (a.buf1 + 4, str1 + 5); - if (memcmp (a.buf1, "aabcEDCBA", 10)) - FAIL (); - - if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9 - || memcmp (a.buf1, "aabcEDCBF", 10)) - FAIL (); - - strncpy (a.buf1 + 6, "X", l0 + 4); - if (memcmp (a.buf1, "aabcEDX\0\0", 10)) - FAIL (); - - if (sprintf (a.buf1 + 7, "%d", num1) != 2 - || memcmp (a.buf1, "aabcEDX67", 10)) - FAIL (); - - if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6 - || memcmp (a.buf1, "aabcEDX98", 10)) - FAIL (); - - a.buf1[l0 + 8] = '\0'; - strcat (a.buf1, "A"); - if (memcmp (a.buf1, "aabcEDX9A", 10)) - FAIL (); - - a.buf1[l0 + 7] = '\0'; - strncat (a.buf1, "ZYXWV", l0 + 2); - if (memcmp (a.buf1, "aabcEDXZY", 10)) - FAIL (); - -#endif - -#if __USE_FORTIFY_LEVEL >= 1 - /* Now check if all buffer overflows are caught at runtime. - N.B. All tests involving a length parameter need to be done - twice: once with the length a compile-time constant, once without. */ - - CHK_FAIL_START - memcpy (buf + 1, "abcdefghij", 10); - CHK_FAIL_END - - CHK_FAIL_START - memcpy (buf + 1, "abcdefghij", l0 + 10); - CHK_FAIL_END - - CHK_FAIL_START - memmove (buf + 2, buf + 1, 9); - CHK_FAIL_END - - CHK_FAIL_START - memmove (buf + 2, buf + 1, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - bcopy (buf + 1, buf + 2, 9); - CHK_FAIL_END - - CHK_FAIL_START - bcopy (buf + 1, buf + 2, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - p = (char *) mempcpy (buf + 6, "abcde", 5); - CHK_FAIL_END - - CHK_FAIL_START - p = (char *) mempcpy (buf + 6, "abcde", l0 + 5); - CHK_FAIL_END - - CHK_FAIL_START - memset (buf + 9, 'j', 2); - CHK_FAIL_END - - CHK_FAIL_START - memset (buf + 9, 'j', l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - bzero (buf + 9, 2); - CHK_FAIL_END - - CHK_FAIL_START - bzero (buf + 9, l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - explicit_bzero (buf + 9, 2); - CHK_FAIL_END - - CHK_FAIL_START - explicit_bzero (buf + 9, l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - strcpy (buf + 5, str1 + 5); - CHK_FAIL_END - - CHK_FAIL_START - p = stpcpy (buf + 9, str2); - CHK_FAIL_END - - CHK_FAIL_START - strncpy (buf + 7, "X", 4); - CHK_FAIL_END - - CHK_FAIL_START - strncpy (buf + 7, "X", l0 + 4); - CHK_FAIL_END - - CHK_FAIL_START - stpncpy (buf + 6, "cd", 5); - CHK_FAIL_END - - CHK_FAIL_START - stpncpy (buf + 6, "cd", l0 + 5); - CHK_FAIL_END - -# if !defined __cplusplus || defined __va_arg_pack - CHK_FAIL_START - sprintf (buf + 8, "%d", num1); - CHK_FAIL_END - - CHK_FAIL_START - snprintf (buf + 8, 3, "%d", num2); - CHK_FAIL_END - - CHK_FAIL_START - snprintf (buf + 8, l0 + 3, "%d", num2); - CHK_FAIL_END - - CHK_FAIL_START - swprintf (wbuf + 8, 3, L"%d", num1); - CHK_FAIL_END - - CHK_FAIL_START - swprintf (wbuf + 8, l0 + 3, L"%d", num1); - CHK_FAIL_END -# endif - - memcpy (buf, str1 + 2, 9); - CHK_FAIL_START - strcat (buf, "AB"); - CHK_FAIL_END - - memcpy (buf, str1 + 3, 8); - CHK_FAIL_START - strncat (buf, "ZYXWV", 3); - CHK_FAIL_END - - memcpy (buf, str1 + 3, 8); - CHK_FAIL_START - strncat (buf, "ZYXWV", l0 + 3); - CHK_FAIL_END - - CHK_FAIL_START - memcpy (a.buf1 + 1, "abcdefghij", 10); - CHK_FAIL_END - - CHK_FAIL_START - memcpy (a.buf1 + 1, "abcdefghij", l0 + 10); - CHK_FAIL_END - - CHK_FAIL_START - memmove (a.buf1 + 2, a.buf1 + 1, 9); - CHK_FAIL_END - - CHK_FAIL_START - memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - bcopy (a.buf1 + 1, a.buf1 + 2, 9); - CHK_FAIL_END - - CHK_FAIL_START - bcopy (a.buf1 + 1, a.buf1 + 2, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - p = (char *) mempcpy (a.buf1 + 6, "abcde", 5); - CHK_FAIL_END - - CHK_FAIL_START - p = (char *) mempcpy (a.buf1 + 6, "abcde", l0 + 5); - CHK_FAIL_END - - CHK_FAIL_START - memset (a.buf1 + 9, 'j', 2); - CHK_FAIL_END - - CHK_FAIL_START - memset (a.buf1 + 9, 'j', l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - bzero (a.buf1 + 9, 2); - CHK_FAIL_END - - CHK_FAIL_START - bzero (a.buf1 + 9, l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - explicit_bzero (a.buf1 + 9, 2); - CHK_FAIL_END - - CHK_FAIL_START - explicit_bzero (a.buf1 + 9, l0 + 2); - CHK_FAIL_END - -# if __USE_FORTIFY_LEVEL >= 2 -# define O 0 -# else -# define O 1 -# endif - - CHK_FAIL_START - strcpy (a.buf1 + (O + 4), str1 + 5); - CHK_FAIL_END - - CHK_FAIL_START - p = stpcpy (a.buf1 + (O + 8), str2); - CHK_FAIL_END - - CHK_FAIL_START - strncpy (a.buf1 + (O + 6), "X", 4); - CHK_FAIL_END - - CHK_FAIL_START - strncpy (a.buf1 + (O + 6), "X", l0 + 4); - CHK_FAIL_END - -# if !defined __cplusplus || defined __va_arg_pack - CHK_FAIL_START - sprintf (a.buf1 + (O + 7), "%d", num1); - CHK_FAIL_END - - CHK_FAIL_START - snprintf (a.buf1 + (O + 7), 3, "%d", num2); - CHK_FAIL_END - - CHK_FAIL_START - snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2); - CHK_FAIL_END -# endif - - memcpy (a.buf1, str1 + (3 - O), 8 + O); - CHK_FAIL_START - strcat (a.buf1, "AB"); - CHK_FAIL_END - - memcpy (a.buf1, str1 + (4 - O), 7 + O); - CHK_FAIL_START - strncat (a.buf1, "ZYXWV", l0 + 3); - CHK_FAIL_END -#endif - - - /* These ops can be done without runtime checking of object size. */ - wmemcpy (wbuf, L"abcdefghij", 10); - wmemmove (wbuf + 1, wbuf, 9); - if (wmemcmp (wbuf, L"aabcdefghi", 10)) - FAIL (); - - if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10 - || wmemcmp (wbuf, L"aabcdabcde", 10)) - FAIL (); - - wmemset (wbuf + 8, L'j', 2); - if (wmemcmp (wbuf, L"aabcdabcjj", 10)) - FAIL (); - - wcscpy (wbuf + 4, L"EDCBA"); - if (wmemcmp (wbuf, L"aabcEDCBA", 10)) - FAIL (); - - if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10)) - FAIL (); - - wcsncpy (wbuf + 6, L"X", 4); - if (wmemcmp (wbuf, L"aabcEDX\0\0", 10)) - FAIL (); - - if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0 - || wmemcmp (wbuf, L"aabcEDX98", 10)) - FAIL (); - - if (swprintf (wbuf + 7, 3, L"64") != 2 - || wmemcmp (wbuf, L"aabcEDX64", 10)) - FAIL (); - - /* These ops need runtime checking, but shouldn't __chk_fail. */ - wmemcpy (wbuf, L"abcdefghij", l0 + 10); - wmemmove (wbuf + 1, wbuf, l0 + 9); - if (wmemcmp (wbuf, L"aabcdefghi", 10)) - FAIL (); - - if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10 - || wmemcmp (wbuf, L"aabcdabcde", 10)) - FAIL (); - - wmemset (wbuf + 8, L'j', l0 + 2); - if (wmemcmp (wbuf, L"aabcdabcjj", 10)) - FAIL (); - - wcscpy (wbuf + 4, wstr1 + 5); - if (wmemcmp (wbuf, L"aabcEDCBA", 10)) - FAIL (); - - if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10)) - FAIL (); - - wcsncpy (wbuf + 6, L"X", l0 + 4); - if (wmemcmp (wbuf, L"aabcEDX\0\0", 10)) - FAIL (); - - if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7 - || wmemcmp (wbuf, L"aabcEcd\0\0", 10)) - FAIL (); - - if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0 - || wmemcmp (wbuf, L"aabcEcd98", 10)) - FAIL (); - - wbuf[l0 + 8] = L'\0'; - wcscat (wbuf, L"A"); - if (wmemcmp (wbuf, L"aabcEcd9A", 10)) - FAIL (); - - wbuf[l0 + 7] = L'\0'; - wcsncat (wbuf, L"ZYXWV", l0 + 2); - if (wmemcmp (wbuf, L"aabcEcdZY", 10)) - FAIL (); - - wmemcpy (wa.buf1, L"abcdefghij", l0 + 10); - wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9); - if (wmemcmp (wa.buf1, L"aabcdefghi", 10)) - FAIL (); - - if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10 - || wmemcmp (wa.buf1, L"aabcdabcde", 10)) - FAIL (); - - wmemset (wa.buf1 + 8, L'j', l0 + 2); - if (wmemcmp (wa.buf1, L"aabcdabcjj", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL < 2 - /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2 - and sufficient GCC support, as the string operations overflow - from a.buf1 into a.buf2. */ - wcscpy (wa.buf1 + 4, wstr1 + 5); - if (wmemcmp (wa.buf1, L"aabcEDCBA", 10)) - FAIL (); - - if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9 - || wmemcmp (wa.buf1, L"aabcEDCBF", 10)) - FAIL (); - - wcsncpy (wa.buf1 + 6, L"X", l0 + 4); - if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10)) - FAIL (); - - if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0 - || wmemcmp (wa.buf1, L"aabcEDX98", 10)) - FAIL (); - - wa.buf1[l0 + 8] = L'\0'; - wcscat (wa.buf1, L"A"); - if (wmemcmp (wa.buf1, L"aabcEDX9A", 10)) - FAIL (); - - wa.buf1[l0 + 7] = L'\0'; - wcsncat (wa.buf1, L"ZYXWV", l0 + 2); - if (wmemcmp (wa.buf1, L"aabcEDXZY", 10)) - FAIL (); - -#endif - -#if __USE_FORTIFY_LEVEL >= 1 - /* Now check if all buffer overflows are caught at runtime. - N.B. All tests involving a length parameter need to be done - twice: once with the length a compile-time constant, once without. */ - - CHK_FAIL_START - wmemcpy (wbuf + 1, L"abcdefghij", 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemcpy (wbuf + 9, L"abcdefghij", 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemcpy (wbuf + 9, L"abcdefghij", l0 + 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemmove (wbuf + 2, wbuf + 1, 9); - CHK_FAIL_END - - CHK_FAIL_START - wmemmove (wbuf + 2, wbuf + 1, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - wp = wmempcpy (wbuf + 6, L"abcde", 5); - CHK_FAIL_END - - CHK_FAIL_START - wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5); - CHK_FAIL_END - - CHK_FAIL_START - wmemset (wbuf + 9, L'j', 2); - CHK_FAIL_END - - CHK_FAIL_START - wmemset (wbuf + 9, L'j', l0 + 2); - CHK_FAIL_END - - CHK_FAIL_START - wcscpy (wbuf + 5, wstr1 + 5); - CHK_FAIL_END - - CHK_FAIL_START - wp = wcpcpy (wbuf + 9, wstr2); - CHK_FAIL_END - - CHK_FAIL_START - wcsncpy (wbuf + 7, L"X", 4); - CHK_FAIL_END - - CHK_FAIL_START - wcsncpy (wbuf + 7, L"X", l0 + 4); - CHK_FAIL_END - - CHK_FAIL_START - wcsncpy (wbuf + 9, L"XABCDEFGH", 8); - CHK_FAIL_END - - CHK_FAIL_START - wcpncpy (wbuf + 9, L"XABCDEFGH", 8); - CHK_FAIL_END - - CHK_FAIL_START - wcpncpy (wbuf + 6, L"cd", 5); - CHK_FAIL_END - - CHK_FAIL_START - wcpncpy (wbuf + 6, L"cd", l0 + 5); - CHK_FAIL_END - - wmemcpy (wbuf, wstr1 + 2, 9); - CHK_FAIL_START - wcscat (wbuf, L"AB"); - CHK_FAIL_END - - wmemcpy (wbuf, wstr1 + 3, 8); - CHK_FAIL_START - wcsncat (wbuf, L"ZYXWV", l0 + 3); - CHK_FAIL_END - - CHK_FAIL_START - wmemcpy (wa.buf1 + 1, L"abcdefghij", 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10); - CHK_FAIL_END - - CHK_FAIL_START - wmemmove (wa.buf1 + 2, wa.buf1 + 1, 9); - CHK_FAIL_END - - CHK_FAIL_START - wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9); - CHK_FAIL_END - - CHK_FAIL_START - wp = wmempcpy (wa.buf1 + 6, L"abcde", 5); - CHK_FAIL_END - - CHK_FAIL_START - wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5); - CHK_FAIL_END - - CHK_FAIL_START - wmemset (wa.buf1 + 9, L'j', 2); - CHK_FAIL_END - - CHK_FAIL_START - wmemset (wa.buf1 + 9, L'j', l0 + 2); - CHK_FAIL_END - -#if __USE_FORTIFY_LEVEL >= 2 -# define O 0 -#else -# define O 1 -#endif - - CHK_FAIL_START - wcscpy (wa.buf1 + (O + 4), wstr1 + 5); - CHK_FAIL_END - - CHK_FAIL_START - wp = wcpcpy (wa.buf1 + (O + 8), wstr2); - CHK_FAIL_END - - CHK_FAIL_START - wcsncpy (wa.buf1 + (O + 6), L"X", 4); - CHK_FAIL_END - - CHK_FAIL_START - wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4); - CHK_FAIL_END - - wmemcpy (wa.buf1, wstr1 + (3 - O), 8 + O); - CHK_FAIL_START - wcscat (wa.buf1, L"AB"); - CHK_FAIL_END - - wmemcpy (wa.buf1, wstr1 + (4 - O), 7 + O); - CHK_FAIL_START - wcsncat (wa.buf1, L"ZYXWV", l0 + 3); - CHK_FAIL_END -#endif - - - /* Now checks for %n protection. */ - - /* Constant literals passed directly are always ok - (even with warnings about possible bugs from GCC). */ - int n1, n2; - if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2 - || n1 != 1 || n2 != 2) - FAIL (); - - /* In this case the format string is not known at compile time, - but resides in read-only memory, so is ok. */ - if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2 - || n1 != 1 || n2 != 2) - FAIL (); - - strcpy (buf2 + 2, "%n%s%n"); - /* When the format string is writable and contains %n, - with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ - CHK_FAIL2_START - if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2) - FAIL (); - CHK_FAIL2_END - - CHK_FAIL2_START - if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2) - FAIL (); - CHK_FAIL2_END - - /* But if there is no %n, even writable format string - should work. */ - buf2[6] = '\0'; - if (sprintf (buf, buf2 + 4, str2) != 1) - FAIL (); - - /* Constant literals passed directly are always ok - (even with warnings about possible bugs from GCC). */ - if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14 - || n1 != 7 || n2 != 14) - FAIL (); - - /* In this case the format string is not known at compile time, - but resides in read-only memory, so is ok. */ - if (printf (str3, str4, &n1, str5, &n2) != 14 - || n1 != 7 || n2 != 14) - FAIL (); - - strcpy (buf2 + 2, "%n%s%n"); - /* When the format string is writable and contains %n, - with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ - CHK_FAIL2_START - if (printf (buf2, str4, &n1, str5, &n1) != 14) - FAIL (); - CHK_FAIL2_END - - /* But if there is no %n, even writable format string - should work. */ - buf2[6] = '\0'; - if (printf (buf2 + 4, str5) != 7) - FAIL (); - - FILE *fp = stdout; - - /* Constant literals passed directly are always ok - (even with warnings about possible bugs from GCC). */ - if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14 - || n1 != 7 || n2 != 14) - FAIL (); - - /* In this case the format string is not known at compile time, - but resides in read-only memory, so is ok. */ - if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14 - || n1 != 7 || n2 != 14) - FAIL (); - - strcpy (buf2 + 2, "%n%s%n"); - /* When the format string is writable and contains %n, - with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ - CHK_FAIL2_START - if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14) - FAIL (); - CHK_FAIL2_END - - /* But if there is no %n, even writable format string - should work. */ - buf2[6] = '\0'; - if (fprintf (fp, buf2 + 4, str5) != 7) - FAIL (); - - char *my_ptr = NULL; - strcpy (buf2 + 2, "%n%s%n"); - /* When the format string is writable and contains %n, - with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */ - CHK_FAIL2_START - if (asprintf (&my_ptr, buf2, str4, &n1, str5, &n1) != 14) - FAIL (); - else - free (my_ptr); - CHK_FAIL2_END - - struct obstack obs; - obstack_init (&obs); - CHK_FAIL2_START - if (obstack_printf (&obs, buf2, str4, &n1, str5, &n1) != 14) - FAIL (); - CHK_FAIL2_END - obstack_free (&obs, NULL); - - my_ptr = NULL; - if (asprintf (&my_ptr, "%s%n%s%n", str4, &n1, str5, &n1) != 14) - FAIL (); - else - free (my_ptr); - - obstack_init (&obs); - if (obstack_printf (&obs, "%s%n%s%n", str4, &n1, str5, &n1) != 14) - FAIL (); - obstack_free (&obs, NULL); - - if (freopen (temp_filename, "r", stdin) == NULL) - { - puts ("could not open temporary file"); - exit (1); - } - - if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9)) - FAIL (); - if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (gets (buf) != buf) - FAIL (); - CHK_FAIL_END -#endif - - rewind (stdin); - - if (fgets (buf, buf_size, stdin) != buf - || memcmp (buf, "abcdefgh\n", 10)) - FAIL (); - if (fgets (buf, buf_size, stdin) != buf || memcmp (buf, "ABCDEFGHI", 10)) - FAIL (); - - rewind (stdin); - - if (fgets (buf, l0 + buf_size, stdin) != buf - || memcmp (buf, "abcdefgh\n", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (fgets (buf, buf_size + 1, stdin) != buf) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (fgets (buf, l0 + buf_size + 1, stdin) != buf) - FAIL (); - CHK_FAIL_END -#endif - - rewind (stdin); - - if (fgets_unlocked (buf, buf_size, stdin) != buf - || memcmp (buf, "abcdefgh\n", 10)) - FAIL (); - if (fgets_unlocked (buf, buf_size, stdin) != buf - || memcmp (buf, "ABCDEFGHI", 10)) - FAIL (); - - rewind (stdin); - - if (fgets_unlocked (buf, l0 + buf_size, stdin) != buf - || memcmp (buf, "abcdefgh\n", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (fgets_unlocked (buf, buf_size + 1, stdin) != buf) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (fgets_unlocked (buf, l0 + buf_size + 1, stdin) != buf) - FAIL (); - CHK_FAIL_END -#endif - - rewind (stdin); - - if (fread (buf, 1, buf_size, stdin) != buf_size - || memcmp (buf, "abcdefgh\nA", 10)) - FAIL (); - if (fread (buf, buf_size, 1, stdin) != 1 - || memcmp (buf, "BCDEFGHI\na", 10)) - FAIL (); - - rewind (stdin); - - if (fread (buf, l0 + 1, buf_size, stdin) != buf_size - || memcmp (buf, "abcdefgh\nA", 10)) - FAIL (); - if (fread (buf, buf_size, l0 + 1, stdin) != 1 - || memcmp (buf, "BCDEFGHI\na", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (fread (buf, 1, buf_size + 1, stdin) != buf_size + 1) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (fread (buf, buf_size + 1, l0 + 1, stdin) != 1) - FAIL (); - CHK_FAIL_END -#endif - - rewind (stdin); - - if (fread_unlocked (buf, 1, buf_size, stdin) != buf_size - || memcmp (buf, "abcdefgh\nA", 10)) - FAIL (); - if (fread_unlocked (buf, buf_size, 1, stdin) != 1 - || memcmp (buf, "BCDEFGHI\na", 10)) - FAIL (); - - rewind (stdin); - - if (fread_unlocked (buf, 1, 4, stdin) != 4 - || memcmp (buf, "abcdFGHI\na", 10)) - FAIL (); - if (fread_unlocked (buf, 4, 1, stdin) != 1 - || memcmp (buf, "efghFGHI\na", 10)) - FAIL (); - - rewind (stdin); - - if (fread_unlocked (buf, l0 + 1, buf_size, stdin) != buf_size - || memcmp (buf, "abcdefgh\nA", 10)) - FAIL (); - if (fread_unlocked (buf, buf_size, l0 + 1, stdin) != 1 - || memcmp (buf, "BCDEFGHI\na", 10)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (fread_unlocked (buf, 1, buf_size + 1, stdin) != buf_size + 1) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (fread_unlocked (buf, buf_size + 1, l0 + 1, stdin) != 1) - FAIL (); - CHK_FAIL_END -#endif - - lseek (fileno (stdin), 0, SEEK_SET); - - if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1 - || memcmp (buf, "abcdefgh\n", 9)) - FAIL (); - if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1 - || memcmp (buf, "ABCDEFGHI", 9)) - FAIL (); - - lseek (fileno (stdin), 0, SEEK_SET); - - if (read (fileno (stdin), buf, l0 + buf_size - 1) != buf_size - 1 - || memcmp (buf, "abcdefgh\n", 9)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (read (fileno (stdin), buf, buf_size + 1) != buf_size + 1) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (read (fileno (stdin), buf, l0 + buf_size + 1) != buf_size + 1) - FAIL (); - CHK_FAIL_END -#endif - - if (pread (fileno (stdin), buf, buf_size - 1, buf_size - 2) - != buf_size - 1 - || memcmp (buf, "\nABCDEFGH", 9)) - FAIL (); - if (pread (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1 - || memcmp (buf, "abcdefgh\n", 9)) - FAIL (); - if (pread (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3) - != buf_size - 1 - || memcmp (buf, "h\nABCDEFG", 9)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (pread (fileno (stdin), buf, buf_size + 1, 2 * buf_size) - != buf_size + 1) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (pread (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size) - != buf_size + 1) - FAIL (); - CHK_FAIL_END -#endif - - if (pread64 (fileno (stdin), buf, buf_size - 1, buf_size - 2) - != buf_size - 1 - || memcmp (buf, "\nABCDEFGH", 9)) - FAIL (); - if (pread64 (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1 - || memcmp (buf, "abcdefgh\n", 9)) - FAIL (); - if (pread64 (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3) - != buf_size - 1 - || memcmp (buf, "h\nABCDEFG", 9)) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (pread64 (fileno (stdin), buf, buf_size + 1, 2 * buf_size) - != buf_size + 1) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (pread64 (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size) - != buf_size + 1) - FAIL (); - CHK_FAIL_END -#endif - - if (freopen (temp_filename, "r", stdin) == NULL) - { - puts ("could not open temporary file"); - exit (1); - } - - if (fseek (stdin, 9 + 10 + 11, SEEK_SET)) - { - puts ("could not seek in test file"); - exit (1); - } - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (gets (buf) != buf) - FAIL (); - CHK_FAIL_END -#endif - - /* Check whether missing N$ formats are detected. */ - CHK_FAIL2_START - printf ("%3$d\n", 1, 2, 3, 4); - CHK_FAIL2_END - - CHK_FAIL2_START - fprintf (stdout, "%3$d\n", 1, 2, 3, 4); - CHK_FAIL2_END - - CHK_FAIL2_START - sprintf (buf, "%3$d\n", 1, 2, 3, 4); - CHK_FAIL2_END - - CHK_FAIL2_START - snprintf (buf, buf_size, "%3$d\n", 1, 2, 3, 4); - CHK_FAIL2_END - - int sp[2]; - if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp)) - FAIL (); - else - { - const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n"; - if ((size_t) send (sp[0], sendstr, strlen (sendstr), 0) - != strlen (sendstr)) - FAIL (); - - char recvbuf[12]; - if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK) - != sizeof recvbuf - || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0) - FAIL (); - - if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK) - != sizeof recvbuf - 7 - || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK) - != sizeof recvbuf) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK) - != sizeof recvbuf - 3) - FAIL (); - CHK_FAIL_END -#endif - - socklen_t sl; - struct sockaddr_un sa_un; - - sl = sizeof (sa_un); - if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK, - (struct sockaddr *) &sa_un, &sl) - != sizeof recvbuf - || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0) - FAIL (); - - sl = sizeof (sa_un); - if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK, - (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 7 - || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - sl = sizeof (sa_un); - if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK, - (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - sl = sizeof (sa_un); - if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK, - (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 3) - FAIL (); - CHK_FAIL_END -#endif - - close (sp[0]); - close (sp[1]); - } - - char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo"; - char *enddir = strchr (fname, '\0'); - if (mkdtemp (fname) == NULL) - { - printf ("mkdtemp failed: %m\n"); - return 1; - } - *enddir = '/'; - if (symlink ("bar", fname) != 0) - FAIL (); - - char readlinkbuf[4]; - if (readlink (fname, readlinkbuf, 4) != 3 - || memcmp (readlinkbuf, "bar", 3) != 0) - FAIL (); - if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3 - || memcmp (readlinkbuf, "bbar", 4) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (readlink (fname, readlinkbuf + 3, 4) != 3) - FAIL (); - CHK_FAIL_END -#endif - - int tmpfd = open ("/tmp", O_RDONLY | O_DIRECTORY); - if (tmpfd < 0) - FAIL (); - - if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf, 4) != 3 - || memcmp (readlinkbuf, "bar", 3) != 0) - FAIL (); - if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 1, - l0 + 3) != 3 - || memcmp (readlinkbuf, "bbar", 4) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 2, - l0 + 3) != 3) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 3, - 4) != 3) - FAIL (); - CHK_FAIL_END -#endif - - close (tmpfd); - - char *cwd1 = getcwd (NULL, 0); - if (cwd1 == NULL) - FAIL (); - - char *cwd2 = getcwd (NULL, 250); - if (cwd2 == NULL) - FAIL (); - - if (cwd1 && cwd2) - { - if (strcmp (cwd1, cwd2) != 0) - FAIL (); - - *enddir = '\0'; - if (chdir (fname)) - FAIL (); - - char *cwd3 = getcwd (NULL, 0); - if (cwd3 == NULL) - FAIL (); - if (strcmp (fname, cwd3) != 0) - printf ("getcwd after chdir is '%s' != '%s'," - "get{c,}wd tests skipped\n", cwd3, fname); - else - { - char getcwdbuf[sizeof fname - 3]; - - char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf); - if (cwd4 != getcwdbuf - || strcmp (getcwdbuf, fname) != 0) - FAIL (); - - cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1); - if (cwd4 != getcwdbuf + 1 - || getcwdbuf[0] != fname[0] - || strcmp (getcwdbuf + 1, fname) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf) - != getcwdbuf + 2) - FAIL (); - CHK_FAIL_END - - CHK_FAIL_START - if (getcwd (getcwdbuf + 2, sizeof getcwdbuf) - != getcwdbuf + 2) - FAIL (); - CHK_FAIL_END -#endif - - if (getwd (getcwdbuf) != getcwdbuf - || strcmp (getcwdbuf, fname) != 0) - FAIL (); - - if (getwd (getcwdbuf + 1) != getcwdbuf + 1 - || strcmp (getcwdbuf + 1, fname) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - if (getwd (getcwdbuf + 2) != getcwdbuf + 2) - FAIL (); - CHK_FAIL_END -#endif - } - - if (chdir (cwd1) != 0) - FAIL (); - free (cwd3); - } - - free (cwd1); - free (cwd2); - *enddir = '/'; - if (unlink (fname) != 0) - FAIL (); - - *enddir = '\0'; - if (rmdir (fname) != 0) - FAIL (); - - -#if PATH_MAX > 0 - char largebuf[PATH_MAX]; - char *realres = realpath (".", largebuf); - if (realres != largebuf) - FAIL (); - -# if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char realbuf[1]; - realres = realpath (".", realbuf); - if (realres != realbuf) - FAIL (); - CHK_FAIL_END -# endif -#endif - - if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL) - { - assert (MB_CUR_MAX <= 10); - - /* First a simple test. */ - char enough[10]; - if (wctomb (enough, L'A') != 1) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - /* We know the wchar_t encoding is ISO 10646. So pick a - character which has a multibyte representation which does not - fit. */ - CHK_FAIL_START - char smallbuf[2]; - if (wctomb (smallbuf, L'\x100') != 2) - FAIL (); - CHK_FAIL_END -#endif - - mbstate_t s; - memset (&s, '\0', sizeof (s)); - if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D') - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - /* We know the wchar_t encoding is ISO 10646. So pick a - character which has a multibyte representation which does not - fit. */ - CHK_FAIL_START - char smallbuf[2]; - if (wcrtomb (smallbuf, L'\x100', &s) != 2) - FAIL (); - CHK_FAIL_END -#endif - - wchar_t wenough[10]; - memset (&s, '\0', sizeof (s)); - const char *cp = "A"; - if (mbsrtowcs (wenough, &cp, 10, &s) != 1 - || wcscmp (wenough, L"A") != 0) - FAIL (); - - cp = "BC"; - if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2 - || wcscmp (wenough, L"BC") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - wchar_t wsmallbuf[2]; - cp = "ABC"; - mbsrtowcs (wsmallbuf, &cp, 10, &s); - CHK_FAIL_END -#endif - - cp = "A"; - if (mbstowcs (wenough, cp, 10) != 1 - || wcscmp (wenough, L"A") != 0) - FAIL (); - - cp = "DEF"; - if (mbstowcs (wenough, cp, l0 + 10) != 3 - || wcscmp (wenough, L"DEF") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - wchar_t wsmallbuf[2]; - cp = "ABC"; - mbstowcs (wsmallbuf, cp, 10); - CHK_FAIL_END -#endif - - memset (&s, '\0', sizeof (s)); - cp = "ABC"; - wcscpy (wenough, L"DEF"); - if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1 - || wcscmp (wenough, L"AEF") != 0) - FAIL (); - - cp = "IJ"; - if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1 - || wcscmp (wenough, L"IEF") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - wchar_t wsmallbuf[2]; - cp = "ABC"; - mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s); - CHK_FAIL_END -#endif - - memset (&s, '\0', sizeof (s)); - const wchar_t *wcp = L"A"; - if (wcsrtombs (enough, &wcp, 10, &s) != 1 - || strcmp (enough, "A") != 0) - FAIL (); - - wcp = L"BC"; - if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2 - || strcmp (enough, "BC") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[2]; - wcp = L"ABC"; - wcsrtombs (smallbuf, &wcp, 10, &s); - CHK_FAIL_END -#endif - - memset (enough, 'Z', sizeof (enough)); - wcp = L"EF"; - if (wcstombs (enough, wcp, 10) != 2 - || strcmp (enough, "EF") != 0) - FAIL (); - - wcp = L"G"; - if (wcstombs (enough, wcp, l0 + 10) != 1 - || strcmp (enough, "G") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[2]; - wcp = L"ABC"; - wcstombs (smallbuf, wcp, 10); - CHK_FAIL_END -#endif - - memset (&s, '\0', sizeof (s)); - wcp = L"AB"; - if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1 - || strcmp (enough, "A") != 0) - FAIL (); - - wcp = L"BCD"; - if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1 - || strcmp (enough, "B") != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[2]; - wcp = L"ABC"; - wcsnrtombs (smallbuf, &wcp, 3, 10, &s); - CHK_FAIL_END -#endif - } - else - { - puts ("cannot set locale"); - ret = 1; - } - - int fd = posix_openpt (O_RDWR); - if (fd != -1) - { - char enough[1000]; - if (ptsname_r (fd, enough, sizeof (enough)) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[2]; - if (ptsname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0) - FAIL (); - CHK_FAIL_END -#endif - close (fd); - } - -#if PATH_MAX > 0 - confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf)); -# if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[1]; - confstr (_CS_GNU_LIBC_VERSION, smallbuf, sizeof (largebuf)); - CHK_FAIL_END -# endif -#endif - - gid_t grpslarge[5]; - int ngr = getgroups (5, grpslarge); - asm volatile ("" : : "r" (ngr)); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[1]; - ngr = getgroups (5, (gid_t *) smallbuf); - asm volatile ("" : : "r" (ngr)); - CHK_FAIL_END -#endif - - fd = open (_PATH_TTY, O_RDONLY); - if (fd != -1) - { - char enough[1000]; - if (ttyname_r (fd, enough, sizeof (enough)) != 0) - FAIL (); - -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[2]; - if (ttyname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0) - FAIL (); - CHK_FAIL_END -#endif - close (fd); - } - - char hostnamelarge[1000]; - gethostname (hostnamelarge, sizeof (hostnamelarge)); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[1]; - gethostname (smallbuf, sizeof (hostnamelarge)); - CHK_FAIL_END -#endif - - char loginlarge[1000]; - getlogin_r (loginlarge, sizeof (hostnamelarge)); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[1]; - getlogin_r (smallbuf, sizeof (loginlarge)); - CHK_FAIL_END -#endif - - char domainnamelarge[1000]; - int res = getdomainname (domainnamelarge, sizeof (domainnamelarge)); - asm volatile ("" : : "r" (res)); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - char smallbuf[1]; - res = getdomainname (smallbuf, sizeof (domainnamelarge)); - asm volatile ("" : : "r" (res)); - CHK_FAIL_END -#endif - - fd_set s; - FD_ZERO (&s); - - FD_SET (FD_SETSIZE - 1, &s); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - FD_SET (FD_SETSIZE, &s); - CHK_FAIL_END - - CHK_FAIL_START - FD_SET (l0 + FD_SETSIZE, &s); - CHK_FAIL_END -#endif - - FD_CLR (FD_SETSIZE - 1, &s); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - FD_CLR (FD_SETSIZE, &s); - CHK_FAIL_END - - CHK_FAIL_START - FD_SET (l0 + FD_SETSIZE, &s); - CHK_FAIL_END -#endif - - FD_ISSET (FD_SETSIZE - 1, &s); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - FD_ISSET (FD_SETSIZE, &s); - CHK_FAIL_END - - CHK_FAIL_START - FD_ISSET (l0 + FD_SETSIZE, &s); - CHK_FAIL_END -#endif - - struct pollfd fds[1]; - fds[0].fd = STDOUT_FILENO; - fds[0].events = POLLOUT; - poll (fds, 1, 0); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - poll (fds, 2, 0); - CHK_FAIL_END - - CHK_FAIL_START - poll (fds, l0 + 2, 0); - CHK_FAIL_END -#endif - ppoll (fds, 1, NULL, NULL); -#if __USE_FORTIFY_LEVEL >= 1 - CHK_FAIL_START - ppoll (fds, 2, NULL, NULL); - CHK_FAIL_END - - CHK_FAIL_START - ppoll (fds, l0 + 2, NULL, NULL); - CHK_FAIL_END -#endif - - return ret; -} +#define _FORTIFY_SOURCE 1 +#include "tst-chk0.c" diff --git a/debug/tst-lfschk4.cc b/debug/tst-chk1cc-lfs.cc similarity index 100% rename from debug/tst-lfschk4.cc rename to debug/tst-chk1cc-lfs.cc diff --git a/debug/tst-chk5.cc b/debug/tst-chk1cc.cc similarity index 54% rename from debug/tst-chk5.cc rename to debug/tst-chk1cc.cc index be37ce2d22..c09b01df34 100644 --- a/debug/tst-chk5.cc +++ b/debug/tst-chk1cc.cc @@ -1,2 +1,2 @@ #define _FORTIFY_SOURCE 1 -#include "tst-chk1.c" +#include "tst-chk0.c" diff --git a/debug/tst-lfschk2.c b/debug/tst-chk2-lfs.c similarity index 100% rename from debug/tst-lfschk2.c rename to debug/tst-chk2-lfs.c diff --git a/debug/tst-chk2.c b/debug/tst-chk2.c index be37ce2d22..983cb8aaa8 100644 --- a/debug/tst-chk2.c +++ b/debug/tst-chk2.c @@ -1,2 +1,2 @@ -#define _FORTIFY_SOURCE 1 -#include "tst-chk1.c" +#define _FORTIFY_SOURCE 2 +#include "tst-chk0.c" diff --git a/debug/tst-lfschk5.cc b/debug/tst-chk2cc-lfs.cc similarity index 100% rename from debug/tst-lfschk5.cc rename to debug/tst-chk2cc-lfs.cc diff --git a/debug/tst-chk6.cc b/debug/tst-chk2cc.cc similarity index 54% rename from debug/tst-chk6.cc rename to debug/tst-chk2cc.cc index 38b8e4fb36..983cb8aaa8 100644 --- a/debug/tst-chk6.cc +++ b/debug/tst-chk2cc.cc @@ -1,2 +1,2 @@ #define _FORTIFY_SOURCE 2 -#include "tst-chk1.c" +#include "tst-chk0.c" diff --git a/debug/tst-lfschk3.c b/debug/tst-chk3-lfs.c similarity index 100% rename from debug/tst-lfschk3.c rename to debug/tst-chk3-lfs.c diff --git a/debug/tst-chk3.c b/debug/tst-chk3.c index 38b8e4fb36..2f87061b00 100644 --- a/debug/tst-chk3.c +++ b/debug/tst-chk3.c @@ -1,2 +1,2 @@ -#define _FORTIFY_SOURCE 2 -#include "tst-chk1.c" +#define _FORTIFY_SOURCE 3 +#include "tst-chk0.c" diff --git a/debug/tst-lfschk6.cc b/debug/tst-chk3cc-lfs.cc similarity index 100% rename from debug/tst-lfschk6.cc rename to debug/tst-chk3cc-lfs.cc diff --git a/debug/tst-chk8.cc b/debug/tst-chk3cc.cc similarity index 54% rename from debug/tst-chk8.cc rename to debug/tst-chk3cc.cc index 2a7b323812..2f87061b00 100644 --- a/debug/tst-chk8.cc +++ b/debug/tst-chk3cc.cc @@ -1,2 +1,2 @@ #define _FORTIFY_SOURCE 3 -#include "tst-chk1.c" +#include "tst-chk0.c" diff --git a/debug/tst-chk4.cc b/debug/tst-chk4.cc deleted file mode 100644 index c82e6aac86..0000000000 --- a/debug/tst-chk4.cc +++ /dev/null @@ -1 +0,0 @@ -#include "tst-chk1.c" diff --git a/debug/tst-chk7.c b/debug/tst-chk7.c deleted file mode 100644 index 2a7b323812..0000000000 --- a/debug/tst-chk7.c +++ /dev/null @@ -1,2 +0,0 @@ -#define _FORTIFY_SOURCE 3 -#include "tst-chk1.c" From patchwork Wed Jan 5 01:39:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Siddhesh Poyarekar X-Patchwork-Id: 49540 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id AB06B3858432 for ; Wed, 5 Jan 2022 01:41:01 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org AB06B3858432 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1641346861; bh=rZBqxoDC5XnvwRNKrxy+87PCIy9eGEyOvuNUy77cGvg=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=Xpy1IWiay6xbCHnKLbLz7y0ExC3SW0vOF/SxVHwRn3+DszqDSUwFzawohpsmUiEHG D+1HeetGjcUEzmho+a7Kg0JjpaXhcfnVI1FUVl9Mh/rzgqBLqEF3nJyUz4AqHCEXtJ J31pow0POTsgQgqb5bkFxukEmMkNINoNJHDB8i00= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from butterfly.birch.relay.mailchannels.net (butterfly.birch.relay.mailchannels.net [23.83.209.27]) by sourceware.org (Postfix) with ESMTPS id 85C63385842C for ; Wed, 5 Jan 2022 01:40:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 85C63385842C X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id 47D126C1928 for ; Wed, 5 Jan 2022 01:40:00 +0000 (UTC) Received: from pdx1-sub0-mail-a306.dreamhost.com (unknown [127.0.0.6]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id B2B206C191C for ; Wed, 5 Jan 2022 01:39:59 +0000 (UTC) X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from pdx1-sub0-mail-a306.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384) by 100.121.9.225 (trex/6.4.3); Wed, 05 Jan 2022 01:40:00 +0000 X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Macabre-Towering: 26890e476941bf82_1641346800119_3195261820 X-MC-Loop-Signature: 1641346800119:394751800 X-MC-Ingress-Time: 1641346800119 Received: from rhbox.intra.reserved-bit.com (unknown [1.186.123.58]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a306.dreamhost.com (Postfix) with ESMTPSA id 4JTBxV27Mtz1T for ; Tue, 4 Jan 2022 17:39:57 -0800 (PST) To: libc-alpha@sourceware.org Subject: [PATCH 2/2] debug: Synchronize feature guards in fortified functions [BZ #28746] Date: Wed, 5 Jan 2022 07:09:46 +0530 Message-Id: <20220105013946.2646963-3-siddhesh@sourceware.org> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20220105013946.2646963-1-siddhesh@sourceware.org> References: <20220105013946.2646963-1-siddhesh@sourceware.org> MIME-Version: 1.0 X-Spam-Status: No, score=-3494.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_NONE, KAM_DMARC_STATUS, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, RCVD_IN_SBL, SPF_HELO_NONE, SPF_NEUTRAL, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Siddhesh Poyarekar via Libc-alpha From: Siddhesh Poyarekar Reply-To: Siddhesh Poyarekar Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Some functions (e.g. stpcpy, pread64, etc.) had moved to POSIX in the main headers as they got incorporated into the standard, but their fortified variants remained under __USE_GNU. As a result, these functions did not get fortified when _GNU_SOURCE was not defined. Add test wrappers that check all functions tested in tst-chk0 at all levels with _GNU_SOURCE undefined and then use the failures to (1) exclude checks for _GNU_SOURCE functions in these tests and (2) Fix feature macro guards in the fortified function headers so that they're the same as the ones in the main headers. This fixes BZ #28746. Signed-off-by: Siddhesh Poyarekar --- debug/Makefile | 17 +++++++----- debug/tst-chk0-nongnu.c | 3 +++ debug/tst-chk0.c | 49 ++++++++++++++++++++++++++++------ debug/tst-chk0cc-nongnu.cc | 3 +++ debug/tst-chk1-nongnu.c | 3 +++ debug/tst-chk1cc-nongnu.cc | 3 +++ debug/tst-chk2-nongnu.c | 3 +++ debug/tst-chk2cc-nongnu.cc | 3 +++ debug/tst-chk3-nongnu.c | 3 +++ debug/tst-chk3cc-nongnu.cc | 3 +++ posix/bits/unistd.h | 2 +- string/bits/string_fortified.h | 8 +++--- support/xsignal.h | 2 ++ wcsmbs/bits/wchar2.h | 2 +- 14 files changed, 85 insertions(+), 19 deletions(-) create mode 100644 debug/tst-chk0-nongnu.c create mode 100644 debug/tst-chk0cc-nongnu.cc create mode 100644 debug/tst-chk1-nongnu.c create mode 100644 debug/tst-chk1cc-nongnu.cc create mode 100644 debug/tst-chk2-nongnu.c create mode 100644 debug/tst-chk2cc-nongnu.cc create mode 100644 debug/tst-chk3-nongnu.c create mode 100644 debug/tst-chk3cc-nongnu.cc diff --git a/debug/Makefile b/debug/Makefile index fe94cd3072..cae00593a8 100644 --- a/debug/Makefile +++ b/debug/Makefile @@ -116,6 +116,8 @@ tests-chk = $(addprefix tst-chk, 0 1 2 3) tests-chk-cc = $(addsuffix cc, $(tests-chk)) tests-chk-lfs = $(addsuffix -lfs, $(tests-chk)) tests-chk-cc-lfs = $(addsuffix -lfs, $(tests-chk-cc)) +tests-chk-nongnu = $(addsuffix -nongnu, $(tests-chk)) +tests-chk-cc-nongnu = $(addsuffix -nongnu, $(tests-chk-cc)) # We know these tests have problems with format strings, this is what # we are testing. Disable that warning. They are also testing @@ -126,16 +128,17 @@ define disable-warnings CFLAGS-$(1).$(2) += -Wno-format -Wno-deprecated-declarations -Wno-error endef -$(foreach t,$(tests-chk) $(tests-chk-lfs), \ +$(foreach t,$(tests-chk) $(tests-chk-lfs) $(tests-chk-nongnu), \ $(eval $(call disable-warnings,$(t),c))) -$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs), \ +$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs) $(tests-chk-cc-nongnu), \ $(eval $(call disable-warnings,$(t),cc))) define link-cc LDLIBS-$(1) = -lstdc++ endef -$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs), $(eval $(call link-cc,$(t)))) +$(foreach t,$(tests-chk-cc) $(tests-chk-cc-lfs) $(tests-chk-cc-nongnu), \ + $(eval $(call link-cc,$(t)))) # backtrace_symbols only works if we link with -rdynamic. backtrace # requires unwind tables on most architectures. @@ -156,14 +159,15 @@ tests = backtrace-tst tst-longjmp_chk \ test-strcpy_chk test-stpcpy_chk \ tst-longjmp_chk2 tst-backtrace2 tst-backtrace3 \ tst-backtrace4 tst-backtrace5 tst-backtrace6 tst-realpath-chk \ - $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs) + $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs) \ + $(tests-chk-nongnu) $(tests-chk-cc-nongnu) ifeq ($(have-ssp),yes) tests += tst-ssp-1 endif ifeq (,$(CXX)) -tests-unsupported = $(tests-chk-cc) $(tests-chk-cc-lfs) +tests-unsupported = $(tests-chk-cc) $(tests-chk-cc-lfs) $(tests-chk-cc-nongnu) endif extra-libs = libSegFault libpcprofile @@ -194,7 +198,8 @@ define chk-gen-locales $(objpfx)$(1).out: $(gen-locales) endef $(foreach t, \ - $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs), \ + $(tests-chk) $(tests-chk-cc) $(tests-chk-lfs) $(tests-chk-cc-lfs) \ + $(tests-chk-nongnu) $(tests-chk-cc-nongnu), \ $(eval $(call link-cc,$(t)))) endif diff --git a/debug/tst-chk0-nongnu.c b/debug/tst-chk0-nongnu.c new file mode 100644 index 0000000000..8f7dd80228 --- /dev/null +++ b/debug/tst-chk0-nongnu.c @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk0.c" diff --git a/debug/tst-chk0.c b/debug/tst-chk0.c index d11e536f87..6b2ec33f87 100644 --- a/debug/tst-chk0.c +++ b/debug/tst-chk0.c @@ -1,4 +1,5 @@ /* Copyright (C) 2004-2021 Free Software Foundation, Inc. + Copyright The GNU Toolchain Authors. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or @@ -36,6 +37,17 @@ #include #include +#ifndef _GNU_SOURCE +# define MEMPCPY memcpy +# define WMEMPCPY wmemcpy +# define MEMPCPY_RET(x) 0 +# define WMEMPCPY_RET(x) 0 +#else +# define MEMPCPY mempcpy +# define WMEMPCPY wmempcpy +# define MEMPCPY_RET(x) __builtin_strlen (x) +# define WMEMPCPY_RET(x) wcslen (x) +#endif #define obstack_chunk_alloc malloc #define obstack_chunk_free free @@ -162,7 +174,7 @@ do_test (void) if (memcmp (buf, "aabcdefghi", 10)) FAIL (); - if (mempcpy (buf + 5, "abcde", 5) != buf + 10 + if (MEMPCPY (buf + 5, "abcde", 5) != buf + 5 + MEMPCPY_RET ("abcde") || memcmp (buf, "aabcdabcde", 10)) FAIL (); @@ -207,7 +219,7 @@ do_test (void) if (memcmp (buf, "aabcdefghi", 10)) FAIL (); - if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10 + if (MEMPCPY (buf + 5, "abcde", l0 + 5) != buf + 5 + MEMPCPY_RET ("abcde") || memcmp (buf, "aabcdabcde", 10)) FAIL (); @@ -266,7 +278,8 @@ do_test (void) if (memcmp (a.buf1, "aabcdefghi", 10)) FAIL (); - if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10 + if (MEMPCPY (a.buf1 + 5, "abcde", l0 + 5) + != a.buf1 + 5 + MEMPCPY_RET ("abcde") || memcmp (a.buf1, "aabcdabcde", 10)) FAIL (); @@ -347,6 +360,7 @@ do_test (void) bcopy (buf + 1, buf + 2, l0 + 9); CHK_FAIL_END +#ifdef _GNU_SOURCE CHK_FAIL_START p = (char *) mempcpy (buf + 6, "abcde", 5); CHK_FAIL_END @@ -354,6 +368,7 @@ do_test (void) CHK_FAIL_START p = (char *) mempcpy (buf + 6, "abcde", l0 + 5); CHK_FAIL_END +#endif CHK_FAIL_START memset (buf + 9, 'j', 2); @@ -464,6 +479,7 @@ do_test (void) bcopy (a.buf1 + 1, a.buf1 + 2, l0 + 9); CHK_FAIL_END +#ifdef _GNU_SOURCE CHK_FAIL_START p = (char *) mempcpy (a.buf1 + 6, "abcde", 5); CHK_FAIL_END @@ -471,6 +487,7 @@ do_test (void) CHK_FAIL_START p = (char *) mempcpy (a.buf1 + 6, "abcde", l0 + 5); CHK_FAIL_END +#endif CHK_FAIL_START memset (a.buf1 + 9, 'j', 2); @@ -550,7 +567,7 @@ do_test (void) if (wmemcmp (wbuf, L"aabcdefghi", 10)) FAIL (); - if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10 + if (WMEMPCPY (wbuf + 5, L"abcde", 5) != wbuf + 5 + WMEMPCPY_RET (L"abcde") || wmemcmp (wbuf, L"aabcdabcde", 10)) FAIL (); @@ -583,7 +600,8 @@ do_test (void) if (wmemcmp (wbuf, L"aabcdefghi", 10)) FAIL (); - if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10 + if (WMEMPCPY (wbuf + 5, L"abcde", l0 + 5) + != wbuf + 5 + WMEMPCPY_RET (L"abcde") || wmemcmp (wbuf, L"aabcdabcde", 10)) FAIL (); @@ -625,7 +643,8 @@ do_test (void) if (wmemcmp (wa.buf1, L"aabcdefghi", 10)) FAIL (); - if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10 + if (WMEMPCPY (wa.buf1 + 5, L"abcde", l0 + 5) + != wa.buf1 + 5 + WMEMPCPY_RET (L"abcde") || wmemcmp (wa.buf1, L"aabcdabcde", 10)) FAIL (); @@ -694,6 +713,7 @@ do_test (void) wmemmove (wbuf + 2, wbuf + 1, l0 + 9); CHK_FAIL_END +#ifdef _GNU_SOURCE CHK_FAIL_START wp = wmempcpy (wbuf + 6, L"abcde", 5); CHK_FAIL_END @@ -701,6 +721,7 @@ do_test (void) CHK_FAIL_START wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5); CHK_FAIL_END +#endif CHK_FAIL_START wmemset (wbuf + 9, L'j', 2); @@ -768,6 +789,7 @@ do_test (void) wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9); CHK_FAIL_END +#ifdef _GNU_SOURCE CHK_FAIL_START wp = wmempcpy (wa.buf1 + 6, L"abcde", 5); CHK_FAIL_END @@ -775,6 +797,7 @@ do_test (void) CHK_FAIL_START wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5); CHK_FAIL_END +#endif CHK_FAIL_START wmemset (wa.buf1 + 9, L'j', 2); @@ -906,6 +929,7 @@ do_test (void) if (fprintf (fp, buf2 + 4, str5) != 7) FAIL (); +#ifdef _GNU_SOURCE char *my_ptr = NULL; strcpy (buf2 + 2, "%n%s%n"); /* When the format string is writable and contains %n, @@ -935,6 +959,7 @@ do_test (void) if (obstack_printf (&obs, "%s%n%s%n", str4, &n1, str5, &n1) != 14) FAIL (); obstack_free (&obs, NULL); +#endif if (freopen (temp_filename, "r", stdin) == NULL) { @@ -982,6 +1007,7 @@ do_test (void) rewind (stdin); +#ifdef _GNU_SOURCE if (fgets_unlocked (buf, buf_size, stdin) != buf || memcmp (buf, "abcdefgh\n", 10)) FAIL (); @@ -1008,6 +1034,7 @@ do_test (void) #endif rewind (stdin); +#endif if (fread (buf, 1, buf_size, stdin) != buf_size || memcmp (buf, "abcdefgh\nA", 10)) @@ -1578,7 +1605,10 @@ do_test (void) ret = 1; } - int fd = posix_openpt (O_RDWR); + int fd; + +#ifdef _GNU_SOURCE + fd = posix_openpt (O_RDWR); if (fd != -1) { char enough[1000]; @@ -1594,6 +1624,7 @@ do_test (void) #endif close (fd); } +#endif #if PATH_MAX > 0 confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf)); @@ -1711,8 +1742,9 @@ do_test (void) poll (fds, l0 + 2, 0); CHK_FAIL_END #endif +#ifdef _GNU_SOURCE ppoll (fds, 1, NULL, NULL); -#if __USE_FORTIFY_LEVEL >= 1 +# if __USE_FORTIFY_LEVEL >= 1 CHK_FAIL_START ppoll (fds, 2, NULL, NULL); CHK_FAIL_END @@ -1720,6 +1752,7 @@ do_test (void) CHK_FAIL_START ppoll (fds, l0 + 2, NULL, NULL); CHK_FAIL_END +# endif #endif return ret; diff --git a/debug/tst-chk0cc-nongnu.cc b/debug/tst-chk0cc-nongnu.cc new file mode 100644 index 0000000000..8f7dd80228 --- /dev/null +++ b/debug/tst-chk0cc-nongnu.cc @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk0.c" diff --git a/debug/tst-chk1-nongnu.c b/debug/tst-chk1-nongnu.c new file mode 100644 index 0000000000..ed953070dd --- /dev/null +++ b/debug/tst-chk1-nongnu.c @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk1.c" diff --git a/debug/tst-chk1cc-nongnu.cc b/debug/tst-chk1cc-nongnu.cc new file mode 100644 index 0000000000..ed953070dd --- /dev/null +++ b/debug/tst-chk1cc-nongnu.cc @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk1.c" diff --git a/debug/tst-chk2-nongnu.c b/debug/tst-chk2-nongnu.c new file mode 100644 index 0000000000..506f7d0396 --- /dev/null +++ b/debug/tst-chk2-nongnu.c @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk2.c" diff --git a/debug/tst-chk2cc-nongnu.cc b/debug/tst-chk2cc-nongnu.cc new file mode 100644 index 0000000000..506f7d0396 --- /dev/null +++ b/debug/tst-chk2cc-nongnu.cc @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk2.c" diff --git a/debug/tst-chk3-nongnu.c b/debug/tst-chk3-nongnu.c new file mode 100644 index 0000000000..44fea0ea0d --- /dev/null +++ b/debug/tst-chk3-nongnu.c @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk3.c" diff --git a/debug/tst-chk3cc-nongnu.cc b/debug/tst-chk3cc-nongnu.cc new file mode 100644 index 0000000000..44fea0ea0d --- /dev/null +++ b/debug/tst-chk3cc-nongnu.cc @@ -0,0 +1,3 @@ +#undef _GNU_SOURCE +#define _LARGEFILE64_SOURCE 1 +#include "tst-chk3.c" diff --git a/posix/bits/unistd.h b/posix/bits/unistd.h index 697dcbbf7b..1df7e5ceef 100644 --- a/posix/bits/unistd.h +++ b/posix/bits/unistd.h @@ -40,7 +40,7 @@ read (int __fd, void *__buf, size_t __nbytes) __fd, __buf, __nbytes); } -#ifdef __USE_UNIX98 +#if defined __USE_UNIX98 || defined __USE_XOPEN2K8 extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __wur __attr_access ((__write_only__, 2, 3)); diff --git a/string/bits/string_fortified.h b/string/bits/string_fortified.h index 5731274848..fac5794c14 100644 --- a/string/bits/string_fortified.h +++ b/string/bits/string_fortified.h @@ -79,7 +79,7 @@ __NTH (strcpy (char *__restrict __dest, const char *__restrict __src)) return __builtin___strcpy_chk (__dest, __src, __glibc_objsize (__dest)); } -#ifdef __USE_GNU +#ifdef __USE_XOPEN2K8 __fortify_function char * __NTH (stpcpy (char *__restrict __dest, const char *__restrict __src)) { @@ -96,14 +96,15 @@ __NTH (strncpy (char *__restrict __dest, const char *__restrict __src, __glibc_objsize (__dest)); } -#if __GNUC_PREREQ (4, 7) || __glibc_clang_prereq (2, 6) +#if __USE_XOPEN2K8 +# if __GNUC_PREREQ (4, 7) || __glibc_clang_prereq (2, 6) __fortify_function char * __NTH (stpncpy (char *__dest, const char *__src, size_t __n)) { return __builtin___stpncpy_chk (__dest, __src, __n, __glibc_objsize (__dest)); } -#else +# else extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n, size_t __destlen) __THROW __fortified_attr_access ((__write_only__, 1, 3)) @@ -119,6 +120,7 @@ __NTH (stpncpy (char *__dest, const char *__src, size_t __n)) return __stpncpy_chk (__dest, __src, __n, __bos (__dest)); return __stpncpy_alias (__dest, __src, __n); } +# endif #endif diff --git a/support/xsignal.h b/support/xsignal.h index 8ee1fa6b4d..692e0f2c42 100644 --- a/support/xsignal.h +++ b/support/xsignal.h @@ -28,7 +28,9 @@ __BEGIN_DECLS terminate the process on error. */ void xraise (int sig); +#ifdef _GNU_SOURCE sighandler_t xsignal (int sig, sighandler_t handler); +#endif void xsigaction (int sig, const struct sigaction *newact, struct sigaction *oldact); diff --git a/wcsmbs/bits/wchar2.h b/wcsmbs/bits/wchar2.h index 26012ef936..88c1fdfcd3 100644 --- a/wcsmbs/bits/wchar2.h +++ b/wcsmbs/bits/wchar2.h @@ -457,7 +457,7 @@ __NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, } -#ifdef __USE_GNU +#ifdef __USE_XOPEN2K8 extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps,