CoCalc -- fortify_string

GitHub Repository: freebsd/freebsd-src
Path: blob/main/lib/libc/tests/secure/fortify_string_test.c
³⁹⁵⁵³ views
1
/* @generated by `generate-fortify-tests.lua "string"` */
2

3
#define	_FORTIFY_SOURCE	2
4
#define	TMPFILE_SIZE	(1024 * 32)
5

6
#include <sys/param.h>
7
#include <sys/jail.h>
8
#include <sys/random.h>
9
#include <sys/resource.h>
10
#include <sys/select.h>
11
#include <sys/socket.h>
12
#include <sys/time.h>
13
#include <sys/uio.h>
14
#include <sys/wait.h>
15
#include <dirent.h>
16
#include <errno.h>
17
#include <fcntl.h>
18
#include <limits.h>
19
#include <poll.h>
20
#include <signal.h>
21
#include <stdio.h>
22
#include <stdlib.h>
23
#include <string.h>
24
#include <strings.h>
25
#include <sysexits.h>
26
#include <unistd.h>
27
#include <wchar.h>
28
#include <atf-c.h>
29

30
static FILE * __unused
31
new_fp(size_t __len)
32
{
33
	static char fpbuf[LINE_MAX];
34
	FILE *fp;
35

36
	ATF_REQUIRE(__len <= sizeof(fpbuf));
37

38
	memset(fpbuf, 'A', sizeof(fpbuf) - 1);
39
	fpbuf[sizeof(fpbuf) - 1] = '\0';
40

41
	fp = fmemopen(fpbuf, sizeof(fpbuf), "rb");
42
	ATF_REQUIRE(fp != NULL);
43

44
	return (fp);
45
}
46

47
/*
48
 * Create a new symlink to use for readlink(2) style tests, we'll just use a
49
 * random target name to have something interesting to look at.
50
 */
51
static const char * __unused
52
new_symlink(size_t __len)
53
{
54
	static const char linkname[] = "link";
55
	char target[MAXNAMLEN];
56
	int error;
57

58
	ATF_REQUIRE(__len <= sizeof(target));
59

60
	arc4random_buf(target, sizeof(target));
61

62
	error = unlink(linkname);
63
	ATF_REQUIRE(error == 0 || errno == ENOENT);
64

65
	error = symlink(target, linkname);
66
	ATF_REQUIRE(error == 0);
67

68
	return (linkname);
69
}
70

71
/*
72
 * For our purposes, first descriptor will be the reader; we'll send both
73
 * raw data and a control message over it so that the result can be used for
74
 * any of our recv*() tests.
75
 */
76
static void __unused
77
new_socket(int sock[2])
78
{
79
	unsigned char ctrl[CMSG_SPACE(sizeof(int))] = { 0 };
80
	static char sockbuf[256];
81
	ssize_t rv;
82
	size_t total = 0;
83
	struct msghdr hdr = { 0 };
84
	struct cmsghdr *cmsg;
85
	int error, fd;
86

87
	error = socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
88
	ATF_REQUIRE(error == 0);
89

90
	while (total != sizeof(sockbuf)) {
91
		rv = send(sock[1], &sockbuf[total], sizeof(sockbuf) - total, 0);
92

93
		ATF_REQUIRE_MSG(rv > 0,
94
		    "expected bytes sent, got %zd with %zu left (size %zu, total %zu)",
95
		    rv, sizeof(sockbuf) - total, sizeof(sockbuf), total);
96
		ATF_REQUIRE_MSG(total + (size_t)rv <= sizeof(sockbuf),
97
		    "%zd exceeds total %zu", rv, sizeof(sockbuf));
98
		total += rv;
99
	}
100

101
	hdr.msg_control = ctrl;
102
	hdr.msg_controllen = sizeof(ctrl);
103

104
	cmsg = CMSG_FIRSTHDR(&hdr);
105
	cmsg->cmsg_level = SOL_SOCKET;
106
	cmsg->cmsg_type = SCM_RIGHTS;
107
	cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
108
	fd = STDIN_FILENO;
109
	memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
110

111
	error = sendmsg(sock[1], &hdr, 0);
112
	ATF_REQUIRE(error != -1);
113
}
114

115
/*
116
 * Constructs a tmpfile that we can use for testing read(2) and friends.
117
 */
118
static int __unused
119
new_tmpfile(void)
120
{
121
	char buf[1024];
122
	ssize_t rv;
123
	size_t written;
124
	int fd;
125

126
	fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644);
127
	ATF_REQUIRE(fd >= 0);
128

129
	written = 0;
130
	while (written < TMPFILE_SIZE) {
131
		rv = write(fd, buf, sizeof(buf));
132
		ATF_REQUIRE(rv > 0);
133

134
		written += rv;
135
	}
136

137
	ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET));
138
	return (fd);
139
}
140

141
static void
142
disable_coredumps(void)
143
{
144
	struct rlimit rl = { 0 };
145

146
	if (setrlimit(RLIMIT_CORE, &rl) == -1)
147
		_exit(EX_OSERR);
148
}
149

150
/*
151
 * Replaces stdin with a file that we can actually read from, for tests where
152
 * we want a FILE * or fd that we can get data from.
153
 */
154
static void __unused
155
replace_stdin(void)
156
{
157
	int fd;
158

159
	fd = new_tmpfile();
160

161
	(void)dup2(fd, STDIN_FILENO);
162
	if (fd != STDIN_FILENO)
163
		close(fd);
164
}
165

166
ATF_TC(memcpy_before_end);
167
ATF_TC_HEAD(memcpy_before_end, tc)
168
{
169
}
170
ATF_TC_BODY(memcpy_before_end, tc)
171
{
172
#define BUF &__stack.__buf
173
	struct {
174
		uint8_t padding_l;
175
		unsigned char __buf[42];
176
		uint8_t padding_r;
177
	} __stack;
178
	const size_t __bufsz __unused = sizeof(__stack.__buf);
179
	const size_t __len = 42 - 1;
180
	const size_t __idx __unused = __len - 1;
181
	char src[__len + 10];
182

183
	memcpy(__stack.__buf, src, __len);
184
#undef BUF
185

186
}
187

188
ATF_TC(memcpy_end);
189
ATF_TC_HEAD(memcpy_end, tc)
190
{
191
}
192
ATF_TC_BODY(memcpy_end, tc)
193
{
194
#define BUF &__stack.__buf
195
	struct {
196
		uint8_t padding_l;
197
		unsigned char __buf[42];
198
		uint8_t padding_r;
199
	} __stack;
200
	const size_t __bufsz __unused = sizeof(__stack.__buf);
201
	const size_t __len = 42;
202
	const size_t __idx __unused = __len - 1;
203
	char src[__len + 10];
204

205
	memcpy(__stack.__buf, src, __len);
206
#undef BUF
207

208
}
209

210
ATF_TC(memcpy_heap_before_end);
211
ATF_TC_HEAD(memcpy_heap_before_end, tc)
212
{
213
}
214
ATF_TC_BODY(memcpy_heap_before_end, tc)
215
{
216
#define BUF __stack.__buf
217
	struct {
218
		uint8_t padding_l;
219
		unsigned char * __buf;
220
		uint8_t padding_r;
221
	} __stack;
222
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
223
	const size_t __len = 42 - 1;
224
	const size_t __idx __unused = __len - 1;
225
	char src[__len + 10];
226

227
	__stack.__buf = malloc(__bufsz);
228

229
	memcpy(__stack.__buf, src, __len);
230
#undef BUF
231

232
}
233

234
ATF_TC(memcpy_heap_end);
235
ATF_TC_HEAD(memcpy_heap_end, tc)
236
{
237
}
238
ATF_TC_BODY(memcpy_heap_end, tc)
239
{
240
#define BUF __stack.__buf
241
	struct {
242
		uint8_t padding_l;
243
		unsigned char * __buf;
244
		uint8_t padding_r;
245
	} __stack;
246
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
247
	const size_t __len = 42;
248
	const size_t __idx __unused = __len - 1;
249
	char src[__len + 10];
250

251
	__stack.__buf = malloc(__bufsz);
252

253
	memcpy(__stack.__buf, src, __len);
254
#undef BUF
255

256
}
257

258
ATF_TC(memcpy_heap_after_end);
259
ATF_TC_HEAD(memcpy_heap_after_end, tc)
260
{
261
}
262
ATF_TC_BODY(memcpy_heap_after_end, tc)
263
{
264
#define BUF __stack.__buf
265
	struct {
266
		uint8_t padding_l;
267
		unsigned char * __buf;
268
		uint8_t padding_r;
269
	} __stack;
270
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
271
	const size_t __len = 42 + 1;
272
	const size_t __idx __unused = __len - 1;
273
	pid_t __child;
274
	int __status;
275
	char src[__len + 10];
276

277
	__child = fork();
278
	ATF_REQUIRE(__child >= 0);
279
	if (__child > 0)
280
		goto monitor;
281

282
	/* Child */
283
	disable_coredumps();
284
	__stack.__buf = malloc(__bufsz);
285

286
	memcpy(__stack.__buf, src, __len);
287
	_exit(EX_SOFTWARE);	/* Should have aborted. */
288

289
monitor:
290
	while (waitpid(__child, &__status, 0) != __child) {
291
		ATF_REQUIRE_EQ(EINTR, errno);
292
	}
293

294
	if (!WIFSIGNALED(__status)) {
295
		switch (WEXITSTATUS(__status)) {
296
		case EX_SOFTWARE:
297
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
298
			break;
299
		case EX_OSERR:
300
			atf_tc_fail("setrlimit(2) failed");
301
			break;
302
		default:
303
			atf_tc_fail("child exited with status %d",
304
			    WEXITSTATUS(__status));
305
		}
306
	} else {
307
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
308
	}
309
#undef BUF
310

311
}
312

