xref: /freebsd/lib/libc/tests/secure/fortify_wchar_test.c (revision 1f155d48f878495d31592c59cab82f975c210ad8)
1 /* @generated by `generate-fortify-tests.lua "wchar"` */
2 
3 #define	_FORTIFY_SOURCE	2
4 #define	TMPFILE_SIZE	(1024 * 32)
5 
6 #include <sys/param.h>
7 #include <sys/random.h>
8 #include <sys/resource.h>
9 #include <sys/select.h>
10 #include <sys/socket.h>
11 #include <sys/time.h>
12 #include <sys/uio.h>
13 #include <sys/wait.h>
14 #include <dirent.h>
15 #include <errno.h>
16 #include <fcntl.h>
17 #include <limits.h>
18 #include <poll.h>
19 #include <signal.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <strings.h>
24 #include <sysexits.h>
25 #include <unistd.h>
26 #include <wchar.h>
27 #include <atf-c.h>
28 
29 static FILE * __unused
new_fp(size_t __len)30 new_fp(size_t __len)
31 {
32 	static char fpbuf[LINE_MAX];
33 	FILE *fp;
34 
35 	ATF_REQUIRE(__len <= sizeof(fpbuf));
36 
37 	memset(fpbuf, 'A', sizeof(fpbuf) - 1);
38 	fpbuf[sizeof(fpbuf) - 1] = '\0';
39 
40 	fp = fmemopen(fpbuf, sizeof(fpbuf), "rb");
41 	ATF_REQUIRE(fp != NULL);
42 
43 	return (fp);
44 }
45 
46 /*
47  * Create a new symlink to use for readlink(2) style tests, we'll just use a
48  * random target name to have something interesting to look at.
49  */
50 static const char * __unused
new_symlink(size_t __len)51 new_symlink(size_t __len)
52 {
53 	static const char linkname[] = "link";
54 	char target[MAXNAMLEN];
55 	int error;
56 
57 	ATF_REQUIRE(__len <= sizeof(target));
58 
59 	arc4random_buf(target, sizeof(target));
60 
61 	error = unlink(linkname);
62 	ATF_REQUIRE(error == 0 || errno == ENOENT);
63 
64 	error = symlink(target, linkname);
65 	ATF_REQUIRE(error == 0);
66 
67 	return (linkname);
68 }
69 
70 /*
71  * For our purposes, first descriptor will be the reader; we'll send both
72  * raw data and a control message over it so that the result can be used for
73  * any of our recv*() tests.
74  */
75 static void __unused
new_socket(int sock[2])76 new_socket(int sock[2])
77 {
78 	unsigned char ctrl[CMSG_SPACE(sizeof(int))] = { 0 };
79 	static char sockbuf[256];
80 	ssize_t rv;
81 	size_t total = 0;
82 	struct msghdr hdr = { 0 };
83 	struct cmsghdr *cmsg;
84 	int error, fd;
85 
86 	error = socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
87 	ATF_REQUIRE(error == 0);
88 
89 	while (total != sizeof(sockbuf)) {
90 		rv = send(sock[1], &sockbuf[total], sizeof(sockbuf) - total, 0);
91 
92 		ATF_REQUIRE_MSG(rv > 0,
93 		    "expected bytes sent, got %zd with %zu left (size %zu, total %zu)",
94 		    rv, sizeof(sockbuf) - total, sizeof(sockbuf), total);
95 		ATF_REQUIRE_MSG(total + (size_t)rv <= sizeof(sockbuf),
96 		    "%zd exceeds total %zu", rv, sizeof(sockbuf));
97 		total += rv;
98 	}
99 
100 	hdr.msg_control = ctrl;
101 	hdr.msg_controllen = sizeof(ctrl);
102 
103 	cmsg = CMSG_FIRSTHDR(&hdr);
104 	cmsg->cmsg_level = SOL_SOCKET;
105 	cmsg->cmsg_type = SCM_RIGHTS;
106 	cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
107 	fd = STDIN_FILENO;
108 	memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
109 
110 	error = sendmsg(sock[1], &hdr, 0);
111 	ATF_REQUIRE(error != -1);
112 }
113 
114 /*
115  * Constructs a tmpfile that we can use for testing read(2) and friends.
116  */
117 static int __unused
new_tmpfile(void)118 new_tmpfile(void)
119 {
120 	char buf[1024];
121 	ssize_t rv;
122 	size_t written;
123 	int fd;
124 
125 	fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644);
126 	ATF_REQUIRE(fd >= 0);
127 
128 	written = 0;
129 	while (written < TMPFILE_SIZE) {
130 		rv = write(fd, buf, sizeof(buf));
131 		ATF_REQUIRE(rv > 0);
132 
133 		written += rv;
134 	}
135 
136 	ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET));
137 	return (fd);
138 }
139 
140 static void
disable_coredumps(void)141 disable_coredumps(void)
142 {
143 	struct rlimit rl = { 0 };
144 
145 	if (setrlimit(RLIMIT_CORE, &rl) == -1)
146 		_exit(EX_OSERR);
147 }
148 
149 /*
150  * Replaces stdin with a file that we can actually read from, for tests where
151  * we want a FILE * or fd that we can get data from.
152  */
153 static void __unused
replace_stdin(void)154 replace_stdin(void)
155 {
156 	int fd;
157 
158 	fd = new_tmpfile();
159 
160 	(void)dup2(fd, STDIN_FILENO);
161 	if (fd != STDIN_FILENO)
162 		close(fd);
163 }
164 
165 ATF_TC_WITHOUT_HEAD(wmemcpy_before_end);
ATF_TC_BODY(wmemcpy_before_end,tc)166 ATF_TC_BODY(wmemcpy_before_end, tc)
167 {
168 #define BUF &__stack.__buf
169 	struct {
170 		uint8_t padding_l;
171 		wchar_t __buf[42];
172 		uint8_t padding_r;
173 	} __stack;
174 	const size_t __bufsz __unused = sizeof(__stack.__buf);
175 	const size_t __len = 42 - 1;
176 	const size_t __idx __unused = __len - 1;
177 	wchar_t src[__len + 10];
178 
179 	wmemcpy(__stack.__buf, src, __len);
180 #undef BUF
181 
182 }
183 
184 ATF_TC_WITHOUT_HEAD(wmemcpy_end);
ATF_TC_BODY(wmemcpy_end,tc)185 ATF_TC_BODY(wmemcpy_end, tc)
186 {
187 #define BUF &__stack.__buf
188 	struct {
189 		uint8_t padding_l;
190 		wchar_t __buf[42];
191 		uint8_t padding_r;
192 	} __stack;
193 	const size_t __bufsz __unused = sizeof(__stack.__buf);
194 	const size_t __len = 42;
195 	const size_t __idx __unused = __len - 1;
196 	wchar_t src[__len + 10];
197 
198 	wmemcpy(__stack.__buf, src, __len);
199 #undef BUF
200 
201 }
202 
203 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_before_end);
ATF_TC_BODY(wmemcpy_heap_before_end,tc)204 ATF_TC_BODY(wmemcpy_heap_before_end, tc)
205 {
206 #define BUF __stack.__buf
207 	struct {
208 		uint8_t padding_l;
209 		wchar_t * __buf;
210 		uint8_t padding_r;
211 	} __stack;
212 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
213 	const size_t __len = 42 - 1;
214 	const size_t __idx __unused = __len - 1;
215 	wchar_t src[__len + 10];
216 
217 	__stack.__buf = malloc(__bufsz);
218 
219 	wmemcpy(__stack.__buf, src, __len);
220 #undef BUF
221 
222 }
223 
224 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_end);
ATF_TC_BODY(wmemcpy_heap_end,tc)225 ATF_TC_BODY(wmemcpy_heap_end, tc)
226 {
227 #define BUF __stack.__buf
228 	struct {
229 		uint8_t padding_l;
230 		wchar_t * __buf;
231 		uint8_t padding_r;
232 	} __stack;
233 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
234 	const size_t __len = 42;
235 	const size_t __idx __unused = __len - 1;
236 	wchar_t src[__len + 10];
237 
238 	__stack.__buf = malloc(__bufsz);
239 
240 	wmemcpy(__stack.__buf, src, __len);
241 #undef BUF
242 
243 }
244 
245 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_after_end);
ATF_TC_BODY(wmemcpy_heap_after_end,tc)246 ATF_TC_BODY(wmemcpy_heap_after_end, tc)
247 {
248 #define BUF __stack.__buf
249 	struct {
250 		uint8_t padding_l;
251 		wchar_t * __buf;
252 		uint8_t padding_r;
253 	} __stack;
254 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
255 	const size_t __len = 42 + 1;
256 	const size_t __idx __unused = __len - 1;
257 	pid_t __child;
258 	int __status;
259 	wchar_t src[__len + 10];
260 
261 	__child = fork();
262 	ATF_REQUIRE(__child >= 0);
263 	if (__child > 0)
264 		goto monitor;
265 
266 	/* Child */
267 	disable_coredumps();
268 	__stack.__buf = malloc(__bufsz);
269 
270 	wmemcpy(__stack.__buf, src, __len);
271 	_exit(EX_SOFTWARE);	/* Should have aborted. */
272 
273 monitor:
274 	while (waitpid(__child, &__status, 0) != __child) {
275 		ATF_REQUIRE_EQ(EINTR, errno);
276 	}
277 
278 	if (!WIFSIGNALED(__status)) {
279 		switch (WEXITSTATUS(__status)) {
280 		case EX_SOFTWARE:
281 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
282 			break;
283 		case EX_OSERR:
284 			atf_tc_fail("setrlimit(2) failed");
285 			break;
286 		default:
287 			atf_tc_fail("child exited with status %d",
288 			    WEXITSTATUS(__status));
289 		}
290 	} else {
291 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
292 	}
293 #undef BUF
294 
295 }
296 
297 ATF_TC_WITHOUT_HEAD(wmempcpy_before_end);
ATF_TC_BODY(wmempcpy_before_end,tc)298 ATF_TC_BODY(wmempcpy_before_end, tc)
299 {
300 #define BUF &__stack.__buf
301 	struct {
302 		uint8_t padding_l;
303 		wchar_t __buf[42];
304 		uint8_t padding_r;
305 	} __stack;
306 	const size_t __bufsz __unused = sizeof(__stack.__buf);
307 	const size_t __len = 42 - 1;
308 	const size_t __idx __unused = __len - 1;
309 	wchar_t src[__len + 10];
310 
311 	wmempcpy(__stack.__buf, src, __len);
312 #undef BUF
313 
314 }
315 
316 ATF_TC_WITHOUT_HEAD(wmempcpy_end);
ATF_TC_BODY(wmempcpy_end,tc)317 ATF_TC_BODY(wmempcpy_end, tc)
318 {
319 #define BUF &__stack.__buf
320 	struct {
321 		uint8_t padding_l;
322 		wchar_t __buf[42];
323 		uint8_t padding_r;
324 	} __stack;
325 	const size_t __bufsz __unused = sizeof(__stack.__buf);
326 	const size_t __len = 42;
327 	const size_t __idx __unused = __len - 1;
328 	wchar_t src[__len + 10];
329 
330 	wmempcpy(__stack.__buf, src, __len);
331 #undef BUF
332 
333 }
334 
335 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_before_end);
ATF_TC_BODY(wmempcpy_heap_before_end,tc)336 ATF_TC_BODY(wmempcpy_heap_before_end, tc)
337 {
338 #define BUF __stack.__buf
339 	struct {
340 		uint8_t padding_l;
341 		wchar_t * __buf;
342 		uint8_t padding_r;
343 	} __stack;
344 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
345 	const size_t __len = 42 - 1;
346 	const size_t __idx __unused = __len - 1;
347 	wchar_t src[__len + 10];
348 
349 	__stack.__buf = malloc(__bufsz);
350 
351 	wmempcpy(__stack.__buf, src, __len);
352 #undef BUF
353 
354 }
355 
356 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_end);
ATF_TC_BODY(wmempcpy_heap_end,tc)357 ATF_TC_BODY(wmempcpy_heap_end, tc)
358 {
359 #define BUF __stack.__buf
360 	struct {
361 		uint8_t padding_l;
362 		wchar_t * __buf;
363 		uint8_t padding_r;
364 	} __stack;
365 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
366 	const size_t __len = 42;
367 	const size_t __idx __unused = __len - 1;
368 	wchar_t src[__len + 10];
369 
370 	__stack.__buf = malloc(__bufsz);
371 
372 	wmempcpy(__stack.__buf, src, __len);
373 #undef BUF
374 
375 }
376 
377 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_after_end);
ATF_TC_BODY(wmempcpy_heap_after_end,tc)378 ATF_TC_BODY(wmempcpy_heap_after_end, tc)
379 {
380 #define BUF __stack.__buf
381 	struct {
382 		uint8_t padding_l;
383 		wchar_t * __buf;
384 		uint8_t padding_r;
385 	} __stack;
386 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
387 	const size_t __len = 42 + 1;
388 	const size_t __idx __unused = __len - 1;
389 	pid_t __child;
390 	int __status;
391 	wchar_t src[__len + 10];
392 
393 	__child = fork();
394 	ATF_REQUIRE(__child >= 0);
395 	if (__child > 0)
396 		goto monitor;
397 
398 	/* Child */
399 	disable_coredumps();
400 	__stack.__buf = malloc(__bufsz);
401 
402 	wmempcpy(__stack.__buf, src, __len);
403 	_exit(EX_SOFTWARE);	/* Should have aborted. */
404 
405 monitor:
406 	while (waitpid(__child, &__status, 0) != __child) {
407 		ATF_REQUIRE_EQ(EINTR, errno);
408 	}
409 
410 	if (!WIFSIGNALED(__status)) {
411 		switch (WEXITSTATUS(__status)) {
412 		case EX_SOFTWARE:
413 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
414 			break;
415 		case EX_OSERR:
416 			atf_tc_fail("setrlimit(2) failed");
417 			break;
418 		default:
419 			atf_tc_fail("child exited with status %d",
420 			    WEXITSTATUS(__status));
421 		}
422 	} else {
423 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
424 	}
425 #undef BUF
426 
427 }
428 
429 ATF_TC_WITHOUT_HEAD(wmemmove_before_end);
ATF_TC_BODY(wmemmove_before_end,tc)430 ATF_TC_BODY(wmemmove_before_end, tc)
431 {
432 #define BUF &__stack.__buf
433 	struct {
434 		uint8_t padding_l;
435 		wchar_t __buf[42];
436 		uint8_t padding_r;
437 	} __stack;
438 	const size_t __bufsz __unused = sizeof(__stack.__buf);
439 	const size_t __len = 42 - 1;
440 	const size_t __idx __unused = __len - 1;
441 	wchar_t src[__len + 10];
442 
443 	wmemmove(__stack.__buf, src, __len);
444 #undef BUF
445 
446 }
447 
448 ATF_TC_WITHOUT_HEAD(wmemmove_end);
ATF_TC_BODY(wmemmove_end,tc)449 ATF_TC_BODY(wmemmove_end, tc)
450 {
451 #define BUF &__stack.__buf
452 	struct {
453 		uint8_t padding_l;
454 		wchar_t __buf[42];
455 		uint8_t padding_r;
456 	} __stack;
457 	const size_t __bufsz __unused = sizeof(__stack.__buf);
458 	const size_t __len = 42;
459 	const size_t __idx __unused = __len - 1;
460 	wchar_t src[__len + 10];
461 
462 	wmemmove(__stack.__buf, src, __len);
463 #undef BUF
464 
465 }
466 
467 ATF_TC_WITHOUT_HEAD(wmemmove_heap_before_end);
ATF_TC_BODY(wmemmove_heap_before_end,tc)468 ATF_TC_BODY(wmemmove_heap_before_end, tc)
469 {
470 #define BUF __stack.__buf
471 	struct {
472 		uint8_t padding_l;
473 		wchar_t * __buf;
474 		uint8_t padding_r;
475 	} __stack;
476 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
477 	const size_t __len = 42 - 1;
478 	const size_t __idx __unused = __len - 1;
479 	wchar_t src[__len + 10];
480 
481 	__stack.__buf = malloc(__bufsz);
482 
483 	wmemmove(__stack.__buf, src, __len);
484 #undef BUF
485 
486 }
487 
488 ATF_TC_WITHOUT_HEAD(wmemmove_heap_end);
ATF_TC_BODY(wmemmove_heap_end,tc)489 ATF_TC_BODY(wmemmove_heap_end, tc)
490 {
491 #define BUF __stack.__buf
492 	struct {
493 		uint8_t padding_l;
494 		wchar_t * __buf;
495 		uint8_t padding_r;
496 	} __stack;
497 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
498 	const size_t __len = 42;
499 	const size_t __idx __unused = __len - 1;
500 	wchar_t src[__len + 10];
501 
502 	__stack.__buf = malloc(__bufsz);
503 
504 	wmemmove(__stack.__buf, src, __len);
505 #undef BUF
506 
507 }
508 
509 ATF_TC_WITHOUT_HEAD(wmemmove_heap_after_end);
ATF_TC_BODY(wmemmove_heap_after_end,tc)510 ATF_TC_BODY(wmemmove_heap_after_end, tc)
511 {
512 #define BUF __stack.__buf
513 	struct {
514 		uint8_t padding_l;
515 		wchar_t * __buf;
516 		uint8_t padding_r;
517 	} __stack;
518 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
519 	const size_t __len = 42 + 1;
520 	const size_t __idx __unused = __len - 1;
521 	pid_t __child;
522 	int __status;
523 	wchar_t src[__len + 10];
524 
525 	__child = fork();
526 	ATF_REQUIRE(__child >= 0);
527 	if (__child > 0)
528 		goto monitor;
529 
530 	/* Child */
531 	disable_coredumps();
532 	__stack.__buf = malloc(__bufsz);
533 
534 	wmemmove(__stack.__buf, src, __len);
535 	_exit(EX_SOFTWARE);	/* Should have aborted. */
536 
537 monitor:
538 	while (waitpid(__child, &__status, 0) != __child) {
539 		ATF_REQUIRE_EQ(EINTR, errno);
540 	}
541 
542 	if (!WIFSIGNALED(__status)) {
543 		switch (WEXITSTATUS(__status)) {
544 		case EX_SOFTWARE:
545 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
546 			break;
547 		case EX_OSERR:
548 			atf_tc_fail("setrlimit(2) failed");
549 			break;
550 		default:
551 			atf_tc_fail("child exited with status %d",
552 			    WEXITSTATUS(__status));
553 		}
554 	} else {
555 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
556 	}
557 #undef BUF
558 
559 }
560 
561 ATF_TC_WITHOUT_HEAD(wmemset_before_end);
ATF_TC_BODY(wmemset_before_end,tc)562 ATF_TC_BODY(wmemset_before_end, tc)
563 {
564 #define BUF &__stack.__buf
565 	struct {
566 		uint8_t padding_l;
567 		wchar_t __buf[42];
568 		uint8_t padding_r;
569 	} __stack;
570 	const size_t __bufsz __unused = sizeof(__stack.__buf);
571 	const size_t __len = 42 - 1;
572 	const size_t __idx __unused = __len - 1;
573 
574 	wmemset(__stack.__buf, L'0', __len);
575 #undef BUF
576 
577 }
578 
579 ATF_TC_WITHOUT_HEAD(wmemset_end);
ATF_TC_BODY(wmemset_end,tc)580 ATF_TC_BODY(wmemset_end, tc)
581 {
582 #define BUF &__stack.__buf
583 	struct {
584 		uint8_t padding_l;
585 		wchar_t __buf[42];
586 		uint8_t padding_r;
587 	} __stack;
588 	const size_t __bufsz __unused = sizeof(__stack.__buf);
589 	const size_t __len = 42;
590 	const size_t __idx __unused = __len - 1;
591 
592 	wmemset(__stack.__buf, L'0', __len);
593 #undef BUF
594 
595 }
596 
597 ATF_TC_WITHOUT_HEAD(wmemset_heap_before_end);
ATF_TC_BODY(wmemset_heap_before_end,tc)598 ATF_TC_BODY(wmemset_heap_before_end, tc)
599 {
600 #define BUF __stack.__buf
601 	struct {
602 		uint8_t padding_l;
603 		wchar_t * __buf;
604 		uint8_t padding_r;
605 	} __stack;
606 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
607 	const size_t __len = 42 - 1;
608 	const size_t __idx __unused = __len - 1;
609 
610 	__stack.__buf = malloc(__bufsz);
611 
612 	wmemset(__stack.__buf, L'0', __len);
613 #undef BUF
614 
615 }
616 
617 ATF_TC_WITHOUT_HEAD(wmemset_heap_end);
ATF_TC_BODY(wmemset_heap_end,tc)618 ATF_TC_BODY(wmemset_heap_end, tc)
619 {
620 #define BUF __stack.__buf
621 	struct {
622 		uint8_t padding_l;
623 		wchar_t * __buf;
624 		uint8_t padding_r;
625 	} __stack;
626 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
627 	const size_t __len = 42;
628 	const size_t __idx __unused = __len - 1;
629 
630 	__stack.__buf = malloc(__bufsz);
631 
632 	wmemset(__stack.__buf, L'0', __len);
633 #undef BUF
634 
635 }
636 
637 ATF_TC_WITHOUT_HEAD(wmemset_heap_after_end);
ATF_TC_BODY(wmemset_heap_after_end,tc)638 ATF_TC_BODY(wmemset_heap_after_end, tc)
639 {
640 #define BUF __stack.__buf
641 	struct {
642 		uint8_t padding_l;
643 		wchar_t * __buf;
644 		uint8_t padding_r;
645 	} __stack;
646 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
647 	const size_t __len = 42 + 1;
648 	const size_t __idx __unused = __len - 1;
649 	pid_t __child;
650 	int __status;
651 
652 	__child = fork();
653 	ATF_REQUIRE(__child >= 0);
654 	if (__child > 0)
655 		goto monitor;
656 
657 	/* Child */
658 	disable_coredumps();
659 	__stack.__buf = malloc(__bufsz);
660 
661 	wmemset(__stack.__buf, L'0', __len);
662 	_exit(EX_SOFTWARE);	/* Should have aborted. */
663 
664 monitor:
665 	while (waitpid(__child, &__status, 0) != __child) {
666 		ATF_REQUIRE_EQ(EINTR, errno);
667 	}
668 
669 	if (!WIFSIGNALED(__status)) {
670 		switch (WEXITSTATUS(__status)) {
671 		case EX_SOFTWARE:
672 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
673 			break;
674 		case EX_OSERR:
675 			atf_tc_fail("setrlimit(2) failed");
676 			break;
677 		default:
678 			atf_tc_fail("child exited with status %d",
679 			    WEXITSTATUS(__status));
680 		}
681 	} else {
682 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
683 	}
684 #undef BUF
685 
686 }
687 
688 ATF_TC_WITHOUT_HEAD(wcpcpy_before_end);
ATF_TC_BODY(wcpcpy_before_end,tc)689 ATF_TC_BODY(wcpcpy_before_end, tc)
690 {
691 #define BUF &__stack.__buf
692 	struct {
693 		uint8_t padding_l;
694 		wchar_t __buf[42];
695 		uint8_t padding_r;
696 	} __stack;
697 	const size_t __bufsz __unused = sizeof(__stack.__buf);
698 	const size_t __len = 42 - 1;
699 	const size_t __idx __unused = __len - 1;
700 	wchar_t src[__len];
701 
702 	wmemset(__stack.__buf, 0, __len);
703 	wmemset(src, 'A', __len - 1);
704 	src[__len - 1] = '\0';
705 
706 	wcpcpy(__stack.__buf, src);
707 #undef BUF
708 
709 }
710 
711 ATF_TC_WITHOUT_HEAD(wcpcpy_end);
ATF_TC_BODY(wcpcpy_end,tc)712 ATF_TC_BODY(wcpcpy_end, tc)
713 {
714 #define BUF &__stack.__buf
715 	struct {
716 		uint8_t padding_l;
717 		wchar_t __buf[42];
718 		uint8_t padding_r;
719 	} __stack;
720 	const size_t __bufsz __unused = sizeof(__stack.__buf);
721 	const size_t __len = 42;
722 	const size_t __idx __unused = __len - 1;
723 	wchar_t src[__len];
724 
725 	wmemset(__stack.__buf, 0, __len);
726 	wmemset(src, 'A', __len - 1);
727 	src[__len - 1] = '\0';
728 
729 	wcpcpy(__stack.__buf, src);
730 #undef BUF
731 
732 }
733 
734 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_before_end);
ATF_TC_BODY(wcpcpy_heap_before_end,tc)735 ATF_TC_BODY(wcpcpy_heap_before_end, tc)
736 {
737 #define BUF __stack.__buf
738 	struct {
739 		uint8_t padding_l;
740 		wchar_t * __buf;
741 		uint8_t padding_r;
742 	} __stack;
743 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
744 	const size_t __len = 42 - 1;
745 	const size_t __idx __unused = __len - 1;
746 	wchar_t src[__len];
747 
748 	__stack.__buf = malloc(__bufsz);
749 	wmemset(__stack.__buf, 0, __len);
750 	wmemset(src, 'A', __len - 1);
751 	src[__len - 1] = '\0';
752 
753 	wcpcpy(__stack.__buf, src);
754 #undef BUF
755 
756 }
757 
758 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_end);
ATF_TC_BODY(wcpcpy_heap_end,tc)759 ATF_TC_BODY(wcpcpy_heap_end, tc)
760 {
761 #define BUF __stack.__buf
762 	struct {
763 		uint8_t padding_l;
764 		wchar_t * __buf;
765 		uint8_t padding_r;
766 	} __stack;
767 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
768 	const size_t __len = 42;
769 	const size_t __idx __unused = __len - 1;
770 	wchar_t src[__len];
771 
772 	__stack.__buf = malloc(__bufsz);
773 	wmemset(__stack.__buf, 0, __len);
774 	wmemset(src, 'A', __len - 1);
775 	src[__len - 1] = '\0';
776 
777 	wcpcpy(__stack.__buf, src);
778 #undef BUF
779 
780 }
781 
782 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_after_end);
ATF_TC_BODY(wcpcpy_heap_after_end,tc)783 ATF_TC_BODY(wcpcpy_heap_after_end, tc)
784 {
785 #define BUF __stack.__buf
786 	struct {
787 		uint8_t padding_l;
788 		wchar_t * __buf;
789 		uint8_t padding_r;
790 	} __stack;
791 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
792 	const size_t __len = 42 + 1;
793 	const size_t __idx __unused = __len - 1;
794 	pid_t __child;
795 	int __status;
796 	wchar_t src[__len];
797 
798 	__child = fork();
799 	ATF_REQUIRE(__child >= 0);
800 	if (__child > 0)
801 		goto monitor;
802 
803 	/* Child */
804 	disable_coredumps();
805 	__stack.__buf = malloc(__bufsz);
806 	wmemset(__stack.__buf, 0, __len);
807 	wmemset(src, 'A', __len - 1);
808 	src[__len - 1] = '\0';
809 
810 	wcpcpy(__stack.__buf, src);
811 	_exit(EX_SOFTWARE);	/* Should have aborted. */
812 
813 monitor:
814 	while (waitpid(__child, &__status, 0) != __child) {
815 		ATF_REQUIRE_EQ(EINTR, errno);
816 	}
817 
818 	if (!WIFSIGNALED(__status)) {
819 		switch (WEXITSTATUS(__status)) {
820 		case EX_SOFTWARE:
821 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
822 			break;
823 		case EX_OSERR:
824 			atf_tc_fail("setrlimit(2) failed");
825 			break;
826 		default:
827 			atf_tc_fail("child exited with status %d",
828 			    WEXITSTATUS(__status));
829 		}
830 	} else {
831 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
832 	}
833 #undef BUF
834 
835 }
836 
837 ATF_TC_WITHOUT_HEAD(wcpncpy_before_end);
ATF_TC_BODY(wcpncpy_before_end,tc)838 ATF_TC_BODY(wcpncpy_before_end, tc)
839 {
840 #define BUF &__stack.__buf
841 	struct {
842 		uint8_t padding_l;
843 		wchar_t __buf[42];
844 		uint8_t padding_r;
845 	} __stack;
846 	const size_t __bufsz __unused = sizeof(__stack.__buf);
847 	const size_t __len = 42 - 1;
848 	const size_t __idx __unused = __len - 1;
849 	wchar_t src[__len];
850 
851 	wmemset(__stack.__buf, 0, __len);
852 	wmemset(src, 'A', __len - 1);
853 	src[__len - 1] = '\0';
854 
855 	wcpncpy(__stack.__buf, src, __len);
856 #undef BUF
857 
858 }
859 
860 ATF_TC_WITHOUT_HEAD(wcpncpy_end);
ATF_TC_BODY(wcpncpy_end,tc)861 ATF_TC_BODY(wcpncpy_end, tc)
862 {
863 #define BUF &__stack.__buf
864 	struct {
865 		uint8_t padding_l;
866 		wchar_t __buf[42];
867 		uint8_t padding_r;
868 	} __stack;
869 	const size_t __bufsz __unused = sizeof(__stack.__buf);
870 	const size_t __len = 42;
871 	const size_t __idx __unused = __len - 1;
872 	wchar_t src[__len];
873 
874 	wmemset(__stack.__buf, 0, __len);
875 	wmemset(src, 'A', __len - 1);
876 	src[__len - 1] = '\0';
877 
878 	wcpncpy(__stack.__buf, src, __len);
879 #undef BUF
880 
881 }
882 
883 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_before_end);
ATF_TC_BODY(wcpncpy_heap_before_end,tc)884 ATF_TC_BODY(wcpncpy_heap_before_end, tc)
885 {
886 #define BUF __stack.__buf
887 	struct {
888 		uint8_t padding_l;
889 		wchar_t * __buf;
890 		uint8_t padding_r;
891 	} __stack;
892 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
893 	const size_t __len = 42 - 1;
894 	const size_t __idx __unused = __len - 1;
895 	wchar_t src[__len];
896 
897 	__stack.__buf = malloc(__bufsz);
898 	wmemset(__stack.__buf, 0, __len);
899 	wmemset(src, 'A', __len - 1);
900 	src[__len - 1] = '\0';
901 
902 	wcpncpy(__stack.__buf, src, __len);
903 #undef BUF
904 
905 }
906 
907 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_end);
ATF_TC_BODY(wcpncpy_heap_end,tc)908 ATF_TC_BODY(wcpncpy_heap_end, tc)
909 {
910 #define BUF __stack.__buf
911 	struct {
912 		uint8_t padding_l;
913 		wchar_t * __buf;
914 		uint8_t padding_r;
915 	} __stack;
916 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
917 	const size_t __len = 42;
918 	const size_t __idx __unused = __len - 1;
919 	wchar_t src[__len];
920 
921 	__stack.__buf = malloc(__bufsz);
922 	wmemset(__stack.__buf, 0, __len);
923 	wmemset(src, 'A', __len - 1);
924 	src[__len - 1] = '\0';
925 
926 	wcpncpy(__stack.__buf, src, __len);
927 #undef BUF
928 
929 }
930 
931 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_after_end);
ATF_TC_BODY(wcpncpy_heap_after_end,tc)932 ATF_TC_BODY(wcpncpy_heap_after_end, tc)
933 {
934 #define BUF __stack.__buf
935 	struct {
936 		uint8_t padding_l;
937 		wchar_t * __buf;
938 		uint8_t padding_r;
939 	} __stack;
940 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
941 	const size_t __len = 42 + 1;
942 	const size_t __idx __unused = __len - 1;
943 	pid_t __child;
944 	int __status;
945 	wchar_t src[__len];
946 
947 	__child = fork();
948 	ATF_REQUIRE(__child >= 0);
949 	if (__child > 0)
950 		goto monitor;
951 
952 	/* Child */
953 	disable_coredumps();
954 	__stack.__buf = malloc(__bufsz);
955 	wmemset(__stack.__buf, 0, __len);
956 	wmemset(src, 'A', __len - 1);
957 	src[__len - 1] = '\0';
958 
959 	wcpncpy(__stack.__buf, src, __len);
960 	_exit(EX_SOFTWARE);	/* Should have aborted. */
961 
962 monitor:
963 	while (waitpid(__child, &__status, 0) != __child) {
964 		ATF_REQUIRE_EQ(EINTR, errno);
965 	}
966 
967 	if (!WIFSIGNALED(__status)) {
968 		switch (WEXITSTATUS(__status)) {
969 		case EX_SOFTWARE:
970 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
971 			break;
972 		case EX_OSERR:
973 			atf_tc_fail("setrlimit(2) failed");
974 			break;
975 		default:
976 			atf_tc_fail("child exited with status %d",
977 			    WEXITSTATUS(__status));
978 		}
979 	} else {
980 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
981 	}
982 #undef BUF
983 
984 }
985 
986 ATF_TC_WITHOUT_HEAD(wcscat_before_end);
ATF_TC_BODY(wcscat_before_end,tc)987 ATF_TC_BODY(wcscat_before_end, tc)
988 {
989 #define BUF &__stack.__buf
990 	struct {
991 		uint8_t padding_l;
992 		wchar_t __buf[42];
993 		uint8_t padding_r;
994 	} __stack;
995 	const size_t __bufsz __unused = sizeof(__stack.__buf);
996 	const size_t __len = 42 - 1;
997 	const size_t __idx __unused = __len - 1;
998 	wchar_t src[__len];
999 
1000 	wmemset(__stack.__buf, 0, __len);
1001 	wmemset(src, 'A', __len - 1);
1002 	src[__len - 1] = '\0';
1003 
1004 	wcscat(__stack.__buf, src);
1005 #undef BUF
1006 
1007 }
1008 
1009 ATF_TC_WITHOUT_HEAD(wcscat_end);
ATF_TC_BODY(wcscat_end,tc)1010 ATF_TC_BODY(wcscat_end, tc)
1011 {
1012 #define BUF &__stack.__buf
1013 	struct {
1014 		uint8_t padding_l;
1015 		wchar_t __buf[42];
1016 		uint8_t padding_r;
1017 	} __stack;
1018 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1019 	const size_t __len = 42;
1020 	const size_t __idx __unused = __len - 1;
1021 	wchar_t src[__len];
1022 
1023 	wmemset(__stack.__buf, 0, __len);
1024 	wmemset(src, 'A', __len - 1);
1025 	src[__len - 1] = '\0';
1026 
1027 	wcscat(__stack.__buf, src);
1028 #undef BUF
1029 
1030 }
1031 
1032 ATF_TC_WITHOUT_HEAD(wcscat_heap_before_end);
ATF_TC_BODY(wcscat_heap_before_end,tc)1033 ATF_TC_BODY(wcscat_heap_before_end, tc)
1034 {
1035 #define BUF __stack.__buf
1036 	struct {
1037 		uint8_t padding_l;
1038 		wchar_t * __buf;
1039 		uint8_t padding_r;
1040 	} __stack;
1041 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1042 	const size_t __len = 42 - 1;
1043 	const size_t __idx __unused = __len - 1;
1044 	wchar_t src[__len];
1045 
1046 	__stack.__buf = malloc(__bufsz);
1047 	wmemset(__stack.__buf, 0, __len);
1048 	wmemset(src, 'A', __len - 1);
1049 	src[__len - 1] = '\0';
1050 
1051 	wcscat(__stack.__buf, src);
1052 #undef BUF
1053 
1054 }
1055 
1056 ATF_TC_WITHOUT_HEAD(wcscat_heap_end);
ATF_TC_BODY(wcscat_heap_end,tc)1057 ATF_TC_BODY(wcscat_heap_end, tc)
1058 {
1059 #define BUF __stack.__buf
1060 	struct {
1061 		uint8_t padding_l;
1062 		wchar_t * __buf;
1063 		uint8_t padding_r;
1064 	} __stack;
1065 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1066 	const size_t __len = 42;
1067 	const size_t __idx __unused = __len - 1;
1068 	wchar_t src[__len];
1069 
1070 	__stack.__buf = malloc(__bufsz);
1071 	wmemset(__stack.__buf, 0, __len);
1072 	wmemset(src, 'A', __len - 1);
1073 	src[__len - 1] = '\0';
1074 
1075 	wcscat(__stack.__buf, src);
1076 #undef BUF
1077 
1078 }
1079 
1080 ATF_TC_WITHOUT_HEAD(wcscat_heap_after_end);
ATF_TC_BODY(wcscat_heap_after_end,tc)1081 ATF_TC_BODY(wcscat_heap_after_end, tc)
1082 {
1083 #define BUF __stack.__buf
1084 	struct {
1085 		uint8_t padding_l;
1086 		wchar_t * __buf;
1087 		uint8_t padding_r;
1088 	} __stack;
1089 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1090 	const size_t __len = 42 + 1;
1091 	const size_t __idx __unused = __len - 1;
1092 	pid_t __child;
1093 	int __status;
1094 	wchar_t src[__len];
1095 
1096 	__child = fork();
1097 	ATF_REQUIRE(__child >= 0);
1098 	if (__child > 0)
1099 		goto monitor;
1100 
1101 	/* Child */
1102 	disable_coredumps();
1103 	__stack.__buf = malloc(__bufsz);
1104 	wmemset(__stack.__buf, 0, __len);
1105 	wmemset(src, 'A', __len - 1);
1106 	src[__len - 1] = '\0';
1107 
1108 	wcscat(__stack.__buf, src);
1109 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1110 
1111 monitor:
1112 	while (waitpid(__child, &__status, 0) != __child) {
1113 		ATF_REQUIRE_EQ(EINTR, errno);
1114 	}
1115 
1116 	if (!WIFSIGNALED(__status)) {
1117 		switch (WEXITSTATUS(__status)) {
1118 		case EX_SOFTWARE:
1119 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1120 			break;
1121 		case EX_OSERR:
1122 			atf_tc_fail("setrlimit(2) failed");
1123 			break;
1124 		default:
1125 			atf_tc_fail("child exited with status %d",
1126 			    WEXITSTATUS(__status));
1127 		}
1128 	} else {
1129 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1130 	}
1131 #undef BUF
1132 
1133 }
1134 
1135 ATF_TC_WITHOUT_HEAD(wcslcat_before_end);
ATF_TC_BODY(wcslcat_before_end,tc)1136 ATF_TC_BODY(wcslcat_before_end, tc)
1137 {
1138 #define BUF &__stack.__buf
1139 	struct {
1140 		uint8_t padding_l;
1141 		wchar_t __buf[42];
1142 		uint8_t padding_r;
1143 	} __stack;
1144 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1145 	const size_t __len = 42 - 1;
1146 	const size_t __idx __unused = __len - 1;
1147 	wchar_t src[__len];
1148 
1149 	wmemset(__stack.__buf, 0, __len);
1150 	wmemset(src, 'A', __len - 1);
1151 	src[__len - 1] = '\0';
1152 
1153 	wcslcat(__stack.__buf, src, __len);
1154 #undef BUF
1155 
1156 }
1157 
1158 ATF_TC_WITHOUT_HEAD(wcslcat_end);
ATF_TC_BODY(wcslcat_end,tc)1159 ATF_TC_BODY(wcslcat_end, tc)
1160 {
1161 #define BUF &__stack.__buf
1162 	struct {
1163 		uint8_t padding_l;
1164 		wchar_t __buf[42];
1165 		uint8_t padding_r;
1166 	} __stack;
1167 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1168 	const size_t __len = 42;
1169 	const size_t __idx __unused = __len - 1;
1170 	wchar_t src[__len];
1171 
1172 	wmemset(__stack.__buf, 0, __len);
1173 	wmemset(src, 'A', __len - 1);
1174 	src[__len - 1] = '\0';
1175 
1176 	wcslcat(__stack.__buf, src, __len);
1177 #undef BUF
1178 
1179 }
1180 
1181 ATF_TC_WITHOUT_HEAD(wcslcat_heap_before_end);
ATF_TC_BODY(wcslcat_heap_before_end,tc)1182 ATF_TC_BODY(wcslcat_heap_before_end, tc)
1183 {
1184 #define BUF __stack.__buf
1185 	struct {
1186 		uint8_t padding_l;
1187 		wchar_t * __buf;
1188 		uint8_t padding_r;
1189 	} __stack;
1190 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1191 	const size_t __len = 42 - 1;
1192 	const size_t __idx __unused = __len - 1;
1193 	wchar_t src[__len];
1194 
1195 	__stack.__buf = malloc(__bufsz);
1196 	wmemset(__stack.__buf, 0, __len);
1197 	wmemset(src, 'A', __len - 1);
1198 	src[__len - 1] = '\0';
1199 
1200 	wcslcat(__stack.__buf, src, __len);
1201 #undef BUF
1202 
1203 }
1204 
1205 ATF_TC_WITHOUT_HEAD(wcslcat_heap_end);
ATF_TC_BODY(wcslcat_heap_end,tc)1206 ATF_TC_BODY(wcslcat_heap_end, tc)
1207 {
1208 #define BUF __stack.__buf
1209 	struct {
1210 		uint8_t padding_l;
1211 		wchar_t * __buf;
1212 		uint8_t padding_r;
1213 	} __stack;
1214 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1215 	const size_t __len = 42;
1216 	const size_t __idx __unused = __len - 1;
1217 	wchar_t src[__len];
1218 
1219 	__stack.__buf = malloc(__bufsz);
1220 	wmemset(__stack.__buf, 0, __len);
1221 	wmemset(src, 'A', __len - 1);
1222 	src[__len - 1] = '\0';
1223 
1224 	wcslcat(__stack.__buf, src, __len);
1225 #undef BUF
1226 
1227 }
1228 
1229 ATF_TC_WITHOUT_HEAD(wcslcat_heap_after_end);
ATF_TC_BODY(wcslcat_heap_after_end,tc)1230 ATF_TC_BODY(wcslcat_heap_after_end, tc)
1231 {
1232 #define BUF __stack.__buf
1233 	struct {
1234 		uint8_t padding_l;
1235 		wchar_t * __buf;
1236 		uint8_t padding_r;
1237 	} __stack;
1238 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1239 	const size_t __len = 42 + 1;
1240 	const size_t __idx __unused = __len - 1;
1241 	pid_t __child;
1242 	int __status;
1243 	wchar_t src[__len];
1244 
1245 	__child = fork();
1246 	ATF_REQUIRE(__child >= 0);
1247 	if (__child > 0)
1248 		goto monitor;
1249 
1250 	/* Child */
1251 	disable_coredumps();
1252 	__stack.__buf = malloc(__bufsz);
1253 	wmemset(__stack.__buf, 0, __len);
1254 	wmemset(src, 'A', __len - 1);
1255 	src[__len - 1] = '\0';
1256 
1257 	wcslcat(__stack.__buf, src, __len);
1258 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1259 
1260 monitor:
1261 	while (waitpid(__child, &__status, 0) != __child) {
1262 		ATF_REQUIRE_EQ(EINTR, errno);
1263 	}
1264 
1265 	if (!WIFSIGNALED(__status)) {
1266 		switch (WEXITSTATUS(__status)) {
1267 		case EX_SOFTWARE:
1268 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1269 			break;
1270 		case EX_OSERR:
1271 			atf_tc_fail("setrlimit(2) failed");
1272 			break;
1273 		default:
1274 			atf_tc_fail("child exited with status %d",
1275 			    WEXITSTATUS(__status));
1276 		}
1277 	} else {
1278 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1279 	}
1280 #undef BUF
1281 
1282 }
1283 
1284 ATF_TC_WITHOUT_HEAD(wcsncat_before_end);
ATF_TC_BODY(wcsncat_before_end,tc)1285 ATF_TC_BODY(wcsncat_before_end, tc)
1286 {
1287 #define BUF &__stack.__buf
1288 	struct {
1289 		uint8_t padding_l;
1290 		wchar_t __buf[42];
1291 		uint8_t padding_r;
1292 	} __stack;
1293 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1294 	const size_t __len = 42 - 1;
1295 	const size_t __idx __unused = __len - 1;
1296 	wchar_t src[__len];
1297 
1298 	wmemset(__stack.__buf, 0, __len);
1299 	wmemset(src, 'A', __len - 1);
1300 	src[__len - 1] = '\0';
1301 
1302 	wcsncat(__stack.__buf, src, __len);
1303 #undef BUF
1304 
1305 }
1306 
1307 ATF_TC_WITHOUT_HEAD(wcsncat_end);
ATF_TC_BODY(wcsncat_end,tc)1308 ATF_TC_BODY(wcsncat_end, tc)
1309 {
1310 #define BUF &__stack.__buf
1311 	struct {
1312 		uint8_t padding_l;
1313 		wchar_t __buf[42];
1314 		uint8_t padding_r;
1315 	} __stack;
1316 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1317 	const size_t __len = 42;
1318 	const size_t __idx __unused = __len - 1;
1319 	wchar_t src[__len];
1320 
1321 	wmemset(__stack.__buf, 0, __len);
1322 	wmemset(src, 'A', __len - 1);
1323 	src[__len - 1] = '\0';
1324 
1325 	wcsncat(__stack.__buf, src, __len);
1326 #undef BUF
1327 
1328 }
1329 
1330 ATF_TC_WITHOUT_HEAD(wcsncat_heap_before_end);
ATF_TC_BODY(wcsncat_heap_before_end,tc)1331 ATF_TC_BODY(wcsncat_heap_before_end, tc)
1332 {
1333 #define BUF __stack.__buf
1334 	struct {
1335 		uint8_t padding_l;
1336 		wchar_t * __buf;
1337 		uint8_t padding_r;
1338 	} __stack;
1339 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1340 	const size_t __len = 42 - 1;
1341 	const size_t __idx __unused = __len - 1;
1342 	wchar_t src[__len];
1343 
1344 	__stack.__buf = malloc(__bufsz);
1345 	wmemset(__stack.__buf, 0, __len);
1346 	wmemset(src, 'A', __len - 1);
1347 	src[__len - 1] = '\0';
1348 
1349 	wcsncat(__stack.__buf, src, __len);
1350 #undef BUF
1351 
1352 }
1353 
1354 ATF_TC_WITHOUT_HEAD(wcsncat_heap_end);
ATF_TC_BODY(wcsncat_heap_end,tc)1355 ATF_TC_BODY(wcsncat_heap_end, tc)
1356 {
1357 #define BUF __stack.__buf
1358 	struct {
1359 		uint8_t padding_l;
1360 		wchar_t * __buf;
1361 		uint8_t padding_r;
1362 	} __stack;
1363 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1364 	const size_t __len = 42;
1365 	const size_t __idx __unused = __len - 1;
1366 	wchar_t src[__len];
1367 
1368 	__stack.__buf = malloc(__bufsz);
1369 	wmemset(__stack.__buf, 0, __len);
1370 	wmemset(src, 'A', __len - 1);
1371 	src[__len - 1] = '\0';
1372 
1373 	wcsncat(__stack.__buf, src, __len);
1374 #undef BUF
1375 
1376 }
1377 
1378 ATF_TC_WITHOUT_HEAD(wcsncat_heap_after_end);
ATF_TC_BODY(wcsncat_heap_after_end,tc)1379 ATF_TC_BODY(wcsncat_heap_after_end, tc)
1380 {
1381 #define BUF __stack.__buf
1382 	struct {
1383 		uint8_t padding_l;
1384 		wchar_t * __buf;
1385 		uint8_t padding_r;
1386 	} __stack;
1387 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1388 	const size_t __len = 42 + 1;
1389 	const size_t __idx __unused = __len - 1;
1390 	pid_t __child;
1391 	int __status;
1392 	wchar_t src[__len];
1393 
1394 	__child = fork();
1395 	ATF_REQUIRE(__child >= 0);
1396 	if (__child > 0)
1397 		goto monitor;
1398 
1399 	/* Child */
1400 	disable_coredumps();
1401 	__stack.__buf = malloc(__bufsz);
1402 	wmemset(__stack.__buf, 0, __len);
1403 	wmemset(src, 'A', __len - 1);
1404 	src[__len - 1] = '\0';
1405 
1406 	wcsncat(__stack.__buf, src, __len);
1407 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1408 
1409 monitor:
1410 	while (waitpid(__child, &__status, 0) != __child) {
1411 		ATF_REQUIRE_EQ(EINTR, errno);
1412 	}
1413 
1414 	if (!WIFSIGNALED(__status)) {
1415 		switch (WEXITSTATUS(__status)) {
1416 		case EX_SOFTWARE:
1417 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1418 			break;
1419 		case EX_OSERR:
1420 			atf_tc_fail("setrlimit(2) failed");
1421 			break;
1422 		default:
1423 			atf_tc_fail("child exited with status %d",
1424 			    WEXITSTATUS(__status));
1425 		}
1426 	} else {
1427 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1428 	}
1429 #undef BUF
1430 
1431 }
1432 
1433 ATF_TC_WITHOUT_HEAD(wcscpy_before_end);
ATF_TC_BODY(wcscpy_before_end,tc)1434 ATF_TC_BODY(wcscpy_before_end, tc)
1435 {
1436 #define BUF &__stack.__buf
1437 	struct {
1438 		uint8_t padding_l;
1439 		wchar_t __buf[42];
1440 		uint8_t padding_r;
1441 	} __stack;
1442 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1443 	const size_t __len = 42 - 1;
1444 	const size_t __idx __unused = __len - 1;
1445 	wchar_t src[__len];
1446 
1447 	wmemset(__stack.__buf, 0, __len);
1448 	wmemset(src, 'A', __len - 1);
1449 	src[__len - 1] = '\0';
1450 
1451 	wcscpy(__stack.__buf, src);
1452 #undef BUF
1453 
1454 }
1455 
1456 ATF_TC_WITHOUT_HEAD(wcscpy_end);
ATF_TC_BODY(wcscpy_end,tc)1457 ATF_TC_BODY(wcscpy_end, tc)
1458 {
1459 #define BUF &__stack.__buf
1460 	struct {
1461 		uint8_t padding_l;
1462 		wchar_t __buf[42];
1463 		uint8_t padding_r;
1464 	} __stack;
1465 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1466 	const size_t __len = 42;
1467 	const size_t __idx __unused = __len - 1;
1468 	wchar_t src[__len];
1469 
1470 	wmemset(__stack.__buf, 0, __len);
1471 	wmemset(src, 'A', __len - 1);
1472 	src[__len - 1] = '\0';
1473 
1474 	wcscpy(__stack.__buf, src);
1475 #undef BUF
1476 
1477 }
1478 
1479 ATF_TC_WITHOUT_HEAD(wcscpy_heap_before_end);
ATF_TC_BODY(wcscpy_heap_before_end,tc)1480 ATF_TC_BODY(wcscpy_heap_before_end, tc)
1481 {
1482 #define BUF __stack.__buf
1483 	struct {
1484 		uint8_t padding_l;
1485 		wchar_t * __buf;
1486 		uint8_t padding_r;
1487 	} __stack;
1488 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1489 	const size_t __len = 42 - 1;
1490 	const size_t __idx __unused = __len - 1;
1491 	wchar_t src[__len];
1492 
1493 	__stack.__buf = malloc(__bufsz);
1494 	wmemset(__stack.__buf, 0, __len);
1495 	wmemset(src, 'A', __len - 1);
1496 	src[__len - 1] = '\0';
1497 
1498 	wcscpy(__stack.__buf, src);
1499 #undef BUF
1500 
1501 }
1502 
1503 ATF_TC_WITHOUT_HEAD(wcscpy_heap_end);
ATF_TC_BODY(wcscpy_heap_end,tc)1504 ATF_TC_BODY(wcscpy_heap_end, tc)
1505 {
1506 #define BUF __stack.__buf
1507 	struct {
1508 		uint8_t padding_l;
1509 		wchar_t * __buf;
1510 		uint8_t padding_r;
1511 	} __stack;
1512 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1513 	const size_t __len = 42;
1514 	const size_t __idx __unused = __len - 1;
1515 	wchar_t src[__len];
1516 
1517 	__stack.__buf = malloc(__bufsz);
1518 	wmemset(__stack.__buf, 0, __len);
1519 	wmemset(src, 'A', __len - 1);
1520 	src[__len - 1] = '\0';
1521 
1522 	wcscpy(__stack.__buf, src);
1523 #undef BUF
1524 
1525 }
1526 
1527 ATF_TC_WITHOUT_HEAD(wcscpy_heap_after_end);
ATF_TC_BODY(wcscpy_heap_after_end,tc)1528 ATF_TC_BODY(wcscpy_heap_after_end, tc)
1529 {
1530 #define BUF __stack.__buf
1531 	struct {
1532 		uint8_t padding_l;
1533 		wchar_t * __buf;
1534 		uint8_t padding_r;
1535 	} __stack;
1536 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1537 	const size_t __len = 42 + 1;
1538 	const size_t __idx __unused = __len - 1;
1539 	pid_t __child;
1540 	int __status;
1541 	wchar_t src[__len];
1542 
1543 	__child = fork();
1544 	ATF_REQUIRE(__child >= 0);
1545 	if (__child > 0)
1546 		goto monitor;
1547 
1548 	/* Child */
1549 	disable_coredumps();
1550 	__stack.__buf = malloc(__bufsz);
1551 	wmemset(__stack.__buf, 0, __len);
1552 	wmemset(src, 'A', __len - 1);
1553 	src[__len - 1] = '\0';
1554 
1555 	wcscpy(__stack.__buf, src);
1556 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1557 
1558 monitor:
1559 	while (waitpid(__child, &__status, 0) != __child) {
1560 		ATF_REQUIRE_EQ(EINTR, errno);
1561 	}
1562 
1563 	if (!WIFSIGNALED(__status)) {
1564 		switch (WEXITSTATUS(__status)) {
1565 		case EX_SOFTWARE:
1566 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1567 			break;
1568 		case EX_OSERR:
1569 			atf_tc_fail("setrlimit(2) failed");
1570 			break;
1571 		default:
1572 			atf_tc_fail("child exited with status %d",
1573 			    WEXITSTATUS(__status));
1574 		}
1575 	} else {
1576 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1577 	}
1578 #undef BUF
1579 
1580 }
1581 
1582 ATF_TC_WITHOUT_HEAD(wcslcpy_before_end);
ATF_TC_BODY(wcslcpy_before_end,tc)1583 ATF_TC_BODY(wcslcpy_before_end, tc)
1584 {
1585 #define BUF &__stack.__buf
1586 	struct {
1587 		uint8_t padding_l;
1588 		wchar_t __buf[42];
1589 		uint8_t padding_r;
1590 	} __stack;
1591 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1592 	const size_t __len = 42 - 1;
1593 	const size_t __idx __unused = __len - 1;
1594 	wchar_t src[__len];
1595 
1596 	wmemset(__stack.__buf, 0, __len);
1597 	wmemset(src, 'A', __len - 1);
1598 	src[__len - 1] = '\0';
1599 
1600 	wcslcpy(__stack.__buf, src, __len);
1601 #undef BUF
1602 
1603 }
1604 
1605 ATF_TC_WITHOUT_HEAD(wcslcpy_end);
ATF_TC_BODY(wcslcpy_end,tc)1606 ATF_TC_BODY(wcslcpy_end, tc)
1607 {
1608 #define BUF &__stack.__buf
1609 	struct {
1610 		uint8_t padding_l;
1611 		wchar_t __buf[42];
1612 		uint8_t padding_r;
1613 	} __stack;
1614 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1615 	const size_t __len = 42;
1616 	const size_t __idx __unused = __len - 1;
1617 	wchar_t src[__len];
1618 
1619 	wmemset(__stack.__buf, 0, __len);
1620 	wmemset(src, 'A', __len - 1);
1621 	src[__len - 1] = '\0';
1622 
1623 	wcslcpy(__stack.__buf, src, __len);
1624 #undef BUF
1625 
1626 }
1627 
1628 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_before_end);
ATF_TC_BODY(wcslcpy_heap_before_end,tc)1629 ATF_TC_BODY(wcslcpy_heap_before_end, tc)
1630 {
1631 #define BUF __stack.__buf
1632 	struct {
1633 		uint8_t padding_l;
1634 		wchar_t * __buf;
1635 		uint8_t padding_r;
1636 	} __stack;
1637 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1638 	const size_t __len = 42 - 1;
1639 	const size_t __idx __unused = __len - 1;
1640 	wchar_t src[__len];
1641 
1642 	__stack.__buf = malloc(__bufsz);
1643 	wmemset(__stack.__buf, 0, __len);
1644 	wmemset(src, 'A', __len - 1);
1645 	src[__len - 1] = '\0';
1646 
1647 	wcslcpy(__stack.__buf, src, __len);
1648 #undef BUF
1649 
1650 }
1651 
1652 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_end);
ATF_TC_BODY(wcslcpy_heap_end,tc)1653 ATF_TC_BODY(wcslcpy_heap_end, tc)
1654 {
1655 #define BUF __stack.__buf
1656 	struct {
1657 		uint8_t padding_l;
1658 		wchar_t * __buf;
1659 		uint8_t padding_r;
1660 	} __stack;
1661 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1662 	const size_t __len = 42;
1663 	const size_t __idx __unused = __len - 1;
1664 	wchar_t src[__len];
1665 
1666 	__stack.__buf = malloc(__bufsz);
1667 	wmemset(__stack.__buf, 0, __len);
1668 	wmemset(src, 'A', __len - 1);
1669 	src[__len - 1] = '\0';
1670 
1671 	wcslcpy(__stack.__buf, src, __len);
1672 #undef BUF
1673 
1674 }
1675 
1676 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_after_end);
ATF_TC_BODY(wcslcpy_heap_after_end,tc)1677 ATF_TC_BODY(wcslcpy_heap_after_end, tc)
1678 {
1679 #define BUF __stack.__buf
1680 	struct {
1681 		uint8_t padding_l;
1682 		wchar_t * __buf;
1683 		uint8_t padding_r;
1684 	} __stack;
1685 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1686 	const size_t __len = 42 + 1;
1687 	const size_t __idx __unused = __len - 1;
1688 	pid_t __child;
1689 	int __status;
1690 	wchar_t src[__len];
1691 
1692 	__child = fork();
1693 	ATF_REQUIRE(__child >= 0);
1694 	if (__child > 0)
1695 		goto monitor;
1696 
1697 	/* Child */
1698 	disable_coredumps();
1699 	__stack.__buf = malloc(__bufsz);
1700 	wmemset(__stack.__buf, 0, __len);
1701 	wmemset(src, 'A', __len - 1);
1702 	src[__len - 1] = '\0';
1703 
1704 	wcslcpy(__stack.__buf, src, __len);
1705 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1706 
1707 monitor:
1708 	while (waitpid(__child, &__status, 0) != __child) {
1709 		ATF_REQUIRE_EQ(EINTR, errno);
1710 	}
1711 
1712 	if (!WIFSIGNALED(__status)) {
1713 		switch (WEXITSTATUS(__status)) {
1714 		case EX_SOFTWARE:
1715 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1716 			break;
1717 		case EX_OSERR:
1718 			atf_tc_fail("setrlimit(2) failed");
1719 			break;
1720 		default:
1721 			atf_tc_fail("child exited with status %d",
1722 			    WEXITSTATUS(__status));
1723 		}
1724 	} else {
1725 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1726 	}
1727 #undef BUF
1728 
1729 }
1730 
1731 ATF_TC_WITHOUT_HEAD(wcsncpy_before_end);
ATF_TC_BODY(wcsncpy_before_end,tc)1732 ATF_TC_BODY(wcsncpy_before_end, tc)
1733 {
1734 #define BUF &__stack.__buf
1735 	struct {
1736 		uint8_t padding_l;
1737 		wchar_t __buf[42];
1738 		uint8_t padding_r;
1739 	} __stack;
1740 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1741 	const size_t __len = 42 - 1;
1742 	const size_t __idx __unused = __len - 1;
1743 	wchar_t src[__len];
1744 
1745 	wmemset(__stack.__buf, 0, __len);
1746 	wmemset(src, 'A', __len - 1);
1747 	src[__len - 1] = '\0';
1748 
1749 	wcsncpy(__stack.__buf, src, __len);
1750 #undef BUF
1751 
1752 }
1753 
1754 ATF_TC_WITHOUT_HEAD(wcsncpy_end);
ATF_TC_BODY(wcsncpy_end,tc)1755 ATF_TC_BODY(wcsncpy_end, tc)
1756 {
1757 #define BUF &__stack.__buf
1758 	struct {
1759 		uint8_t padding_l;
1760 		wchar_t __buf[42];
1761 		uint8_t padding_r;
1762 	} __stack;
1763 	const size_t __bufsz __unused = sizeof(__stack.__buf);
1764 	const size_t __len = 42;
1765 	const size_t __idx __unused = __len - 1;
1766 	wchar_t src[__len];
1767 
1768 	wmemset(__stack.__buf, 0, __len);
1769 	wmemset(src, 'A', __len - 1);
1770 	src[__len - 1] = '\0';
1771 
1772 	wcsncpy(__stack.__buf, src, __len);
1773 #undef BUF
1774 
1775 }
1776 
1777 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_before_end);
ATF_TC_BODY(wcsncpy_heap_before_end,tc)1778 ATF_TC_BODY(wcsncpy_heap_before_end, tc)
1779 {
1780 #define BUF __stack.__buf
1781 	struct {
1782 		uint8_t padding_l;
1783 		wchar_t * __buf;
1784 		uint8_t padding_r;
1785 	} __stack;
1786 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1787 	const size_t __len = 42 - 1;
1788 	const size_t __idx __unused = __len - 1;
1789 	wchar_t src[__len];
1790 
1791 	__stack.__buf = malloc(__bufsz);
1792 	wmemset(__stack.__buf, 0, __len);
1793 	wmemset(src, 'A', __len - 1);
1794 	src[__len - 1] = '\0';
1795 
1796 	wcsncpy(__stack.__buf, src, __len);
1797 #undef BUF
1798 
1799 }
1800 
1801 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_end);
ATF_TC_BODY(wcsncpy_heap_end,tc)1802 ATF_TC_BODY(wcsncpy_heap_end, tc)
1803 {
1804 #define BUF __stack.__buf
1805 	struct {
1806 		uint8_t padding_l;
1807 		wchar_t * __buf;
1808 		uint8_t padding_r;
1809 	} __stack;
1810 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1811 	const size_t __len = 42;
1812 	const size_t __idx __unused = __len - 1;
1813 	wchar_t src[__len];
1814 
1815 	__stack.__buf = malloc(__bufsz);
1816 	wmemset(__stack.__buf, 0, __len);
1817 	wmemset(src, 'A', __len - 1);
1818 	src[__len - 1] = '\0';
1819 
1820 	wcsncpy(__stack.__buf, src, __len);
1821 #undef BUF
1822 
1823 }
1824 
1825 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_after_end);
ATF_TC_BODY(wcsncpy_heap_after_end,tc)1826 ATF_TC_BODY(wcsncpy_heap_after_end, tc)
1827 {
1828 #define BUF __stack.__buf
1829 	struct {
1830 		uint8_t padding_l;
1831 		wchar_t * __buf;
1832 		uint8_t padding_r;
1833 	} __stack;
1834 	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1835 	const size_t __len = 42 + 1;
1836 	const size_t __idx __unused = __len - 1;
1837 	pid_t __child;
1838 	int __status;
1839 	wchar_t src[__len];
1840 
1841 	__child = fork();
1842 	ATF_REQUIRE(__child >= 0);
1843 	if (__child > 0)
1844 		goto monitor;
1845 
1846 	/* Child */
1847 	disable_coredumps();
1848 	__stack.__buf = malloc(__bufsz);
1849 	wmemset(__stack.__buf, 0, __len);
1850 	wmemset(src, 'A', __len - 1);
1851 	src[__len - 1] = '\0';
1852 
1853 	wcsncpy(__stack.__buf, src, __len);
1854 	_exit(EX_SOFTWARE);	/* Should have aborted. */
1855 
1856 monitor:
1857 	while (waitpid(__child, &__status, 0) != __child) {
1858 		ATF_REQUIRE_EQ(EINTR, errno);
1859 	}
1860 
1861 	if (!WIFSIGNALED(__status)) {
1862 		switch (WEXITSTATUS(__status)) {
1863 		case EX_SOFTWARE:
1864 			atf_tc_fail("FORTIFY_SOURCE failed to abort");
1865 			break;
1866 		case EX_OSERR:
1867 			atf_tc_fail("setrlimit(2) failed");
1868 			break;
1869 		default:
1870 			atf_tc_fail("child exited with status %d",
1871 			    WEXITSTATUS(__status));
1872 		}
1873 	} else {
1874 		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1875 	}
1876 #undef BUF
1877 
1878 }
1879 
ATF_TP_ADD_TCS(tp)1880 ATF_TP_ADD_TCS(tp)
1881 {
1882 	ATF_TP_ADD_TC(tp, wmemcpy_before_end);
1883 	ATF_TP_ADD_TC(tp, wmemcpy_end);
1884 	ATF_TP_ADD_TC(tp, wmemcpy_heap_before_end);
1885 	ATF_TP_ADD_TC(tp, wmemcpy_heap_end);
1886 	ATF_TP_ADD_TC(tp, wmemcpy_heap_after_end);
1887 	ATF_TP_ADD_TC(tp, wmempcpy_before_end);
1888 	ATF_TP_ADD_TC(tp, wmempcpy_end);
1889 	ATF_TP_ADD_TC(tp, wmempcpy_heap_before_end);
1890 	ATF_TP_ADD_TC(tp, wmempcpy_heap_end);
1891 	ATF_TP_ADD_TC(tp, wmempcpy_heap_after_end);
1892 	ATF_TP_ADD_TC(tp, wmemmove_before_end);
1893 	ATF_TP_ADD_TC(tp, wmemmove_end);
1894 	ATF_TP_ADD_TC(tp, wmemmove_heap_before_end);
1895 	ATF_TP_ADD_TC(tp, wmemmove_heap_end);
1896 	ATF_TP_ADD_TC(tp, wmemmove_heap_after_end);
1897 	ATF_TP_ADD_TC(tp, wmemset_before_end);
1898 	ATF_TP_ADD_TC(tp, wmemset_end);
1899 	ATF_TP_ADD_TC(tp, wmemset_heap_before_end);
1900 	ATF_TP_ADD_TC(tp, wmemset_heap_end);
1901 	ATF_TP_ADD_TC(tp, wmemset_heap_after_end);
1902 	ATF_TP_ADD_TC(tp, wcpcpy_before_end);
1903 	ATF_TP_ADD_TC(tp, wcpcpy_end);
1904 	ATF_TP_ADD_TC(tp, wcpcpy_heap_before_end);
1905 	ATF_TP_ADD_TC(tp, wcpcpy_heap_end);
1906 	ATF_TP_ADD_TC(tp, wcpcpy_heap_after_end);
1907 	ATF_TP_ADD_TC(tp, wcpncpy_before_end);
1908 	ATF_TP_ADD_TC(tp, wcpncpy_end);
1909 	ATF_TP_ADD_TC(tp, wcpncpy_heap_before_end);
1910 	ATF_TP_ADD_TC(tp, wcpncpy_heap_end);
1911 	ATF_TP_ADD_TC(tp, wcpncpy_heap_after_end);
1912 	ATF_TP_ADD_TC(tp, wcscat_before_end);
1913 	ATF_TP_ADD_TC(tp, wcscat_end);
1914 	ATF_TP_ADD_TC(tp, wcscat_heap_before_end);
1915 	ATF_TP_ADD_TC(tp, wcscat_heap_end);
1916 	ATF_TP_ADD_TC(tp, wcscat_heap_after_end);
1917 	ATF_TP_ADD_TC(tp, wcslcat_before_end);
1918 	ATF_TP_ADD_TC(tp, wcslcat_end);
1919 	ATF_TP_ADD_TC(tp, wcslcat_heap_before_end);
1920 	ATF_TP_ADD_TC(tp, wcslcat_heap_end);
1921 	ATF_TP_ADD_TC(tp, wcslcat_heap_after_end);
1922 	ATF_TP_ADD_TC(tp, wcsncat_before_end);
1923 	ATF_TP_ADD_TC(tp, wcsncat_end);
1924 	ATF_TP_ADD_TC(tp, wcsncat_heap_before_end);
1925 	ATF_TP_ADD_TC(tp, wcsncat_heap_end);
1926 	ATF_TP_ADD_TC(tp, wcsncat_heap_after_end);
1927 	ATF_TP_ADD_TC(tp, wcscpy_before_end);
1928 	ATF_TP_ADD_TC(tp, wcscpy_end);
1929 	ATF_TP_ADD_TC(tp, wcscpy_heap_before_end);
1930 	ATF_TP_ADD_TC(tp, wcscpy_heap_end);
1931 	ATF_TP_ADD_TC(tp, wcscpy_heap_after_end);
1932 	ATF_TP_ADD_TC(tp, wcslcpy_before_end);
1933 	ATF_TP_ADD_TC(tp, wcslcpy_end);
1934 	ATF_TP_ADD_TC(tp, wcslcpy_heap_before_end);
1935 	ATF_TP_ADD_TC(tp, wcslcpy_heap_end);
1936 	ATF_TP_ADD_TC(tp, wcslcpy_heap_after_end);
1937 	ATF_TP_ADD_TC(tp, wcsncpy_before_end);
1938 	ATF_TP_ADD_TC(tp, wcsncpy_end);
1939 	ATF_TP_ADD_TC(tp, wcsncpy_heap_before_end);
1940 	ATF_TP_ADD_TC(tp, wcsncpy_heap_end);
1941 	ATF_TP_ADD_TC(tp, wcsncpy_heap_after_end);
1942 	return (atf_no_error());
1943 }
1944