313
ATF_TC(mempcpy_before_end);
314
ATF_TC_HEAD(mempcpy_before_end, tc)
315
{
316
}
317
ATF_TC_BODY(mempcpy_before_end, tc)
318
{
319
#define BUF &__stack.__buf
320
	struct {
321
		uint8_t padding_l;
322
		unsigned char __buf[42];
323
		uint8_t padding_r;
324
	} __stack;
325
	const size_t __bufsz __unused = sizeof(__stack.__buf);
326
	const size_t __len = 42 - 1;
327
	const size_t __idx __unused = __len - 1;
328
	char src[__len + 10];
329

330
	mempcpy(__stack.__buf, src, __len);
331
#undef BUF
332

333
}
334

335
ATF_TC(mempcpy_end);
336
ATF_TC_HEAD(mempcpy_end, tc)
337
{
338
}
339
ATF_TC_BODY(mempcpy_end, tc)
340
{
341
#define BUF &__stack.__buf
342
	struct {
343
		uint8_t padding_l;
344
		unsigned char __buf[42];
345
		uint8_t padding_r;
346
	} __stack;
347
	const size_t __bufsz __unused = sizeof(__stack.__buf);
348
	const size_t __len = 42;
349
	const size_t __idx __unused = __len - 1;
350
	char src[__len + 10];
351

352
	mempcpy(__stack.__buf, src, __len);
353
#undef BUF
354

355
}
356

357
ATF_TC(mempcpy_heap_before_end);
358
ATF_TC_HEAD(mempcpy_heap_before_end, tc)
359
{
360
}
361
ATF_TC_BODY(mempcpy_heap_before_end, tc)
362
{
363
#define BUF __stack.__buf
364
	struct {
365
		uint8_t padding_l;
366
		unsigned char * __buf;
367
		uint8_t padding_r;
368
	} __stack;
369
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
370
	const size_t __len = 42 - 1;
371
	const size_t __idx __unused = __len - 1;
372
	char src[__len + 10];
373

374
	__stack.__buf = malloc(__bufsz);
375

376
	mempcpy(__stack.__buf, src, __len);
377
#undef BUF
378

379
}
380

381
ATF_TC(mempcpy_heap_end);
382
ATF_TC_HEAD(mempcpy_heap_end, tc)
383
{
384
}
385
ATF_TC_BODY(mempcpy_heap_end, tc)
386
{
387
#define BUF __stack.__buf
388
	struct {
389
		uint8_t padding_l;
390
		unsigned char * __buf;
391
		uint8_t padding_r;
392
	} __stack;
393
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
394
	const size_t __len = 42;
395
	const size_t __idx __unused = __len - 1;
396
	char src[__len + 10];
397

398
	__stack.__buf = malloc(__bufsz);
399

400
	mempcpy(__stack.__buf, src, __len);
401
#undef BUF
402

403
}
404

405
ATF_TC(mempcpy_heap_after_end);
406
ATF_TC_HEAD(mempcpy_heap_after_end, tc)
407
{
408
}
409
ATF_TC_BODY(mempcpy_heap_after_end, tc)
410
{
411
#define BUF __stack.__buf
412
	struct {
413
		uint8_t padding_l;
414
		unsigned char * __buf;
415
		uint8_t padding_r;
416
	} __stack;
417
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
418
	const size_t __len = 42 + 1;
419
	const size_t __idx __unused = __len - 1;
420
	pid_t __child;
421
	int __status;
422
	char src[__len + 10];
423

424
	__child = fork();
425
	ATF_REQUIRE(__child >= 0);
426
	if (__child > 0)
427
		goto monitor;
428

429
	/* Child */
430
	disable_coredumps();
431
	__stack.__buf = malloc(__bufsz);
432

433
	mempcpy(__stack.__buf, src, __len);
434
	_exit(EX_SOFTWARE);	/* Should have aborted. */
435

436
monitor:
437
	while (waitpid(__child, &__status, 0) != __child) {
438
		ATF_REQUIRE_EQ(EINTR, errno);
439
	}
440

441
	if (!WIFSIGNALED(__status)) {
442
		switch (WEXITSTATUS(__status)) {
443
		case EX_SOFTWARE:
444
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
445
			break;
446
		case EX_OSERR:
447
			atf_tc_fail("setrlimit(2) failed");
448
			break;
449
		default:
450
			atf_tc_fail("child exited with status %d",
451
			    WEXITSTATUS(__status));
452
		}
453
	} else {
454
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
455
	}
456
#undef BUF
457

458
}
459

460
ATF_TC(memmove_before_end);
461
ATF_TC_HEAD(memmove_before_end, tc)
462
{
463
}
464
ATF_TC_BODY(memmove_before_end, tc)
465
{
466
#define BUF &__stack.__buf
467
	struct {
468
		uint8_t padding_l;
469
		unsigned char __buf[42];
470
		uint8_t padding_r;
471
	} __stack;
472
	const size_t __bufsz __unused = sizeof(__stack.__buf);
473
	const size_t __len = 42 - 1;
474
	const size_t __idx __unused = __len - 1;
475
	char src[__len + 10];
476

477
	memmove(__stack.__buf, src, __len);
478
#undef BUF
479

480
}
481

482
ATF_TC(memmove_end);
483
ATF_TC_HEAD(memmove_end, tc)
484
{
485
}
486
ATF_TC_BODY(memmove_end, tc)
487
{
488
#define BUF &__stack.__buf
489
	struct {
490
		uint8_t padding_l;
491
		unsigned char __buf[42];
492
		uint8_t padding_r;
493
	} __stack;
494
	const size_t __bufsz __unused = sizeof(__stack.__buf);
495
	const size_t __len = 42;
496
	const size_t __idx __unused = __len - 1;
497
	char src[__len + 10];
498

499
	memmove(__stack.__buf, src, __len);
500
#undef BUF
501

502
}
503

504
ATF_TC(memmove_heap_before_end);
505
ATF_TC_HEAD(memmove_heap_before_end, tc)
506
{
507
}
508
ATF_TC_BODY(memmove_heap_before_end, tc)
509
{
510
#define BUF __stack.__buf
511
	struct {
512
		uint8_t padding_l;
513
		unsigned char * __buf;
514
		uint8_t padding_r;
515
	} __stack;
516
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
517
	const size_t __len = 42 - 1;
518
	const size_t __idx __unused = __len - 1;
519
	char src[__len + 10];
520

521
	__stack.__buf = malloc(__bufsz);
522

523
	memmove(__stack.__buf, src, __len);
524
#undef BUF
525

526
}
527

528
ATF_TC(memmove_heap_end);
529
ATF_TC_HEAD(memmove_heap_end, tc)
530
{
531
}
532
ATF_TC_BODY(memmove_heap_end, tc)
533
{
534
#define BUF __stack.__buf
535
	struct {
536
		uint8_t padding_l;
537
		unsigned char * __buf;
538
		uint8_t padding_r;
539
	} __stack;
540
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
541
	const size_t __len = 42;
542
	const size_t __idx __unused = __len - 1;
543
	char src[__len + 10];
544

545
	__stack.__buf = malloc(__bufsz);
546

547
	memmove(__stack.__buf, src, __len);
548
#undef BUF
549

550
}
551

552
ATF_TC(memmove_heap_after_end);
553
ATF_TC_HEAD(memmove_heap_after_end, tc)
554
{
555
}
556
ATF_TC_BODY(memmove_heap_after_end, tc)
557
{
558
#define BUF __stack.__buf
559
	struct {
560
		uint8_t padding_l;
561
		unsigned char * __buf;
562
		uint8_t padding_r;
563
	} __stack;
564
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
565
	const size_t __len = 42 + 1;
566
	const size_t __idx __unused = __len - 1;
567
	pid_t __child;
568
	int __status;
569
	char src[__len + 10];
570

571
	__child = fork();
572
	ATF_REQUIRE(__child >= 0);
573
	if (__child > 0)
574
		goto monitor;
575

576
	/* Child */
577
	disable_coredumps();
578
	__stack.__buf = malloc(__bufsz);
579

580
	memmove(__stack.__buf, src, __len);
581
	_exit(EX_SOFTWARE);	/* Should have aborted. */
582

583
monitor:
584
	while (waitpid(__child, &__status, 0) != __child) {
585
		ATF_REQUIRE_EQ(EINTR, errno);
586
	}
587

588
	if (!WIFSIGNALED(__status)) {
589
		switch (WEXITSTATUS(__status)) {
590
		case EX_SOFTWARE:
591
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
592
			break;
593
		case EX_OSERR:
594
			atf_tc_fail("setrlimit(2) failed");
595
			break;
596
		default:
597
			atf_tc_fail("child exited with status %d",
598
			    WEXITSTATUS(__status));
599
		}
600
	} else {
601
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
602
	}
603
#undef BUF
604

605
}
606

607
ATF_TC(memset_before_end);
608
ATF_TC_HEAD(memset_before_end, tc)
609
{
610
}
611
ATF_TC_BODY(memset_before_end, tc)
612
{
613
#define BUF &__stack.__buf
614
	struct {
615
		uint8_t padding_l;
616
		unsigned char __buf[42];
617
		uint8_t padding_r;
618
	} __stack;
619
	const size_t __bufsz __unused = sizeof(__stack.__buf);
620
	const size_t __len = 42 - 1;
621
	const size_t __idx __unused = __len - 1;
622

623
	memset(__stack.__buf, 0, __len);
624
#undef BUF
625

626
}
627

628
ATF_TC(memset_end);
629
ATF_TC_HEAD(memset_end, tc)
630
{
631
}
632
ATF_TC_BODY(memset_end, tc)
633
{
634
#define BUF &__stack.__buf
635
	struct {
636
		uint8_t padding_l;
637
		unsigned char __buf[42];
638
		uint8_t padding_r;
639
	} __stack;
640
	const size_t __bufsz __unused = sizeof(__stack.__buf);
641
	const size_t __len = 42;
642
	const size_t __idx __unused = __len - 1;
643

644
	memset(__stack.__buf, 0, __len);
645
#undef BUF
646

647
}
648

649
ATF_TC(memset_heap_before_end);
650
ATF_TC_HEAD(memset_heap_before_end, tc)
651
{
652
}
653
ATF_TC_BODY(memset_heap_before_end, tc)
654
{
655
#define BUF __stack.__buf
656
	struct {
657
		uint8_t padding_l;
658
		unsigned char * __buf;
659
		uint8_t padding_r;
660
	} __stack;
661
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
662
	const size_t __len = 42 - 1;
663
	const size_t __idx __unused = __len - 1;
664

665
	__stack.__buf = malloc(__bufsz);
666

667
	memset(__stack.__buf, 0, __len);
668
#undef BUF
669

670
}
671

672
ATF_TC(memset_heap_end);
673
ATF_TC_HEAD(memset_heap_end, tc)
674
{
675
}
676
ATF_TC_BODY(memset_heap_end, tc)
677
{
678
#define BUF __stack.__buf
679
	struct {
680
		uint8_t padding_l;
681
		unsigned char * __buf;
682
		uint8_t padding_r;
683
	} __stack;
684
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
685
	const size_t __len = 42;
686
	const size_t __idx __unused = __len - 1;
687

688
	__stack.__buf = malloc(__bufsz);
689

690
	memset(__stack.__buf, 0, __len);
691
#undef BUF
692

693
}
694

695
ATF_TC(memset_heap_after_end);
696
ATF_TC_HEAD(memset_heap_after_end, tc)
697
{
698
}
699
ATF_TC_BODY(memset_heap_after_end, tc)
700
{
701
#define BUF __stack.__buf
702
	struct {
703
		uint8_t padding_l;
704
		unsigned char * __buf;
705
		uint8_t padding_r;
706
	} __stack;
707
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
708
	const size_t __len = 42 + 1;
709
	const size_t __idx __unused = __len - 1;
710
	pid_t __child;
711
	int __status;
712

713
	__child = fork();
714
	ATF_REQUIRE(__child >= 0);
715
	if (__child > 0)
716
		goto monitor;
717

718
	/* Child */
719
	disable_coredumps();
720
	__stack.__buf = malloc(__bufsz);
721

722
	memset(__stack.__buf, 0, __len);
723
	_exit(EX_SOFTWARE);	/* Should have aborted. */
724

725
monitor:
726
	while (waitpid(__child, &__status, 0) != __child) {
727
		ATF_REQUIRE_EQ(EINTR, errno);
728
	}
729

730
	if (!WIFSIGNALED(__status)) {
731
		switch (WEXITSTATUS(__status)) {
732
		case EX_SOFTWARE:
733
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
734
			break;
735
		case EX_OSERR:
736
			atf_tc_fail("setrlimit(2) failed");
737
			break;
738
		default:
739
			atf_tc_fail("child exited with status %d",
740
			    WEXITSTATUS(__status));
741
		}
742
	} else {
743
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
744
	}
745
#undef BUF
746

747
}
748

749
ATF_TC(memset_explicit_before_end);
750
ATF_TC_HEAD(memset_explicit_before_end, tc)
751
{
752
}
753
ATF_TC_BODY(memset_explicit_before_end, tc)
754
{
755
#define BUF &__stack.__buf
756
	struct {
757
		uint8_t padding_l;
758
		unsigned char __buf[42];
759
		uint8_t padding_r;
760
	} __stack;
761
	const size_t __bufsz __unused = sizeof(__stack.__buf);
762
	const size_t __len = 42 - 1;
763
	const size_t __idx __unused = __len - 1;
764

765
	memset_explicit(__stack.__buf, 0, __len);
766
#undef BUF
767

768
}
769

770
ATF_TC(memset_explicit_end);
771
ATF_TC_HEAD(memset_explicit_end, tc)
772
{
773
}
774
ATF_TC_BODY(memset_explicit_end, tc)
775
{
776
#define BUF &__stack.__buf
777
	struct {
778
		uint8_t padding_l;
779
		unsigned char __buf[42];
780
		uint8_t padding_r;
781
	} __stack;
782
	const size_t __bufsz __unused = sizeof(__stack.__buf);
783
	const size_t __len = 42;
784
	const size_t __idx __unused = __len - 1;
785

786
	memset_explicit(__stack.__buf, 0, __len);
787
#undef BUF
788

789
}
790

791
ATF_TC(memset_explicit_heap_before_end);
792
ATF_TC_HEAD(memset_explicit_heap_before_end, tc)
793
{
794
}
795
ATF_TC_BODY(memset_explicit_heap_before_end, tc)
796
{
797
#define BUF __stack.__buf
798
	struct {
799
		uint8_t padding_l;
800
		unsigned char * __buf;
801
		uint8_t padding_r;
802
	} __stack;
803
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
804
	const size_t __len = 42 - 1;
805
	const size_t __idx __unused = __len - 1;
806

807
	__stack.__buf = malloc(__bufsz);
808

809
	memset_explicit(__stack.__buf, 0, __len);
810
#undef BUF
811

812
}
813

814
ATF_TC(memset_explicit_heap_end);
815
ATF_TC_HEAD(memset_explicit_heap_end, tc)
816
{
817
}
818
ATF_TC_BODY(memset_explicit_heap_end, tc)
819
{
820
#define BUF __stack.__buf
821
	struct {
822
		uint8_t padding_l;
823
		unsigned char * __buf;
824
		uint8_t padding_r;
825
	} __stack;
826
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
827
	const size_t __len = 42;
828
	const size_t __idx __unused = __len - 1;
829

830
	__stack.__buf = malloc(__bufsz);
831

832
	memset_explicit(__stack.__buf, 0, __len);
833
#undef BUF
834

835
}
836

837
ATF_TC(memset_explicit_heap_after_end);
838
ATF_TC_HEAD(memset_explicit_heap_after_end, tc)
839
{
840
}
841
ATF_TC_BODY(memset_explicit_heap_after_end, tc)
842
{
843
#define BUF __stack.__buf
844
	struct {
845
		uint8_t padding_l;
846
		unsigned char * __buf;
847
		uint8_t padding_r;
848
	} __stack;
849
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
850
	const size_t __len = 42 + 1;
851
	const size_t __idx __unused = __len - 1;
852
	pid_t __child;
853
	int __status;
854

855
	__child = fork();
856
	ATF_REQUIRE(__child >= 0);
857
	if (__child > 0)
858
		goto monitor;
859

860
	/* Child */
861
	disable_coredumps();
862
	__stack.__buf = malloc(__bufsz);
863

864
	memset_explicit(__stack.__buf, 0, __len);
865
	_exit(EX_SOFTWARE);	/* Should have aborted. */
866

867
monitor:
868
	while (waitpid(__child, &__status, 0) != __child) {
869
		ATF_REQUIRE_EQ(EINTR, errno);
870
	}
871

872
	if (!WIFSIGNALED(__status)) {
873
		switch (WEXITSTATUS(__status)) {
874
		case EX_SOFTWARE:
875
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
876
			break;
877
		case EX_OSERR:
878
			atf_tc_fail("setrlimit(2) failed");
879
			break;
880
		default:
881
			atf_tc_fail("child exited with status %d",
882
			    WEXITSTATUS(__status));
883
		}
884
	} else {
885
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
886
	}
887
#undef BUF
888

889
}
890

891
ATF_TC(stpcpy_before_end);
892
ATF_TC_HEAD(stpcpy_before_end, tc)
893
{
894
}
895
ATF_TC_BODY(stpcpy_before_end, tc)
896
{
897
#define BUF &__stack.__buf
898
	struct {
899
		uint8_t padding_l;
900
		unsigned char __buf[42];
901
		uint8_t padding_r;
902
	} __stack;
903
	const size_t __bufsz __unused = sizeof(__stack.__buf);
904
	const size_t __len = 42 - 1;
905
	const size_t __idx __unused = __len - 1;
906
	char src[__len];
907

908
	memset(__stack.__buf, 0, __len);
909
	memset(src, 'A', __len - 1);
910
	src[__len - 1] = '\0';
911

912
	stpcpy(__stack.__buf, src);
913
#undef BUF
914

915
}
916

917
ATF_TC(stpcpy_end);
918
ATF_TC_HEAD(stpcpy_end, tc)
919
{
920
}
921
ATF_TC_BODY(stpcpy_end, tc)
922
{
923
#define BUF &__stack.__buf
924
	struct {
925
		uint8_t padding_l;
926
		unsigned char __buf[42];
927
		uint8_t padding_r;
928
	} __stack;
929
	const size_t __bufsz __unused = sizeof(__stack.__buf);
930
	const size_t __len = 42;
931
	const size_t __idx __unused = __len - 1;
932
	char src[__len];
933

934
	memset(__stack.__buf, 0, __len);
935
	memset(src, 'A', __len - 1);
936
	src[__len - 1] = '\0';
937

938
	stpcpy(__stack.__buf, src);
939
#undef BUF
940

941
}
942

943
ATF_TC(stpcpy_heap_before_end);
944
ATF_TC_HEAD(stpcpy_heap_before_end, tc)
945
{
946
}
947
ATF_TC_BODY(stpcpy_heap_before_end, tc)
948
{
949
#define BUF __stack.__buf
950
	struct {
951
		uint8_t padding_l;
952
		unsigned char * __buf;
953
		uint8_t padding_r;
954
	} __stack;
955
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
956
	const size_t __len = 42 - 1;
957
	const size_t __idx __unused = __len - 1;
958
	char src[__len];
959

960
	__stack.__buf = malloc(__bufsz);
961
	memset(__stack.__buf, 0, __len);
962
	memset(src, 'A', __len - 1);
963
	src[__len - 1] = '\0';
964

965
	stpcpy(__stack.__buf, src);
966
#undef BUF
967

968
}
969

970
ATF_TC(stpcpy_heap_end);
971
ATF_TC_HEAD(stpcpy_heap_end, tc)
972
{
973
}
974
ATF_TC_BODY(stpcpy_heap_end, tc)
975
{
976
#define BUF __stack.__buf
977
	struct {
978
		uint8_t padding_l;
979
		unsigned char * __buf;
980
		uint8_t padding_r;
981
	} __stack;
982
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
983
	const size_t __len = 42;
984
	const size_t __idx __unused = __len - 1;
985
	char src[__len];
986

987
	__stack.__buf = malloc(__bufsz);
988
	memset(__stack.__buf, 0, __len);
989
	memset(src, 'A', __len - 1);
990
	src[__len - 1] = '\0';
991

992
	stpcpy(__stack.__buf, src);
993
#undef BUF
994

995
}
996

997
ATF_TC(stpcpy_heap_after_end);
998
ATF_TC_HEAD(stpcpy_heap_after_end, tc)
999
{
1000
}
1001
ATF_TC_BODY(stpcpy_heap_after_end, tc)
1002
{
1003
#define BUF __stack.__buf
1004
	struct {
1005
		uint8_t padding_l;
1006
		unsigned char * __buf;
1007
		uint8_t padding_r;
1008
	} __stack;
1009
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1010
	const size_t __len = 42 + 1;
1011
	const size_t __idx __unused = __len - 1;
1012
	pid_t __child;
1013
	int __status;
1014
	char src[__len];
1015

1016
	__child = fork();
1017
	ATF_REQUIRE(__child >= 0);
1018
	if (__child > 0)
1019
		goto monitor;
1020

1021
	/* Child */
1022
	disable_coredumps();
1023
	__stack.__buf = malloc(__bufsz);
1024
	memset(__stack.__buf, 0, __len);
1025
	memset(src, 'A', __len - 1);
1026
	src[__len - 1] = '\0';
1027

1028
	stpcpy(__stack.__buf, src);
1029
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1030

1031
monitor:
1032
	while (waitpid(__child, &__status, 0) != __child) {
1033
		ATF_REQUIRE_EQ(EINTR, errno);
1034
	}
1035

1036
	if (!WIFSIGNALED(__status)) {
1037
		switch (WEXITSTATUS(__status)) {
1038
		case EX_SOFTWARE:
1039
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1040
			break;
1041
		case EX_OSERR:
1042
			atf_tc_fail("setrlimit(2) failed");
1043
			break;
1044
		default:
1045
			atf_tc_fail("child exited with status %d",
1046
			    WEXITSTATUS(__status));
1047
		}
1048
	} else {
1049
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1050
	}
1051
#undef BUF
1052

1053
}
1054

1055
ATF_TC(stpncpy_before_end);
1056
ATF_TC_HEAD(stpncpy_before_end, tc)
1057
{
1058
}
1059
ATF_TC_BODY(stpncpy_before_end, tc)
1060
{
1061
#define BUF &__stack.__buf
1062
	struct {
1063
		uint8_t padding_l;
1064
		unsigned char __buf[42];
1065
		uint8_t padding_r;
1066
	} __stack;
1067
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1068
	const size_t __len = 42 - 1;
1069
	const size_t __idx __unused = __len - 1;
1070
	char src[__len];
1071

1072
	memset(__stack.__buf, 0, __len);
1073
	memset(src, 'A', __len - 1);
1074
	src[__len - 1] = '\0';
1075

1076
	stpncpy(__stack.__buf, src, __len);
1077
#undef BUF
1078

1079
}
1080

1081
ATF_TC(stpncpy_end);
1082
ATF_TC_HEAD(stpncpy_end, tc)
1083
{
1084
}
1085
ATF_TC_BODY(stpncpy_end, tc)
1086
{
1087
#define BUF &__stack.__buf
1088
	struct {
1089
		uint8_t padding_l;
1090
		unsigned char __buf[42];
1091
		uint8_t padding_r;
1092
	} __stack;
1093
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1094
	const size_t __len = 42;
1095
	const size_t __idx __unused = __len - 1;
1096
	char src[__len];
1097

1098
	memset(__stack.__buf, 0, __len);
1099
	memset(src, 'A', __len - 1);
1100
	src[__len - 1] = '\0';
1101

1102
	stpncpy(__stack.__buf, src, __len);
1103
#undef BUF
1104

1105
}
1106

1107
ATF_TC(stpncpy_heap_before_end);
1108
ATF_TC_HEAD(stpncpy_heap_before_end, tc)
1109
{
1110
}
1111
ATF_TC_BODY(stpncpy_heap_before_end, tc)
1112
{
1113
#define BUF __stack.__buf
1114
	struct {
1115
		uint8_t padding_l;
1116
		unsigned char * __buf;
1117
		uint8_t padding_r;
1118
	} __stack;
1119
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1120
	const size_t __len = 42 - 1;
1121
	const size_t __idx __unused = __len - 1;
1122
	char src[__len];
1123

1124
	__stack.__buf = malloc(__bufsz);
1125
	memset(__stack.__buf, 0, __len);
1126
	memset(src, 'A', __len - 1);
1127
	src[__len - 1] = '\0';
1128

1129
	stpncpy(__stack.__buf, src, __len);
1130
#undef BUF
1131

1132
}
1133

1134
ATF_TC(stpncpy_heap_end);
1135
ATF_TC_HEAD(stpncpy_heap_end, tc)
1136
{
1137
}
1138
ATF_TC_BODY(stpncpy_heap_end, tc)
1139
{
1140
#define BUF __stack.__buf
1141
	struct {
1142
		uint8_t padding_l;
1143
		unsigned char * __buf;
1144
		uint8_t padding_r;
1145
	} __stack;
1146
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1147
	const size_t __len = 42;
1148
	const size_t __idx __unused = __len - 1;
1149
	char src[__len];
1150

1151
	__stack.__buf = malloc(__bufsz);
1152
	memset(__stack.__buf, 0, __len);
1153
	memset(src, 'A', __len - 1);
1154
	src[__len - 1] = '\0';
1155

1156
	stpncpy(__stack.__buf, src, __len);
1157
#undef BUF
1158

1159
}
1160

1161
ATF_TC(stpncpy_heap_after_end);
1162
ATF_TC_HEAD(stpncpy_heap_after_end, tc)
1163
{
1164
}
1165
ATF_TC_BODY(stpncpy_heap_after_end, tc)
1166
{
1167
#define BUF __stack.__buf
1168
	struct {
1169
		uint8_t padding_l;
1170
		unsigned char * __buf;
1171
		uint8_t padding_r;
1172
	} __stack;
1173
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1174
	const size_t __len = 42 + 1;
1175
	const size_t __idx __unused = __len - 1;
1176
	pid_t __child;
1177
	int __status;
1178
	char src[__len];
1179

1180
	__child = fork();
1181
	ATF_REQUIRE(__child >= 0);
1182
	if (__child > 0)
1183
		goto monitor;
1184

1185
	/* Child */
1186
	disable_coredumps();
1187
	__stack.__buf = malloc(__bufsz);
1188
	memset(__stack.__buf, 0, __len);
1189
	memset(src, 'A', __len - 1);
1190
	src[__len - 1] = '\0';
1191

1192
	stpncpy(__stack.__buf, src, __len);
1193
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1194

1195
monitor:
1196
	while (waitpid(__child, &__status, 0) != __child) {
1197
		ATF_REQUIRE_EQ(EINTR, errno);
1198
	}
1199

1200
	if (!WIFSIGNALED(__status)) {
1201
		switch (WEXITSTATUS(__status)) {
1202
		case EX_SOFTWARE:
1203
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1204
			break;
1205
		case EX_OSERR:
1206
			atf_tc_fail("setrlimit(2) failed");
1207
			break;
1208
		default:
1209
			atf_tc_fail("child exited with status %d",
1210
			    WEXITSTATUS(__status));
1211
		}
1212
	} else {
1213
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1214
	}
1215
#undef BUF
1216

1217
}
1218

1219
ATF_TC(strcat_before_end);
1220
ATF_TC_HEAD(strcat_before_end, tc)
1221
{
1222
}
1223
ATF_TC_BODY(strcat_before_end, tc)
1224
{
1225
#define BUF &__stack.__buf
1226
	struct {
1227
		uint8_t padding_l;
1228
		unsigned char __buf[42];
1229
		uint8_t padding_r;
1230
	} __stack;
1231
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1232
	const size_t __len = 42 - 1;
1233
	const size_t __idx __unused = __len - 1;
1234
	char src[__len];
1235

1236
	memset(__stack.__buf, 0, __len);
1237
	memset(src, 'A', __len - 1);
1238
	src[__len - 1] = '\0';
1239

1240
	strcat(__stack.__buf, src);
1241
#undef BUF
1242

1243
}
1244

1245
ATF_TC(strcat_end);
1246
ATF_TC_HEAD(strcat_end, tc)
1247
{
1248
}
1249
ATF_TC_BODY(strcat_end, tc)
1250
{
1251
#define BUF &__stack.__buf
1252
	struct {
1253
		uint8_t padding_l;
1254
		unsigned char __buf[42];
1255
		uint8_t padding_r;
1256
	} __stack;
1257
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1258
	const size_t __len = 42;
1259
	const size_t __idx __unused = __len - 1;
1260
	char src[__len];
1261

1262
	memset(__stack.__buf, 0, __len);
1263
	memset(src, 'A', __len - 1);
1264
	src[__len - 1] = '\0';
1265

1266
	strcat(__stack.__buf, src);
1267
#undef BUF
1268

1269
}
1270

1271
ATF_TC(strcat_heap_before_end);
1272
ATF_TC_HEAD(strcat_heap_before_end, tc)
1273
{
1274
}
1275
ATF_TC_BODY(strcat_heap_before_end, tc)
1276
{
1277
#define BUF __stack.__buf
1278
	struct {
1279
		uint8_t padding_l;
1280
		unsigned char * __buf;
1281
		uint8_t padding_r;
1282
	} __stack;
1283
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1284
	const size_t __len = 42 - 1;
1285
	const size_t __idx __unused = __len - 1;
1286
	char src[__len];
1287

1288
	__stack.__buf = malloc(__bufsz);
1289
	memset(__stack.__buf, 0, __len);
1290
	memset(src, 'A', __len - 1);
1291
	src[__len - 1] = '\0';
1292

1293
	strcat(__stack.__buf, src);
1294
#undef BUF
1295

1296
}
1297

1298
ATF_TC(strcat_heap_end);
1299
ATF_TC_HEAD(strcat_heap_end, tc)
1300
{
1301
}
1302
ATF_TC_BODY(strcat_heap_end, tc)
1303
{
1304
#define BUF __stack.__buf
1305
	struct {
1306
		uint8_t padding_l;
1307
		unsigned char * __buf;
1308
		uint8_t padding_r;
1309
	} __stack;
1310
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1311
	const size_t __len = 42;
1312
	const size_t __idx __unused = __len - 1;
1313
	char src[__len];
1314

1315
	__stack.__buf = malloc(__bufsz);
1316
	memset(__stack.__buf, 0, __len);
1317
	memset(src, 'A', __len - 1);
1318
	src[__len - 1] = '\0';
1319

1320
	strcat(__stack.__buf, src);
1321
#undef BUF
1322

1323
}
1324

1325
ATF_TC(strcat_heap_after_end);
1326
ATF_TC_HEAD(strcat_heap_after_end, tc)
1327
{
1328
}
1329
ATF_TC_BODY(strcat_heap_after_end, tc)
1330
{
1331
#define BUF __stack.__buf
1332
	struct {
1333
		uint8_t padding_l;
1334
		unsigned char * __buf;
1335
		uint8_t padding_r;
1336
	} __stack;
1337
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1338
	const size_t __len = 42 + 1;
1339
	const size_t __idx __unused = __len - 1;
1340
	pid_t __child;
1341
	int __status;
1342
	char src[__len];
1343

1344
	__child = fork();
1345
	ATF_REQUIRE(__child >= 0);
1346
	if (__child > 0)
1347
		goto monitor;
1348

1349
	/* Child */
1350
	disable_coredumps();
1351
	__stack.__buf = malloc(__bufsz);
1352
	memset(__stack.__buf, 0, __len);
1353
	memset(src, 'A', __len - 1);
1354
	src[__len - 1] = '\0';
1355

1356
	strcat(__stack.__buf, src);
1357
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1358

1359
monitor:
1360
	while (waitpid(__child, &__status, 0) != __child) {
1361
		ATF_REQUIRE_EQ(EINTR, errno);
1362
	}
1363

1364
	if (!WIFSIGNALED(__status)) {
1365
		switch (WEXITSTATUS(__status)) {
1366
		case EX_SOFTWARE:
1367
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1368
			break;
1369
		case EX_OSERR:
1370
			atf_tc_fail("setrlimit(2) failed");
1371
			break;
1372
		default:
1373
			atf_tc_fail("child exited with status %d",
1374
			    WEXITSTATUS(__status));
1375
		}
1376
	} else {
1377
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1378
	}
1379
#undef BUF
1380

1381
}
1382

1383
ATF_TC(strlcat_before_end);
1384
ATF_TC_HEAD(strlcat_before_end, tc)
1385
{
1386
}
1387
ATF_TC_BODY(strlcat_before_end, tc)
1388
{
1389
#define BUF &__stack.__buf
1390
	struct {
1391
		uint8_t padding_l;
1392
		unsigned char __buf[42];
1393
		uint8_t padding_r;
1394
	} __stack;
1395
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1396
	const size_t __len = 42 - 1;
1397
	const size_t __idx __unused = __len - 1;
1398
	char src[__len];
1399

1400
	memset(__stack.__buf, 0, __len);
1401
	memset(src, 'A', __len - 1);
1402
	src[__len - 1] = '\0';
1403

1404
	strlcat(__stack.__buf, src, __len);
1405
#undef BUF
1406

1407
}
1408

1409
ATF_TC(strlcat_end);
1410
ATF_TC_HEAD(strlcat_end, tc)
1411
{
1412
}
1413
ATF_TC_BODY(strlcat_end, tc)
1414
{
1415
#define BUF &__stack.__buf
1416
	struct {
1417
		uint8_t padding_l;
1418
		unsigned char __buf[42];
1419
		uint8_t padding_r;
1420
	} __stack;
1421
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1422
	const size_t __len = 42;
1423
	const size_t __idx __unused = __len - 1;
1424
	char src[__len];
1425

1426
	memset(__stack.__buf, 0, __len);
1427
	memset(src, 'A', __len - 1);
1428
	src[__len - 1] = '\0';
1429

1430
	strlcat(__stack.__buf, src, __len);
1431
#undef BUF
1432

1433
}
1434

1435
ATF_TC(strlcat_heap_before_end);
1436
ATF_TC_HEAD(strlcat_heap_before_end, tc)
1437
{
1438
}
1439
ATF_TC_BODY(strlcat_heap_before_end, tc)
1440
{
1441
#define BUF __stack.__buf
1442
	struct {
1443
		uint8_t padding_l;
1444
		unsigned char * __buf;
1445
		uint8_t padding_r;
1446
	} __stack;
1447
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1448
	const size_t __len = 42 - 1;
1449
	const size_t __idx __unused = __len - 1;
1450
	char src[__len];
1451

1452
	__stack.__buf = malloc(__bufsz);
1453
	memset(__stack.__buf, 0, __len);
1454
	memset(src, 'A', __len - 1);
1455
	src[__len - 1] = '\0';
1456

1457
	strlcat(__stack.__buf, src, __len);
1458
#undef BUF
1459

1460
}
1461

1462
ATF_TC(strlcat_heap_end);
1463
ATF_TC_HEAD(strlcat_heap_end, tc)
1464
{
1465
}
1466
ATF_TC_BODY(strlcat_heap_end, tc)
1467
{
1468
#define BUF __stack.__buf
1469
	struct {
1470
		uint8_t padding_l;
1471
		unsigned char * __buf;
1472
		uint8_t padding_r;
1473
	} __stack;
1474
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1475
	const size_t __len = 42;
1476
	const size_t __idx __unused = __len - 1;
1477
	char src[__len];
1478

1479
	__stack.__buf = malloc(__bufsz);
1480
	memset(__stack.__buf, 0, __len);
1481
	memset(src, 'A', __len - 1);
1482
	src[__len - 1] = '\0';
1483

1484
	strlcat(__stack.__buf, src, __len);
1485
#undef BUF
1486

1487
}
1488

1489
ATF_TC(strlcat_heap_after_end);
1490
ATF_TC_HEAD(strlcat_heap_after_end, tc)
1491
{
1492
}
1493
ATF_TC_BODY(strlcat_heap_after_end, tc)
1494
{
1495
#define BUF __stack.__buf
1496
	struct {
1497
		uint8_t padding_l;
1498
		unsigned char * __buf;
1499
		uint8_t padding_r;
1500
	} __stack;
1501
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1502
	const size_t __len = 42 + 1;
1503
	const size_t __idx __unused = __len - 1;
1504
	pid_t __child;
1505
	int __status;
1506
	char src[__len];
1507

1508
	__child = fork();
1509
	ATF_REQUIRE(__child >= 0);
1510
	if (__child > 0)
1511
		goto monitor;
1512

1513
	/* Child */
1514
	disable_coredumps();
1515
	__stack.__buf = malloc(__bufsz);
1516
	memset(__stack.__buf, 0, __len);
1517
	memset(src, 'A', __len - 1);
1518
	src[__len - 1] = '\0';
1519

1520
	strlcat(__stack.__buf, src, __len);
1521
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1522

1523
monitor:
1524
	while (waitpid(__child, &__status, 0) != __child) {
1525
		ATF_REQUIRE_EQ(EINTR, errno);
1526
	}
1527

1528
	if (!WIFSIGNALED(__status)) {
1529
		switch (WEXITSTATUS(__status)) {
1530
		case EX_SOFTWARE:
1531
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1532
			break;
1533
		case EX_OSERR:
1534
			atf_tc_fail("setrlimit(2) failed");
1535
			break;
1536
		default:
1537
			atf_tc_fail("child exited with status %d",
1538
			    WEXITSTATUS(__status));
1539
		}
1540
	} else {
1541
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1542
	}
1543
#undef BUF
1544

1545
}
1546

1547
ATF_TC(strncat_before_end);
1548
ATF_TC_HEAD(strncat_before_end, tc)
1549
{
1550
}
1551
ATF_TC_BODY(strncat_before_end, tc)
1552
{
1553
#define BUF &__stack.__buf
1554
	struct {
1555
		uint8_t padding_l;
1556
		unsigned char __buf[42];
1557
		uint8_t padding_r;
1558
	} __stack;
1559
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1560
	const size_t __len = 42 - 1;
1561
	const size_t __idx __unused = __len - 1;
1562
	char src[__len];
1563

1564
	memset(__stack.__buf, 0, __len);
1565
	memset(src, 'A', __len - 1);
1566
	src[__len - 1] = '\0';
1567

1568
	strncat(__stack.__buf, src, __len);
1569
#undef BUF
1570

1571
}
1572

1573
ATF_TC(strncat_end);
1574
ATF_TC_HEAD(strncat_end, tc)
1575
{
1576
}
1577
ATF_TC_BODY(strncat_end, tc)
1578
{
1579
#define BUF &__stack.__buf
1580
	struct {
1581
		uint8_t padding_l;
1582
		unsigned char __buf[42];
1583
		uint8_t padding_r;
1584
	} __stack;
1585
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1586
	const size_t __len = 42;
1587
	const size_t __idx __unused = __len - 1;
1588
	char src[__len];
1589

1590
	memset(__stack.__buf, 0, __len);
1591
	memset(src, 'A', __len - 1);
1592
	src[__len - 1] = '\0';
1593

1594
	strncat(__stack.__buf, src, __len);
1595
#undef BUF
1596

1597
}
1598

1599
ATF_TC(strncat_heap_before_end);
1600
ATF_TC_HEAD(strncat_heap_before_end, tc)
1601
{
1602
}
1603
ATF_TC_BODY(strncat_heap_before_end, tc)
1604
{
1605
#define BUF __stack.__buf
1606
	struct {
1607
		uint8_t padding_l;
1608
		unsigned char * __buf;
1609
		uint8_t padding_r;
1610
	} __stack;
1611
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1612
	const size_t __len = 42 - 1;
1613
	const size_t __idx __unused = __len - 1;
1614
	char src[__len];
1615

1616
	__stack.__buf = malloc(__bufsz);
1617
	memset(__stack.__buf, 0, __len);
1618
	memset(src, 'A', __len - 1);
1619
	src[__len - 1] = '\0';
1620

1621
	strncat(__stack.__buf, src, __len);
1622
#undef BUF
1623

1624
}
1625

1626
ATF_TC(strncat_heap_end);
1627
ATF_TC_HEAD(strncat_heap_end, tc)
1628
{
1629
}
1630
ATF_TC_BODY(strncat_heap_end, tc)
1631
{
1632
#define BUF __stack.__buf
1633
	struct {
1634
		uint8_t padding_l;
1635
		unsigned char * __buf;
1636
		uint8_t padding_r;
1637
	} __stack;
1638
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1639
	const size_t __len = 42;
1640
	const size_t __idx __unused = __len - 1;
1641
	char src[__len];
1642

1643
	__stack.__buf = malloc(__bufsz);
1644
	memset(__stack.__buf, 0, __len);
1645
	memset(src, 'A', __len - 1);
1646
	src[__len - 1] = '\0';
1647

1648
	strncat(__stack.__buf, src, __len);
1649
#undef BUF
1650

1651
}
1652

1653
ATF_TC(strncat_heap_after_end);
1654
ATF_TC_HEAD(strncat_heap_after_end, tc)
1655
{
1656
}
1657
ATF_TC_BODY(strncat_heap_after_end, tc)
1658
{
1659
#define BUF __stack.__buf
1660
	struct {
1661
		uint8_t padding_l;
1662
		unsigned char * __buf;
1663
		uint8_t padding_r;
1664
	} __stack;
1665
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1666
	const size_t __len = 42 + 1;
1667
	const size_t __idx __unused = __len - 1;
1668
	pid_t __child;
1669
	int __status;
1670
	char src[__len];
1671

1672
	__child = fork();
1673
	ATF_REQUIRE(__child >= 0);
1674
	if (__child > 0)
1675
		goto monitor;
1676

1677
	/* Child */
1678
	disable_coredumps();
1679
	__stack.__buf = malloc(__bufsz);
1680
	memset(__stack.__buf, 0, __len);
1681
	memset(src, 'A', __len - 1);
1682
	src[__len - 1] = '\0';
1683

1684
	strncat(__stack.__buf, src, __len);
1685
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1686

1687
monitor:
1688
	while (waitpid(__child, &__status, 0) != __child) {
1689
		ATF_REQUIRE_EQ(EINTR, errno);
1690
	}
1691

1692
	if (!WIFSIGNALED(__status)) {
1693
		switch (WEXITSTATUS(__status)) {
1694
		case EX_SOFTWARE:
1695
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1696
			break;
1697
		case EX_OSERR:
1698
			atf_tc_fail("setrlimit(2) failed");
1699
			break;
1700
		default:
1701
			atf_tc_fail("child exited with status %d",
1702
			    WEXITSTATUS(__status));
1703
		}
1704
	} else {
1705
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1706
	}
1707
#undef BUF
1708

1709
}
1710

1711
ATF_TC(strcpy_before_end);
1712
ATF_TC_HEAD(strcpy_before_end, tc)
1713
{
1714
}
1715
ATF_TC_BODY(strcpy_before_end, tc)
1716
{
1717
#define BUF &__stack.__buf
1718
	struct {
1719
		uint8_t padding_l;
1720
		unsigned char __buf[42];
1721
		uint8_t padding_r;
1722
	} __stack;
1723
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1724
	const size_t __len = 42 - 1;
1725
	const size_t __idx __unused = __len - 1;
1726
	char src[__len];
1727

1728
	memset(__stack.__buf, 0, __len);
1729
	memset(src, 'A', __len - 1);
1730
	src[__len - 1] = '\0';
1731

1732
	strcpy(__stack.__buf, src);
1733
#undef BUF
1734

1735
}
1736

1737
ATF_TC(strcpy_end);
1738
ATF_TC_HEAD(strcpy_end, tc)
1739
{
1740
}
1741
ATF_TC_BODY(strcpy_end, tc)
1742
{
1743
#define BUF &__stack.__buf
1744
	struct {
1745
		uint8_t padding_l;
1746
		unsigned char __buf[42];
1747
		uint8_t padding_r;
1748
	} __stack;
1749
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1750
	const size_t __len = 42;
1751
	const size_t __idx __unused = __len - 1;
1752
	char src[__len];
1753

1754
	memset(__stack.__buf, 0, __len);
1755
	memset(src, 'A', __len - 1);
1756
	src[__len - 1] = '\0';
1757

1758
	strcpy(__stack.__buf, src);
1759
#undef BUF
1760

1761
}
1762

1763
ATF_TC(strcpy_heap_before_end);
1764
ATF_TC_HEAD(strcpy_heap_before_end, tc)
1765
{
1766
}
1767
ATF_TC_BODY(strcpy_heap_before_end, tc)
1768
{
1769
#define BUF __stack.__buf
1770
	struct {
1771
		uint8_t padding_l;
1772
		unsigned char * __buf;
1773
		uint8_t padding_r;
1774
	} __stack;
1775
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1776
	const size_t __len = 42 - 1;
1777
	const size_t __idx __unused = __len - 1;
1778
	char src[__len];
1779

1780
	__stack.__buf = malloc(__bufsz);
1781
	memset(__stack.__buf, 0, __len);
1782
	memset(src, 'A', __len - 1);
1783
	src[__len - 1] = '\0';
1784

1785
	strcpy(__stack.__buf, src);
1786
#undef BUF
1787

1788
}
1789

1790
ATF_TC(strcpy_heap_end);
1791
ATF_TC_HEAD(strcpy_heap_end, tc)
1792
{
1793
}
1794
ATF_TC_BODY(strcpy_heap_end, tc)
1795
{
1796
#define BUF __stack.__buf
1797
	struct {
1798
		uint8_t padding_l;
1799
		unsigned char * __buf;
1800
		uint8_t padding_r;
1801
	} __stack;
1802
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1803
	const size_t __len = 42;
1804
	const size_t __idx __unused = __len - 1;
1805
	char src[__len];
1806

1807
	__stack.__buf = malloc(__bufsz);
1808
	memset(__stack.__buf, 0, __len);
1809
	memset(src, 'A', __len - 1);
1810
	src[__len - 1] = '\0';
1811

1812
	strcpy(__stack.__buf, src);
1813
#undef BUF
1814

1815
}
1816

1817
ATF_TC(strcpy_heap_after_end);
1818
ATF_TC_HEAD(strcpy_heap_after_end, tc)
1819
{
1820
}
1821
ATF_TC_BODY(strcpy_heap_after_end, tc)
1822
{
1823
#define BUF __stack.__buf
1824
	struct {
1825
		uint8_t padding_l;
1826
		unsigned char * __buf;
1827
		uint8_t padding_r;
1828
	} __stack;
1829
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1830
	const size_t __len = 42 + 1;
1831
	const size_t __idx __unused = __len - 1;
1832
	pid_t __child;
1833
	int __status;
1834
	char src[__len];
1835

1836
	__child = fork();
1837
	ATF_REQUIRE(__child >= 0);
1838
	if (__child > 0)
1839
		goto monitor;
1840

1841
	/* Child */
1842
	disable_coredumps();
1843
	__stack.__buf = malloc(__bufsz);
1844
	memset(__stack.__buf, 0, __len);
1845
	memset(src, 'A', __len - 1);
1846
	src[__len - 1] = '\0';
1847

1848
	strcpy(__stack.__buf, src);
1849
	_exit(EX_SOFTWARE);	/* Should have aborted. */
1850

1851
monitor:
1852
	while (waitpid(__child, &__status, 0) != __child) {
1853
		ATF_REQUIRE_EQ(EINTR, errno);
1854
	}
1855

1856
	if (!WIFSIGNALED(__status)) {
1857
		switch (WEXITSTATUS(__status)) {
1858
		case EX_SOFTWARE:
1859
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1860
			break;
1861
		case EX_OSERR:
1862
			atf_tc_fail("setrlimit(2) failed");
1863
			break;
1864
		default:
1865
			atf_tc_fail("child exited with status %d",
1866
			    WEXITSTATUS(__status));
1867
		}
1868
	} else {
1869
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1870
	}
1871
#undef BUF
1872

1873
}
1874

1875
ATF_TC(strlcpy_before_end);
1876
ATF_TC_HEAD(strlcpy_before_end, tc)
1877
{
1878
}
1879
ATF_TC_BODY(strlcpy_before_end, tc)
1880
{
1881
#define BUF &__stack.__buf
1882
	struct {
1883
		uint8_t padding_l;
1884
		unsigned char __buf[42];
1885
		uint8_t padding_r;
1886
	} __stack;
1887
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1888
	const size_t __len = 42 - 1;
1889
	const size_t __idx __unused = __len - 1;
1890
	char src[__len];
1891

1892
	memset(__stack.__buf, 0, __len);
1893
	memset(src, 'A', __len - 1);
1894
	src[__len - 1] = '\0';
1895

1896
	strlcpy(__stack.__buf, src, __len);
1897
#undef BUF
1898

1899
}
1900

1901
ATF_TC(strlcpy_end);
1902
ATF_TC_HEAD(strlcpy_end, tc)
1903
{
1904
}
1905
ATF_TC_BODY(strlcpy_end, tc)
1906
{
1907
#define BUF &__stack.__buf
1908
	struct {
1909
		uint8_t padding_l;
1910
		unsigned char __buf[42];
1911
		uint8_t padding_r;
1912
	} __stack;
1913
	const size_t __bufsz __unused = sizeof(__stack.__buf);
1914
	const size_t __len = 42;
1915
	const size_t __idx __unused = __len - 1;
1916
	char src[__len];
1917

1918
	memset(__stack.__buf, 0, __len);
1919
	memset(src, 'A', __len - 1);
1920
	src[__len - 1] = '\0';
1921

1922
	strlcpy(__stack.__buf, src, __len);
1923
#undef BUF
1924

1925
}
1926

1927
ATF_TC(strlcpy_heap_before_end);
1928
ATF_TC_HEAD(strlcpy_heap_before_end, tc)
1929
{
1930
}
1931
ATF_TC_BODY(strlcpy_heap_before_end, tc)
1932
{
1933
#define BUF __stack.__buf
1934
	struct {
1935
		uint8_t padding_l;
1936
		unsigned char * __buf;
1937
		uint8_t padding_r;
1938
	} __stack;
1939
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1940
	const size_t __len = 42 - 1;
1941
	const size_t __idx __unused = __len - 1;
1942
	char src[__len];
1943

1944
	__stack.__buf = malloc(__bufsz);
1945
	memset(__stack.__buf, 0, __len);
1946
	memset(src, 'A', __len - 1);
1947
	src[__len - 1] = '\0';
1948

1949
	strlcpy(__stack.__buf, src, __len);
1950
#undef BUF
1951

1952
}
1953

1954
ATF_TC(strlcpy_heap_end);
1955
ATF_TC_HEAD(strlcpy_heap_end, tc)
1956
{
1957
}
1958
ATF_TC_BODY(strlcpy_heap_end, tc)
1959
{
1960
#define BUF __stack.__buf
1961
	struct {
1962
		uint8_t padding_l;
1963
		unsigned char * __buf;
1964
		uint8_t padding_r;
1965
	} __stack;
1966
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1967
	const size_t __len = 42;
1968
	const size_t __idx __unused = __len - 1;
1969
	char src[__len];
1970

1971
	__stack.__buf = malloc(__bufsz);
1972
	memset(__stack.__buf, 0, __len);
1973
	memset(src, 'A', __len - 1);
1974
	src[__len - 1] = '\0';
1975

1976
	strlcpy(__stack.__buf, src, __len);
1977
#undef BUF
1978

1979
}
1980

1981
ATF_TC(strlcpy_heap_after_end);
1982
ATF_TC_HEAD(strlcpy_heap_after_end, tc)
1983
{
1984
}
1985
ATF_TC_BODY(strlcpy_heap_after_end, tc)
1986
{
1987
#define BUF __stack.__buf
1988
	struct {
1989
		uint8_t padding_l;
1990
		unsigned char * __buf;
1991
		uint8_t padding_r;
1992
	} __stack;
1993
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1994
	const size_t __len = 42 + 1;
1995
	const size_t __idx __unused = __len - 1;
1996
	pid_t __child;
1997
	int __status;
1998
	char src[__len];
1999

2000
	__child = fork();
2001
	ATF_REQUIRE(__child >= 0);
2002
	if (__child > 0)
2003
		goto monitor;
2004

2005
	/* Child */
2006
	disable_coredumps();
2007
	__stack.__buf = malloc(__bufsz);
2008
	memset(__stack.__buf, 0, __len);
2009
	memset(src, 'A', __len - 1);
2010
	src[__len - 1] = '\0';
2011

2012
	strlcpy(__stack.__buf, src, __len);
2013
	_exit(EX_SOFTWARE);	/* Should have aborted. */
2014

2015
monitor:
2016
	while (waitpid(__child, &__status, 0) != __child) {
2017
		ATF_REQUIRE_EQ(EINTR, errno);
2018
	}
2019

2020
	if (!WIFSIGNALED(__status)) {
2021
		switch (WEXITSTATUS(__status)) {
2022
		case EX_SOFTWARE:
2023
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
2024
			break;
2025
		case EX_OSERR:
2026
			atf_tc_fail("setrlimit(2) failed");
2027
			break;
2028
		default:
2029
			atf_tc_fail("child exited with status %d",
2030
			    WEXITSTATUS(__status));
2031
		}
2032
	} else {
2033
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
2034
	}
2035
#undef BUF
2036

2037
}
2038

2039
ATF_TC(strncpy_before_end);
2040
ATF_TC_HEAD(strncpy_before_end, tc)
2041
{
2042
}
2043
ATF_TC_BODY(strncpy_before_end, tc)
2044
{
2045
#define BUF &__stack.__buf
2046
	struct {
2047
		uint8_t padding_l;
2048
		unsigned char __buf[42];
2049
		uint8_t padding_r;
2050
	} __stack;
2051
	const size_t __bufsz __unused = sizeof(__stack.__buf);
2052
	const size_t __len = 42 - 1;
2053
	const size_t __idx __unused = __len - 1;
2054
	char src[__len];
2055

2056
	memset(__stack.__buf, 0, __len);
2057
	memset(src, 'A', __len - 1);
2058
	src[__len - 1] = '\0';
2059

2060
	strncpy(__stack.__buf, src, __len);
2061
#undef BUF
2062

2063
}
2064

2065
ATF_TC(strncpy_end);
2066
ATF_TC_HEAD(strncpy_end, tc)
2067
{
2068
}
2069
ATF_TC_BODY(strncpy_end, tc)
2070
{
2071
#define BUF &__stack.__buf
2072
	struct {
2073
		uint8_t padding_l;
2074
		unsigned char __buf[42];
2075
		uint8_t padding_r;
2076
	} __stack;
2077
	const size_t __bufsz __unused = sizeof(__stack.__buf);
2078
	const size_t __len = 42;
2079
	const size_t __idx __unused = __len - 1;
2080
	char src[__len];
2081

2082
	memset(__stack.__buf, 0, __len);
2083
	memset(src, 'A', __len - 1);
2084
	src[__len - 1] = '\0';
2085

2086
	strncpy(__stack.__buf, src, __len);
2087
#undef BUF
2088

2089
}
2090

2091
ATF_TC(strncpy_heap_before_end);
2092
ATF_TC_HEAD(strncpy_heap_before_end, tc)
2093
{
2094
}
2095
ATF_TC_BODY(strncpy_heap_before_end, tc)
2096
{
2097
#define BUF __stack.__buf
2098
	struct {
2099
		uint8_t padding_l;
2100
		unsigned char * __buf;
2101
		uint8_t padding_r;
2102
	} __stack;
2103
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2104
	const size_t __len = 42 - 1;
2105
	const size_t __idx __unused = __len - 1;
2106
	char src[__len];
2107

2108
	__stack.__buf = malloc(__bufsz);
2109
	memset(__stack.__buf, 0, __len);
2110
	memset(src, 'A', __len - 1);
2111
	src[__len - 1] = '\0';
2112

2113
	strncpy(__stack.__buf, src, __len);
2114
#undef BUF
2115

2116
}
2117

2118
ATF_TC(strncpy_heap_end);
2119
ATF_TC_HEAD(strncpy_heap_end, tc)
2120
{
2121
}
2122
ATF_TC_BODY(strncpy_heap_end, tc)
2123
{
2124
#define BUF __stack.__buf
2125
	struct {
2126
		uint8_t padding_l;
2127
		unsigned char * __buf;
2128
		uint8_t padding_r;
2129
	} __stack;
2130
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2131
	const size_t __len = 42;
2132
	const size_t __idx __unused = __len - 1;
2133
	char src[__len];
2134

2135
	__stack.__buf = malloc(__bufsz);
2136
	memset(__stack.__buf, 0, __len);
2137
	memset(src, 'A', __len - 1);
2138
	src[__len - 1] = '\0';
2139

2140
	strncpy(__stack.__buf, src, __len);
2141
#undef BUF
2142

2143
}
2144

2145
ATF_TC(strncpy_heap_after_end);
2146
ATF_TC_HEAD(strncpy_heap_after_end, tc)
2147
{
2148
}
2149
ATF_TC_BODY(strncpy_heap_after_end, tc)
2150
{
2151
#define BUF __stack.__buf
2152
	struct {
2153
		uint8_t padding_l;
2154
		unsigned char * __buf;
2155
		uint8_t padding_r;
2156
	} __stack;
2157
	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2158
	const size_t __len = 42 + 1;
2159
	const size_t __idx __unused = __len - 1;
2160
	pid_t __child;
2161
	int __status;
2162
	char src[__len];
2163

2164
	__child = fork();
2165
	ATF_REQUIRE(__child >= 0);
2166
	if (__child > 0)
2167
		goto monitor;
2168

2169
	/* Child */
2170
	disable_coredumps();
2171
	__stack.__buf = malloc(__bufsz);
2172
	memset(__stack.__buf, 0, __len);
2173
	memset(src, 'A', __len - 1);
2174
	src[__len - 1] = '\0';
2175

2176
	strncpy(__stack.__buf, src, __len);
2177
	_exit(EX_SOFTWARE);	/* Should have aborted. */
2178

2179
monitor:
2180
	while (waitpid(__child, &__status, 0) != __child) {
2181
		ATF_REQUIRE_EQ(EINTR, errno);
2182
	}
2183

2184
	if (!WIFSIGNALED(__status)) {
2185
		switch (WEXITSTATUS(__status)) {
2186
		case EX_SOFTWARE:
2187
			atf_tc_fail("FORTIFY_SOURCE failed to abort");
2188
			break;
2189
		case EX_OSERR:
2190
			atf_tc_fail("setrlimit(2) failed");
2191
			break;
2192
		default:
2193
			atf_tc_fail("child exited with status %d",
2194
			    WEXITSTATUS(__status));
2195
		}
2196
	} else {
2197
		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
2198
	}
2199
#undef BUF
2200

2201
}
2202

2203
ATF_TP_ADD_TCS(tp)
2204
{
2205
	ATF_TP_ADD_TC(tp, memcpy_before_end);
2206
	ATF_TP_ADD_TC(tp, memcpy_end);
2207
	ATF_TP_ADD_TC(tp, memcpy_heap_before_end);
2208
	ATF_TP_ADD_TC(tp, memcpy_heap_end);
2209
	ATF_TP_ADD_TC(tp, memcpy_heap_after_end);
2210
	ATF_TP_ADD_TC(tp, mempcpy_before_end);
2211
	ATF_TP_ADD_TC(tp, mempcpy_end);
2212
	ATF_TP_ADD_TC(tp, mempcpy_heap_before_end);
2213
	ATF_TP_ADD_TC(tp, mempcpy_heap_end);
2214
	ATF_TP_ADD_TC(tp, mempcpy_heap_after_end);
2215
	ATF_TP_ADD_TC(tp, memmove_before_end);
2216
	ATF_TP_ADD_TC(tp, memmove_end);
2217
	ATF_TP_ADD_TC(tp, memmove_heap_before_end);
2218
	ATF_TP_ADD_TC(tp, memmove_heap_end);
2219
	ATF_TP_ADD_TC(tp, memmove_heap_after_end);
2220
	ATF_TP_ADD_TC(tp, memset_before_end);
2221
	ATF_TP_ADD_TC(tp, memset_end);
2222
	ATF_TP_ADD_TC(tp, memset_heap_before_end);
2223
	ATF_TP_ADD_TC(tp, memset_heap_end);
2224
	ATF_TP_ADD_TC(tp, memset_heap_after_end);
2225
	ATF_TP_ADD_TC(tp, memset_explicit_before_end);
2226
	ATF_TP_ADD_TC(tp, memset_explicit_end);
2227
	ATF_TP_ADD_TC(tp, memset_explicit_heap_before_end);
2228
	ATF_TP_ADD_TC(tp, memset_explicit_heap_end);
2229
	ATF_TP_ADD_TC(tp, memset_explicit_heap_after_end);
2230
	ATF_TP_ADD_TC(tp, stpcpy_before_end);
2231
	ATF_TP_ADD_TC(tp, stpcpy_end);
2232
	ATF_TP_ADD_TC(tp, stpcpy_heap_before_end);
2233
	ATF_TP_ADD_TC(tp, stpcpy_heap_end);
2234
	ATF_TP_ADD_TC(tp, stpcpy_heap_after_end);
2235
	ATF_TP_ADD_TC(tp, stpncpy_before_end);
2236
	ATF_TP_ADD_TC(tp, stpncpy_end);
2237
	ATF_TP_ADD_TC(tp, stpncpy_heap_before_end);
2238
	ATF_TP_ADD_TC(tp, stpncpy_heap_end);
2239
	ATF_TP_ADD_TC(tp, stpncpy_heap_after_end);
2240
	ATF_TP_ADD_TC(tp, strcat_before_end);
2241
	ATF_TP_ADD_TC(tp, strcat_end);
2242
	ATF_TP_ADD_TC(tp, strcat_heap_before_end);
2243
	ATF_TP_ADD_TC(tp, strcat_heap_end);
2244
	ATF_TP_ADD_TC(tp, strcat_heap_after_end);
2245
	ATF_TP_ADD_TC(tp, strlcat_before_end);
2246
	ATF_TP_ADD_TC(tp, strlcat_end);
2247
	ATF_TP_ADD_TC(tp, strlcat_heap_before_end);
2248
	ATF_TP_ADD_TC(tp, strlcat_heap_end);
2249
	ATF_TP_ADD_TC(tp, strlcat_heap_after_end);
2250
	ATF_TP_ADD_TC(tp, strncat_before_end);
2251
	ATF_TP_ADD_TC(tp, strncat_end);
2252
	ATF_TP_ADD_TC(tp, strncat_heap_before_end);
2253
	ATF_TP_ADD_TC(tp, strncat_heap_end);
2254
	ATF_TP_ADD_TC(tp, strncat_heap_after_end);
2255
	ATF_TP_ADD_TC(tp, strcpy_before_end);
2256
	ATF_TP_ADD_TC(tp, strcpy_end);
2257
	ATF_TP_ADD_TC(tp, strcpy_heap_before_end);
2258
	ATF_TP_ADD_TC(tp, strcpy_heap_end);
2259
	ATF_TP_ADD_TC(tp, strcpy_heap_after_end);
2260
	ATF_TP_ADD_TC(tp, strlcpy_before_end);
2261
	ATF_TP_ADD_TC(tp, strlcpy_end);
2262
	ATF_TP_ADD_TC(tp, strlcpy_heap_before_end);
2263
	ATF_TP_ADD_TC(tp, strlcpy_heap_end);
2264
	ATF_TP_ADD_TC(tp, strlcpy_heap_after_end);
2265
	ATF_TP_ADD_TC(tp, strncpy_before_end);
2266
	ATF_TP_ADD_TC(tp, strncpy_end);
2267
	ATF_TP_ADD_TC(tp, strncpy_heap_before_end);
2268
	ATF_TP_ADD_TC(tp, strncpy_heap_end);
2269
	ATF_TP_ADD_TC(tp, strncpy_heap_after_end);
2270
	return (atf_no_error());
2271
}
2272

2273
Product

Resources

Company
