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/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
new_fp(size_t __len)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
new_symlink(size_t __len)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
new_socket(int sock[2])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
new_tmpfile(void)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
disable_coredumps(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
replace_stdin(void)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(wmemcpy_before_end);
ATF_TC_HEAD(wmemcpy_before_end,tc)167 ATF_TC_HEAD(wmemcpy_before_end, tc)
168 {
169 }
ATF_TC_BODY(wmemcpy_before_end,tc)170 ATF_TC_BODY(wmemcpy_before_end, tc)
171 {
172 #define BUF &__stack.__buf
173 struct {
174 uint8_t padding_l;
175 wchar_t __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 wchar_t src[__len + 10];
182
183 wmemcpy(__stack.__buf, src, __len);
184 #undef BUF
185
186 }
187
188 ATF_TC(wmemcpy_end);
ATF_TC_HEAD(wmemcpy_end,tc)189 ATF_TC_HEAD(wmemcpy_end, tc)
190 {
191 }
ATF_TC_BODY(wmemcpy_end,tc)192 ATF_TC_BODY(wmemcpy_end, tc)
193 {
194 #define BUF &__stack.__buf
195 struct {
196 uint8_t padding_l;
197 wchar_t __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 wchar_t src[__len + 10];
204
205 wmemcpy(__stack.__buf, src, __len);
206 #undef BUF
207
208 }
209
210 ATF_TC(wmemcpy_heap_before_end);
ATF_TC_HEAD(wmemcpy_heap_before_end,tc)211 ATF_TC_HEAD(wmemcpy_heap_before_end, tc)
212 {
213 }
ATF_TC_BODY(wmemcpy_heap_before_end,tc)214 ATF_TC_BODY(wmemcpy_heap_before_end, tc)
215 {
216 #define BUF __stack.__buf
217 struct {
218 uint8_t padding_l;
219 wchar_t * __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 wchar_t src[__len + 10];
226
227 __stack.__buf = malloc(__bufsz);
228
229 wmemcpy(__stack.__buf, src, __len);
230 #undef BUF
231
232 }
233
234 ATF_TC(wmemcpy_heap_end);
ATF_TC_HEAD(wmemcpy_heap_end,tc)235 ATF_TC_HEAD(wmemcpy_heap_end, tc)
236 {
237 }
ATF_TC_BODY(wmemcpy_heap_end,tc)238 ATF_TC_BODY(wmemcpy_heap_end, tc)
239 {
240 #define BUF __stack.__buf
241 struct {
242 uint8_t padding_l;
243 wchar_t * __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 wchar_t src[__len + 10];
250
251 __stack.__buf = malloc(__bufsz);
252
253 wmemcpy(__stack.__buf, src, __len);
254 #undef BUF
255
256 }
257
258 ATF_TC(wmemcpy_heap_after_end);
ATF_TC_HEAD(wmemcpy_heap_after_end,tc)259 ATF_TC_HEAD(wmemcpy_heap_after_end, tc)
260 {
261 }
ATF_TC_BODY(wmemcpy_heap_after_end,tc)262 ATF_TC_BODY(wmemcpy_heap_after_end, tc)
263 {
264 #define BUF __stack.__buf
265 struct {
266 uint8_t padding_l;
267 wchar_t * __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 wchar_t 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 wmemcpy(__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(wmempcpy_before_end);
ATF_TC_HEAD(wmempcpy_before_end,tc)314 ATF_TC_HEAD(wmempcpy_before_end, tc)
315 {
316 }
ATF_TC_BODY(wmempcpy_before_end,tc)317 ATF_TC_BODY(wmempcpy_before_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 - 1;
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(wmempcpy_end);
ATF_TC_HEAD(wmempcpy_end,tc)336 ATF_TC_HEAD(wmempcpy_end, tc)
337 {
338 }
ATF_TC_BODY(wmempcpy_end,tc)339 ATF_TC_BODY(wmempcpy_end, tc)
340 {
341 #define BUF &__stack.__buf
342 struct {
343 uint8_t padding_l;
344 wchar_t __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 wchar_t src[__len + 10];
351
352 wmempcpy(__stack.__buf, src, __len);
353 #undef BUF
354
355 }
356
357 ATF_TC(wmempcpy_heap_before_end);
ATF_TC_HEAD(wmempcpy_heap_before_end,tc)358 ATF_TC_HEAD(wmempcpy_heap_before_end, tc)
359 {
360 }
ATF_TC_BODY(wmempcpy_heap_before_end,tc)361 ATF_TC_BODY(wmempcpy_heap_before_end, tc)
362 {
363 #define BUF __stack.__buf
364 struct {
365 uint8_t padding_l;
366 wchar_t * __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 wchar_t src[__len + 10];
373
374 __stack.__buf = malloc(__bufsz);
375
376 wmempcpy(__stack.__buf, src, __len);
377 #undef BUF
378
379 }
380
381 ATF_TC(wmempcpy_heap_end);
ATF_TC_HEAD(wmempcpy_heap_end,tc)382 ATF_TC_HEAD(wmempcpy_heap_end, tc)
383 {
384 }
ATF_TC_BODY(wmempcpy_heap_end,tc)385 ATF_TC_BODY(wmempcpy_heap_end, tc)
386 {
387 #define BUF __stack.__buf
388 struct {
389 uint8_t padding_l;
390 wchar_t * __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 wchar_t src[__len + 10];
397
398 __stack.__buf = malloc(__bufsz);
399
400 wmempcpy(__stack.__buf, src, __len);
401 #undef BUF
402
403 }
404
405 ATF_TC(wmempcpy_heap_after_end);
ATF_TC_HEAD(wmempcpy_heap_after_end,tc)406 ATF_TC_HEAD(wmempcpy_heap_after_end, tc)
407 {
408 }
ATF_TC_BODY(wmempcpy_heap_after_end,tc)409 ATF_TC_BODY(wmempcpy_heap_after_end, tc)
410 {
411 #define BUF __stack.__buf
412 struct {
413 uint8_t padding_l;
414 wchar_t * __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 wchar_t 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 wmempcpy(__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(wmemmove_before_end);
ATF_TC_HEAD(wmemmove_before_end,tc)461 ATF_TC_HEAD(wmemmove_before_end, tc)
462 {
463 }
ATF_TC_BODY(wmemmove_before_end,tc)464 ATF_TC_BODY(wmemmove_before_end, tc)
465 {
466 #define BUF &__stack.__buf
467 struct {
468 uint8_t padding_l;
469 wchar_t __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 wchar_t src[__len + 10];
476
477 wmemmove(__stack.__buf, src, __len);
478 #undef BUF
479
480 }
481
482 ATF_TC(wmemmove_end);
ATF_TC_HEAD(wmemmove_end,tc)483 ATF_TC_HEAD(wmemmove_end, tc)
484 {
485 }
ATF_TC_BODY(wmemmove_end,tc)486 ATF_TC_BODY(wmemmove_end, tc)
487 {
488 #define BUF &__stack.__buf
489 struct {
490 uint8_t padding_l;
491 wchar_t __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 wchar_t src[__len + 10];
498
499 wmemmove(__stack.__buf, src, __len);
500 #undef BUF
501
502 }
503
504 ATF_TC(wmemmove_heap_before_end);
ATF_TC_HEAD(wmemmove_heap_before_end,tc)505 ATF_TC_HEAD(wmemmove_heap_before_end, tc)
506 {
507 }
ATF_TC_BODY(wmemmove_heap_before_end,tc)508 ATF_TC_BODY(wmemmove_heap_before_end, tc)
509 {
510 #define BUF __stack.__buf
511 struct {
512 uint8_t padding_l;
513 wchar_t * __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 wchar_t src[__len + 10];
520
521 __stack.__buf = malloc(__bufsz);
522
523 wmemmove(__stack.__buf, src, __len);
524 #undef BUF
525
526 }
527
528 ATF_TC(wmemmove_heap_end);
ATF_TC_HEAD(wmemmove_heap_end,tc)529 ATF_TC_HEAD(wmemmove_heap_end, tc)
530 {
531 }
ATF_TC_BODY(wmemmove_heap_end,tc)532 ATF_TC_BODY(wmemmove_heap_end, tc)
533 {
534 #define BUF __stack.__buf
535 struct {
536 uint8_t padding_l;
537 wchar_t * __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 wchar_t src[__len + 10];
544
545 __stack.__buf = malloc(__bufsz);
546
547 wmemmove(__stack.__buf, src, __len);
548 #undef BUF
549
550 }
551
552 ATF_TC(wmemmove_heap_after_end);
ATF_TC_HEAD(wmemmove_heap_after_end,tc)553 ATF_TC_HEAD(wmemmove_heap_after_end, tc)
554 {
555 }
ATF_TC_BODY(wmemmove_heap_after_end,tc)556 ATF_TC_BODY(wmemmove_heap_after_end, tc)
557 {
558 #define BUF __stack.__buf
559 struct {
560 uint8_t padding_l;
561 wchar_t * __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 wchar_t 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 wmemmove(__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(wmemset_before_end);
ATF_TC_HEAD(wmemset_before_end,tc)608 ATF_TC_HEAD(wmemset_before_end, tc)
609 {
610 }
ATF_TC_BODY(wmemset_before_end,tc)611 ATF_TC_BODY(wmemset_before_end, tc)
612 {
613 #define BUF &__stack.__buf
614 struct {
615 uint8_t padding_l;
616 wchar_t __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 wmemset(__stack.__buf, L'0', __len);
624 #undef BUF
625
626 }
627
628 ATF_TC(wmemset_end);
ATF_TC_HEAD(wmemset_end,tc)629 ATF_TC_HEAD(wmemset_end, tc)
630 {
631 }
ATF_TC_BODY(wmemset_end,tc)632 ATF_TC_BODY(wmemset_end, tc)
633 {
634 #define BUF &__stack.__buf
635 struct {
636 uint8_t padding_l;
637 wchar_t __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 wmemset(__stack.__buf, L'0', __len);
645 #undef BUF
646
647 }
648
649 ATF_TC(wmemset_heap_before_end);
ATF_TC_HEAD(wmemset_heap_before_end,tc)650 ATF_TC_HEAD(wmemset_heap_before_end, tc)
651 {
652 }
ATF_TC_BODY(wmemset_heap_before_end,tc)653 ATF_TC_BODY(wmemset_heap_before_end, tc)
654 {
655 #define BUF __stack.__buf
656 struct {
657 uint8_t padding_l;
658 wchar_t * __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 wmemset(__stack.__buf, L'0', __len);
668 #undef BUF
669
670 }
671
672 ATF_TC(wmemset_heap_end);
ATF_TC_HEAD(wmemset_heap_end,tc)673 ATF_TC_HEAD(wmemset_heap_end, tc)
674 {
675 }
ATF_TC_BODY(wmemset_heap_end,tc)676 ATF_TC_BODY(wmemset_heap_end, tc)
677 {
678 #define BUF __stack.__buf
679 struct {
680 uint8_t padding_l;
681 wchar_t * __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 wmemset(__stack.__buf, L'0', __len);
691 #undef BUF
692
693 }
694
695 ATF_TC(wmemset_heap_after_end);
ATF_TC_HEAD(wmemset_heap_after_end,tc)696 ATF_TC_HEAD(wmemset_heap_after_end, tc)
697 {
698 }
ATF_TC_BODY(wmemset_heap_after_end,tc)699 ATF_TC_BODY(wmemset_heap_after_end, tc)
700 {
701 #define BUF __stack.__buf
702 struct {
703 uint8_t padding_l;
704 wchar_t * __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 wmemset(__stack.__buf, L'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(wcpcpy_before_end);
ATF_TC_HEAD(wcpcpy_before_end,tc)750 ATF_TC_HEAD(wcpcpy_before_end, tc)
751 {
752 }
ATF_TC_BODY(wcpcpy_before_end,tc)753 ATF_TC_BODY(wcpcpy_before_end, tc)
754 {
755 #define BUF &__stack.__buf
756 struct {
757 uint8_t padding_l;
758 wchar_t __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 wchar_t src[__len];
765
766 wmemset(__stack.__buf, 0, __len);
767 wmemset(src, 'A', __len - 1);
768 src[__len - 1] = '\0';
769
770 wcpcpy(__stack.__buf, src);
771 #undef BUF
772
773 }
774
775 ATF_TC(wcpcpy_end);
ATF_TC_HEAD(wcpcpy_end,tc)776 ATF_TC_HEAD(wcpcpy_end, tc)
777 {
778 }
ATF_TC_BODY(wcpcpy_end,tc)779 ATF_TC_BODY(wcpcpy_end, tc)
780 {
781 #define BUF &__stack.__buf
782 struct {
783 uint8_t padding_l;
784 wchar_t __buf[42];
785 uint8_t padding_r;
786 } __stack;
787 const size_t __bufsz __unused = sizeof(__stack.__buf);
788 const size_t __len = 42;
789 const size_t __idx __unused = __len - 1;
790 wchar_t src[__len];
791
792 wmemset(__stack.__buf, 0, __len);
793 wmemset(src, 'A', __len - 1);
794 src[__len - 1] = '\0';
795
796 wcpcpy(__stack.__buf, src);
797 #undef BUF
798
799 }
800
801 ATF_TC(wcpcpy_heap_before_end);
ATF_TC_HEAD(wcpcpy_heap_before_end,tc)802 ATF_TC_HEAD(wcpcpy_heap_before_end, tc)
803 {
804 }
ATF_TC_BODY(wcpcpy_heap_before_end,tc)805 ATF_TC_BODY(wcpcpy_heap_before_end, tc)
806 {
807 #define BUF __stack.__buf
808 struct {
809 uint8_t padding_l;
810 wchar_t * __buf;
811 uint8_t padding_r;
812 } __stack;
813 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
814 const size_t __len = 42 - 1;
815 const size_t __idx __unused = __len - 1;
816 wchar_t src[__len];
817
818 __stack.__buf = malloc(__bufsz);
819 wmemset(__stack.__buf, 0, __len);
820 wmemset(src, 'A', __len - 1);
821 src[__len - 1] = '\0';
822
823 wcpcpy(__stack.__buf, src);
824 #undef BUF
825
826 }
827
828 ATF_TC(wcpcpy_heap_end);
ATF_TC_HEAD(wcpcpy_heap_end,tc)829 ATF_TC_HEAD(wcpcpy_heap_end, tc)
830 {
831 }
ATF_TC_BODY(wcpcpy_heap_end,tc)832 ATF_TC_BODY(wcpcpy_heap_end, tc)
833 {
834 #define BUF __stack.__buf
835 struct {
836 uint8_t padding_l;
837 wchar_t * __buf;
838 uint8_t padding_r;
839 } __stack;
840 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
841 const size_t __len = 42;
842 const size_t __idx __unused = __len - 1;
843 wchar_t src[__len];
844
845 __stack.__buf = malloc(__bufsz);
846 wmemset(__stack.__buf, 0, __len);
847 wmemset(src, 'A', __len - 1);
848 src[__len - 1] = '\0';
849
850 wcpcpy(__stack.__buf, src);
851 #undef BUF
852
853 }
854
855 ATF_TC(wcpcpy_heap_after_end);
ATF_TC_HEAD(wcpcpy_heap_after_end,tc)856 ATF_TC_HEAD(wcpcpy_heap_after_end, tc)
857 {
858 }
ATF_TC_BODY(wcpcpy_heap_after_end,tc)859 ATF_TC_BODY(wcpcpy_heap_after_end, tc)
860 {
861 #define BUF __stack.__buf
862 struct {
863 uint8_t padding_l;
864 wchar_t * __buf;
865 uint8_t padding_r;
866 } __stack;
867 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
868 const size_t __len = 42 + 1;
869 const size_t __idx __unused = __len - 1;
870 pid_t __child;
871 int __status;
872 wchar_t src[__len];
873
874 __child = fork();
875 ATF_REQUIRE(__child >= 0);
876 if (__child > 0)
877 goto monitor;
878
879 /* Child */
880 disable_coredumps();
881 __stack.__buf = malloc(__bufsz);
882 wmemset(__stack.__buf, 0, __len);
883 wmemset(src, 'A', __len - 1);
884 src[__len - 1] = '\0';
885
886 wcpcpy(__stack.__buf, src);
887 _exit(EX_SOFTWARE); /* Should have aborted. */
888
889 monitor:
890 while (waitpid(__child, &__status, 0) != __child) {
891 ATF_REQUIRE_EQ(EINTR, errno);
892 }
893
894 if (!WIFSIGNALED(__status)) {
895 switch (WEXITSTATUS(__status)) {
896 case EX_SOFTWARE:
897 atf_tc_fail("FORTIFY_SOURCE failed to abort");
898 break;
899 case EX_OSERR:
900 atf_tc_fail("setrlimit(2) failed");
901 break;
902 default:
903 atf_tc_fail("child exited with status %d",
904 WEXITSTATUS(__status));
905 }
906 } else {
907 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
908 }
909 #undef BUF
910
911 }
912
913 ATF_TC(wcpncpy_before_end);
ATF_TC_HEAD(wcpncpy_before_end,tc)914 ATF_TC_HEAD(wcpncpy_before_end, tc)
915 {
916 }
ATF_TC_BODY(wcpncpy_before_end,tc)917 ATF_TC_BODY(wcpncpy_before_end, tc)
918 {
919 #define BUF &__stack.__buf
920 struct {
921 uint8_t padding_l;
922 wchar_t __buf[42];
923 uint8_t padding_r;
924 } __stack;
925 const size_t __bufsz __unused = sizeof(__stack.__buf);
926 const size_t __len = 42 - 1;
927 const size_t __idx __unused = __len - 1;
928 wchar_t src[__len];
929
930 wmemset(__stack.__buf, 0, __len);
931 wmemset(src, 'A', __len - 1);
932 src[__len - 1] = '\0';
933
934 wcpncpy(__stack.__buf, src, __len);
935 #undef BUF
936
937 }
938
939 ATF_TC(wcpncpy_end);
ATF_TC_HEAD(wcpncpy_end,tc)940 ATF_TC_HEAD(wcpncpy_end, tc)
941 {
942 }
ATF_TC_BODY(wcpncpy_end,tc)943 ATF_TC_BODY(wcpncpy_end, tc)
944 {
945 #define BUF &__stack.__buf
946 struct {
947 uint8_t padding_l;
948 wchar_t __buf[42];
949 uint8_t padding_r;
950 } __stack;
951 const size_t __bufsz __unused = sizeof(__stack.__buf);
952 const size_t __len = 42;
953 const size_t __idx __unused = __len - 1;
954 wchar_t src[__len];
955
956 wmemset(__stack.__buf, 0, __len);
957 wmemset(src, 'A', __len - 1);
958 src[__len - 1] = '\0';
959
960 wcpncpy(__stack.__buf, src, __len);
961 #undef BUF
962
963 }
964
965 ATF_TC(wcpncpy_heap_before_end);
ATF_TC_HEAD(wcpncpy_heap_before_end,tc)966 ATF_TC_HEAD(wcpncpy_heap_before_end, tc)
967 {
968 }
ATF_TC_BODY(wcpncpy_heap_before_end,tc)969 ATF_TC_BODY(wcpncpy_heap_before_end, tc)
970 {
971 #define BUF __stack.__buf
972 struct {
973 uint8_t padding_l;
974 wchar_t * __buf;
975 uint8_t padding_r;
976 } __stack;
977 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
978 const size_t __len = 42 - 1;
979 const size_t __idx __unused = __len - 1;
980 wchar_t src[__len];
981
982 __stack.__buf = malloc(__bufsz);
983 wmemset(__stack.__buf, 0, __len);
984 wmemset(src, 'A', __len - 1);
985 src[__len - 1] = '\0';
986
987 wcpncpy(__stack.__buf, src, __len);
988 #undef BUF
989
990 }
991
992 ATF_TC(wcpncpy_heap_end);
ATF_TC_HEAD(wcpncpy_heap_end,tc)993 ATF_TC_HEAD(wcpncpy_heap_end, tc)
994 {
995 }
ATF_TC_BODY(wcpncpy_heap_end,tc)996 ATF_TC_BODY(wcpncpy_heap_end, tc)
997 {
998 #define BUF __stack.__buf
999 struct {
1000 uint8_t padding_l;
1001 wchar_t * __buf;
1002 uint8_t padding_r;
1003 } __stack;
1004 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1005 const size_t __len = 42;
1006 const size_t __idx __unused = __len - 1;
1007 wchar_t src[__len];
1008
1009 __stack.__buf = malloc(__bufsz);
1010 wmemset(__stack.__buf, 0, __len);
1011 wmemset(src, 'A', __len - 1);
1012 src[__len - 1] = '\0';
1013
1014 wcpncpy(__stack.__buf, src, __len);
1015 #undef BUF
1016
1017 }
1018
1019 ATF_TC(wcpncpy_heap_after_end);
ATF_TC_HEAD(wcpncpy_heap_after_end,tc)1020 ATF_TC_HEAD(wcpncpy_heap_after_end, tc)
1021 {
1022 }
ATF_TC_BODY(wcpncpy_heap_after_end,tc)1023 ATF_TC_BODY(wcpncpy_heap_after_end, tc)
1024 {
1025 #define BUF __stack.__buf
1026 struct {
1027 uint8_t padding_l;
1028 wchar_t * __buf;
1029 uint8_t padding_r;
1030 } __stack;
1031 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1032 const size_t __len = 42 + 1;
1033 const size_t __idx __unused = __len - 1;
1034 pid_t __child;
1035 int __status;
1036 wchar_t src[__len];
1037
1038 __child = fork();
1039 ATF_REQUIRE(__child >= 0);
1040 if (__child > 0)
1041 goto monitor;
1042
1043 /* Child */
1044 disable_coredumps();
1045 __stack.__buf = malloc(__bufsz);
1046 wmemset(__stack.__buf, 0, __len);
1047 wmemset(src, 'A', __len - 1);
1048 src[__len - 1] = '\0';
1049
1050 wcpncpy(__stack.__buf, src, __len);
1051 _exit(EX_SOFTWARE); /* Should have aborted. */
1052
1053 monitor:
1054 while (waitpid(__child, &__status, 0) != __child) {
1055 ATF_REQUIRE_EQ(EINTR, errno);
1056 }
1057
1058 if (!WIFSIGNALED(__status)) {
1059 switch (WEXITSTATUS(__status)) {
1060 case EX_SOFTWARE:
1061 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1062 break;
1063 case EX_OSERR:
1064 atf_tc_fail("setrlimit(2) failed");
1065 break;
1066 default:
1067 atf_tc_fail("child exited with status %d",
1068 WEXITSTATUS(__status));
1069 }
1070 } else {
1071 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1072 }
1073 #undef BUF
1074
1075 }
1076
1077 ATF_TC(wcscat_before_end);
ATF_TC_HEAD(wcscat_before_end,tc)1078 ATF_TC_HEAD(wcscat_before_end, tc)
1079 {
1080 }
ATF_TC_BODY(wcscat_before_end,tc)1081 ATF_TC_BODY(wcscat_before_end, tc)
1082 {
1083 #define BUF &__stack.__buf
1084 struct {
1085 uint8_t padding_l;
1086 wchar_t __buf[42];
1087 uint8_t padding_r;
1088 } __stack;
1089 const size_t __bufsz __unused = sizeof(__stack.__buf);
1090 const size_t __len = 42 - 1;
1091 const size_t __idx __unused = __len - 1;
1092 wchar_t src[__len];
1093
1094 wmemset(__stack.__buf, 0, __len);
1095 wmemset(src, 'A', __len - 1);
1096 src[__len - 1] = '\0';
1097
1098 wcscat(__stack.__buf, src);
1099 #undef BUF
1100
1101 }
1102
1103 ATF_TC(wcscat_end);
ATF_TC_HEAD(wcscat_end,tc)1104 ATF_TC_HEAD(wcscat_end, tc)
1105 {
1106 }
ATF_TC_BODY(wcscat_end,tc)1107 ATF_TC_BODY(wcscat_end, tc)
1108 {
1109 #define BUF &__stack.__buf
1110 struct {
1111 uint8_t padding_l;
1112 wchar_t __buf[42];
1113 uint8_t padding_r;
1114 } __stack;
1115 const size_t __bufsz __unused = sizeof(__stack.__buf);
1116 const size_t __len = 42;
1117 const size_t __idx __unused = __len - 1;
1118 wchar_t src[__len];
1119
1120 wmemset(__stack.__buf, 0, __len);
1121 wmemset(src, 'A', __len - 1);
1122 src[__len - 1] = '\0';
1123
1124 wcscat(__stack.__buf, src);
1125 #undef BUF
1126
1127 }
1128
1129 ATF_TC(wcscat_heap_before_end);
ATF_TC_HEAD(wcscat_heap_before_end,tc)1130 ATF_TC_HEAD(wcscat_heap_before_end, tc)
1131 {
1132 }
ATF_TC_BODY(wcscat_heap_before_end,tc)1133 ATF_TC_BODY(wcscat_heap_before_end, tc)
1134 {
1135 #define BUF __stack.__buf
1136 struct {
1137 uint8_t padding_l;
1138 wchar_t * __buf;
1139 uint8_t padding_r;
1140 } __stack;
1141 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1142 const size_t __len = 42 - 1;
1143 const size_t __idx __unused = __len - 1;
1144 wchar_t src[__len];
1145
1146 __stack.__buf = malloc(__bufsz);
1147 wmemset(__stack.__buf, 0, __len);
1148 wmemset(src, 'A', __len - 1);
1149 src[__len - 1] = '\0';
1150
1151 wcscat(__stack.__buf, src);
1152 #undef BUF
1153
1154 }
1155
1156 ATF_TC(wcscat_heap_end);
ATF_TC_HEAD(wcscat_heap_end,tc)1157 ATF_TC_HEAD(wcscat_heap_end, tc)
1158 {
1159 }
ATF_TC_BODY(wcscat_heap_end,tc)1160 ATF_TC_BODY(wcscat_heap_end, tc)
1161 {
1162 #define BUF __stack.__buf
1163 struct {
1164 uint8_t padding_l;
1165 wchar_t * __buf;
1166 uint8_t padding_r;
1167 } __stack;
1168 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1169 const size_t __len = 42;
1170 const size_t __idx __unused = __len - 1;
1171 wchar_t src[__len];
1172
1173 __stack.__buf = malloc(__bufsz);
1174 wmemset(__stack.__buf, 0, __len);
1175 wmemset(src, 'A', __len - 1);
1176 src[__len - 1] = '\0';
1177
1178 wcscat(__stack.__buf, src);
1179 #undef BUF
1180
1181 }
1182
1183 ATF_TC(wcscat_heap_after_end);
ATF_TC_HEAD(wcscat_heap_after_end,tc)1184 ATF_TC_HEAD(wcscat_heap_after_end, tc)
1185 {
1186 }
ATF_TC_BODY(wcscat_heap_after_end,tc)1187 ATF_TC_BODY(wcscat_heap_after_end, tc)
1188 {
1189 #define BUF __stack.__buf
1190 struct {
1191 uint8_t padding_l;
1192 wchar_t * __buf;
1193 uint8_t padding_r;
1194 } __stack;
1195 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1196 const size_t __len = 42 + 1;
1197 const size_t __idx __unused = __len - 1;
1198 pid_t __child;
1199 int __status;
1200 wchar_t src[__len];
1201
1202 __child = fork();
1203 ATF_REQUIRE(__child >= 0);
1204 if (__child > 0)
1205 goto monitor;
1206
1207 /* Child */
1208 disable_coredumps();
1209 __stack.__buf = malloc(__bufsz);
1210 wmemset(__stack.__buf, 0, __len);
1211 wmemset(src, 'A', __len - 1);
1212 src[__len - 1] = '\0';
1213
1214 wcscat(__stack.__buf, src);
1215 _exit(EX_SOFTWARE); /* Should have aborted. */
1216
1217 monitor:
1218 while (waitpid(__child, &__status, 0) != __child) {
1219 ATF_REQUIRE_EQ(EINTR, errno);
1220 }
1221
1222 if (!WIFSIGNALED(__status)) {
1223 switch (WEXITSTATUS(__status)) {
1224 case EX_SOFTWARE:
1225 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1226 break;
1227 case EX_OSERR:
1228 atf_tc_fail("setrlimit(2) failed");
1229 break;
1230 default:
1231 atf_tc_fail("child exited with status %d",
1232 WEXITSTATUS(__status));
1233 }
1234 } else {
1235 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1236 }
1237 #undef BUF
1238
1239 }
1240
1241 ATF_TC(wcslcat_before_end);
ATF_TC_HEAD(wcslcat_before_end,tc)1242 ATF_TC_HEAD(wcslcat_before_end, tc)
1243 {
1244 }
ATF_TC_BODY(wcslcat_before_end,tc)1245 ATF_TC_BODY(wcslcat_before_end, tc)
1246 {
1247 #define BUF &__stack.__buf
1248 struct {
1249 uint8_t padding_l;
1250 wchar_t __buf[42];
1251 uint8_t padding_r;
1252 } __stack;
1253 const size_t __bufsz __unused = sizeof(__stack.__buf);
1254 const size_t __len = 42 - 1;
1255 const size_t __idx __unused = __len - 1;
1256 wchar_t src[__len];
1257
1258 wmemset(__stack.__buf, 0, __len);
1259 wmemset(src, 'A', __len - 1);
1260 src[__len - 1] = '\0';
1261
1262 wcslcat(__stack.__buf, src, __len);
1263 #undef BUF
1264
1265 }
1266
1267 ATF_TC(wcslcat_end);
ATF_TC_HEAD(wcslcat_end,tc)1268 ATF_TC_HEAD(wcslcat_end, tc)
1269 {
1270 }
ATF_TC_BODY(wcslcat_end,tc)1271 ATF_TC_BODY(wcslcat_end, tc)
1272 {
1273 #define BUF &__stack.__buf
1274 struct {
1275 uint8_t padding_l;
1276 wchar_t __buf[42];
1277 uint8_t padding_r;
1278 } __stack;
1279 const size_t __bufsz __unused = sizeof(__stack.__buf);
1280 const size_t __len = 42;
1281 const size_t __idx __unused = __len - 1;
1282 wchar_t src[__len];
1283
1284 wmemset(__stack.__buf, 0, __len);
1285 wmemset(src, 'A', __len - 1);
1286 src[__len - 1] = '\0';
1287
1288 wcslcat(__stack.__buf, src, __len);
1289 #undef BUF
1290
1291 }
1292
1293 ATF_TC(wcslcat_heap_before_end);
ATF_TC_HEAD(wcslcat_heap_before_end,tc)1294 ATF_TC_HEAD(wcslcat_heap_before_end, tc)
1295 {
1296 }
ATF_TC_BODY(wcslcat_heap_before_end,tc)1297 ATF_TC_BODY(wcslcat_heap_before_end, tc)
1298 {
1299 #define BUF __stack.__buf
1300 struct {
1301 uint8_t padding_l;
1302 wchar_t * __buf;
1303 uint8_t padding_r;
1304 } __stack;
1305 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1306 const size_t __len = 42 - 1;
1307 const size_t __idx __unused = __len - 1;
1308 wchar_t src[__len];
1309
1310 __stack.__buf = malloc(__bufsz);
1311 wmemset(__stack.__buf, 0, __len);
1312 wmemset(src, 'A', __len - 1);
1313 src[__len - 1] = '\0';
1314
1315 wcslcat(__stack.__buf, src, __len);
1316 #undef BUF
1317
1318 }
1319
1320 ATF_TC(wcslcat_heap_end);
ATF_TC_HEAD(wcslcat_heap_end,tc)1321 ATF_TC_HEAD(wcslcat_heap_end, tc)
1322 {
1323 }
ATF_TC_BODY(wcslcat_heap_end,tc)1324 ATF_TC_BODY(wcslcat_heap_end, tc)
1325 {
1326 #define BUF __stack.__buf
1327 struct {
1328 uint8_t padding_l;
1329 wchar_t * __buf;
1330 uint8_t padding_r;
1331 } __stack;
1332 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1333 const size_t __len = 42;
1334 const size_t __idx __unused = __len - 1;
1335 wchar_t src[__len];
1336
1337 __stack.__buf = malloc(__bufsz);
1338 wmemset(__stack.__buf, 0, __len);
1339 wmemset(src, 'A', __len - 1);
1340 src[__len - 1] = '\0';
1341
1342 wcslcat(__stack.__buf, src, __len);
1343 #undef BUF
1344
1345 }
1346
1347 ATF_TC(wcslcat_heap_after_end);
ATF_TC_HEAD(wcslcat_heap_after_end,tc)1348 ATF_TC_HEAD(wcslcat_heap_after_end, tc)
1349 {
1350 }
ATF_TC_BODY(wcslcat_heap_after_end,tc)1351 ATF_TC_BODY(wcslcat_heap_after_end, tc)
1352 {
1353 #define BUF __stack.__buf
1354 struct {
1355 uint8_t padding_l;
1356 wchar_t * __buf;
1357 uint8_t padding_r;
1358 } __stack;
1359 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1360 const size_t __len = 42 + 1;
1361 const size_t __idx __unused = __len - 1;
1362 pid_t __child;
1363 int __status;
1364 wchar_t src[__len];
1365
1366 __child = fork();
1367 ATF_REQUIRE(__child >= 0);
1368 if (__child > 0)
1369 goto monitor;
1370
1371 /* Child */
1372 disable_coredumps();
1373 __stack.__buf = malloc(__bufsz);
1374 wmemset(__stack.__buf, 0, __len);
1375 wmemset(src, 'A', __len - 1);
1376 src[__len - 1] = '\0';
1377
1378 wcslcat(__stack.__buf, src, __len);
1379 _exit(EX_SOFTWARE); /* Should have aborted. */
1380
1381 monitor:
1382 while (waitpid(__child, &__status, 0) != __child) {
1383 ATF_REQUIRE_EQ(EINTR, errno);
1384 }
1385
1386 if (!WIFSIGNALED(__status)) {
1387 switch (WEXITSTATUS(__status)) {
1388 case EX_SOFTWARE:
1389 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1390 break;
1391 case EX_OSERR:
1392 atf_tc_fail("setrlimit(2) failed");
1393 break;
1394 default:
1395 atf_tc_fail("child exited with status %d",
1396 WEXITSTATUS(__status));
1397 }
1398 } else {
1399 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1400 }
1401 #undef BUF
1402
1403 }
1404
1405 ATF_TC(wcsncat_before_end);
ATF_TC_HEAD(wcsncat_before_end,tc)1406 ATF_TC_HEAD(wcsncat_before_end, tc)
1407 {
1408 }
ATF_TC_BODY(wcsncat_before_end,tc)1409 ATF_TC_BODY(wcsncat_before_end, tc)
1410 {
1411 #define BUF &__stack.__buf
1412 struct {
1413 uint8_t padding_l;
1414 wchar_t __buf[42];
1415 uint8_t padding_r;
1416 } __stack;
1417 const size_t __bufsz __unused = sizeof(__stack.__buf);
1418 const size_t __len = 42 - 1;
1419 const size_t __idx __unused = __len - 1;
1420 wchar_t src[__len];
1421
1422 wmemset(__stack.__buf, 0, __len);
1423 wmemset(src, 'A', __len - 1);
1424 src[__len - 1] = '\0';
1425
1426 wcsncat(__stack.__buf, src, __len);
1427 #undef BUF
1428
1429 }
1430
1431 ATF_TC(wcsncat_end);
ATF_TC_HEAD(wcsncat_end,tc)1432 ATF_TC_HEAD(wcsncat_end, tc)
1433 {
1434 }
ATF_TC_BODY(wcsncat_end,tc)1435 ATF_TC_BODY(wcsncat_end, tc)
1436 {
1437 #define BUF &__stack.__buf
1438 struct {
1439 uint8_t padding_l;
1440 wchar_t __buf[42];
1441 uint8_t padding_r;
1442 } __stack;
1443 const size_t __bufsz __unused = sizeof(__stack.__buf);
1444 const size_t __len = 42;
1445 const size_t __idx __unused = __len - 1;
1446 wchar_t src[__len];
1447
1448 wmemset(__stack.__buf, 0, __len);
1449 wmemset(src, 'A', __len - 1);
1450 src[__len - 1] = '\0';
1451
1452 wcsncat(__stack.__buf, src, __len);
1453 #undef BUF
1454
1455 }
1456
1457 ATF_TC(wcsncat_heap_before_end);
ATF_TC_HEAD(wcsncat_heap_before_end,tc)1458 ATF_TC_HEAD(wcsncat_heap_before_end, tc)
1459 {
1460 }
ATF_TC_BODY(wcsncat_heap_before_end,tc)1461 ATF_TC_BODY(wcsncat_heap_before_end, tc)
1462 {
1463 #define BUF __stack.__buf
1464 struct {
1465 uint8_t padding_l;
1466 wchar_t * __buf;
1467 uint8_t padding_r;
1468 } __stack;
1469 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1470 const size_t __len = 42 - 1;
1471 const size_t __idx __unused = __len - 1;
1472 wchar_t src[__len];
1473
1474 __stack.__buf = malloc(__bufsz);
1475 wmemset(__stack.__buf, 0, __len);
1476 wmemset(src, 'A', __len - 1);
1477 src[__len - 1] = '\0';
1478
1479 wcsncat(__stack.__buf, src, __len);
1480 #undef BUF
1481
1482 }
1483
1484 ATF_TC(wcsncat_heap_end);
ATF_TC_HEAD(wcsncat_heap_end,tc)1485 ATF_TC_HEAD(wcsncat_heap_end, tc)
1486 {
1487 }
ATF_TC_BODY(wcsncat_heap_end,tc)1488 ATF_TC_BODY(wcsncat_heap_end, tc)
1489 {
1490 #define BUF __stack.__buf
1491 struct {
1492 uint8_t padding_l;
1493 wchar_t * __buf;
1494 uint8_t padding_r;
1495 } __stack;
1496 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1497 const size_t __len = 42;
1498 const size_t __idx __unused = __len - 1;
1499 wchar_t src[__len];
1500
1501 __stack.__buf = malloc(__bufsz);
1502 wmemset(__stack.__buf, 0, __len);
1503 wmemset(src, 'A', __len - 1);
1504 src[__len - 1] = '\0';
1505
1506 wcsncat(__stack.__buf, src, __len);
1507 #undef BUF
1508
1509 }
1510
1511 ATF_TC(wcsncat_heap_after_end);
ATF_TC_HEAD(wcsncat_heap_after_end,tc)1512 ATF_TC_HEAD(wcsncat_heap_after_end, tc)
1513 {
1514 }
ATF_TC_BODY(wcsncat_heap_after_end,tc)1515 ATF_TC_BODY(wcsncat_heap_after_end, tc)
1516 {
1517 #define BUF __stack.__buf
1518 struct {
1519 uint8_t padding_l;
1520 wchar_t * __buf;
1521 uint8_t padding_r;
1522 } __stack;
1523 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1524 const size_t __len = 42 + 1;
1525 const size_t __idx __unused = __len - 1;
1526 pid_t __child;
1527 int __status;
1528 wchar_t src[__len];
1529
1530 __child = fork();
1531 ATF_REQUIRE(__child >= 0);
1532 if (__child > 0)
1533 goto monitor;
1534
1535 /* Child */
1536 disable_coredumps();
1537 __stack.__buf = malloc(__bufsz);
1538 wmemset(__stack.__buf, 0, __len);
1539 wmemset(src, 'A', __len - 1);
1540 src[__len - 1] = '\0';
1541
1542 wcsncat(__stack.__buf, src, __len);
1543 _exit(EX_SOFTWARE); /* Should have aborted. */
1544
1545 monitor:
1546 while (waitpid(__child, &__status, 0) != __child) {
1547 ATF_REQUIRE_EQ(EINTR, errno);
1548 }
1549
1550 if (!WIFSIGNALED(__status)) {
1551 switch (WEXITSTATUS(__status)) {
1552 case EX_SOFTWARE:
1553 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1554 break;
1555 case EX_OSERR:
1556 atf_tc_fail("setrlimit(2) failed");
1557 break;
1558 default:
1559 atf_tc_fail("child exited with status %d",
1560 WEXITSTATUS(__status));
1561 }
1562 } else {
1563 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1564 }
1565 #undef BUF
1566
1567 }
1568
1569 ATF_TC(wcscpy_before_end);
ATF_TC_HEAD(wcscpy_before_end,tc)1570 ATF_TC_HEAD(wcscpy_before_end, tc)
1571 {
1572 }
ATF_TC_BODY(wcscpy_before_end,tc)1573 ATF_TC_BODY(wcscpy_before_end, tc)
1574 {
1575 #define BUF &__stack.__buf
1576 struct {
1577 uint8_t padding_l;
1578 wchar_t __buf[42];
1579 uint8_t padding_r;
1580 } __stack;
1581 const size_t __bufsz __unused = sizeof(__stack.__buf);
1582 const size_t __len = 42 - 1;
1583 const size_t __idx __unused = __len - 1;
1584 wchar_t src[__len];
1585
1586 wmemset(__stack.__buf, 0, __len);
1587 wmemset(src, 'A', __len - 1);
1588 src[__len - 1] = '\0';
1589
1590 wcscpy(__stack.__buf, src);
1591 #undef BUF
1592
1593 }
1594
1595 ATF_TC(wcscpy_end);
ATF_TC_HEAD(wcscpy_end,tc)1596 ATF_TC_HEAD(wcscpy_end, tc)
1597 {
1598 }
ATF_TC_BODY(wcscpy_end,tc)1599 ATF_TC_BODY(wcscpy_end, tc)
1600 {
1601 #define BUF &__stack.__buf
1602 struct {
1603 uint8_t padding_l;
1604 wchar_t __buf[42];
1605 uint8_t padding_r;
1606 } __stack;
1607 const size_t __bufsz __unused = sizeof(__stack.__buf);
1608 const size_t __len = 42;
1609 const size_t __idx __unused = __len - 1;
1610 wchar_t src[__len];
1611
1612 wmemset(__stack.__buf, 0, __len);
1613 wmemset(src, 'A', __len - 1);
1614 src[__len - 1] = '\0';
1615
1616 wcscpy(__stack.__buf, src);
1617 #undef BUF
1618
1619 }
1620
1621 ATF_TC(wcscpy_heap_before_end);
ATF_TC_HEAD(wcscpy_heap_before_end,tc)1622 ATF_TC_HEAD(wcscpy_heap_before_end, tc)
1623 {
1624 }
ATF_TC_BODY(wcscpy_heap_before_end,tc)1625 ATF_TC_BODY(wcscpy_heap_before_end, tc)
1626 {
1627 #define BUF __stack.__buf
1628 struct {
1629 uint8_t padding_l;
1630 wchar_t * __buf;
1631 uint8_t padding_r;
1632 } __stack;
1633 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1634 const size_t __len = 42 - 1;
1635 const size_t __idx __unused = __len - 1;
1636 wchar_t src[__len];
1637
1638 __stack.__buf = malloc(__bufsz);
1639 wmemset(__stack.__buf, 0, __len);
1640 wmemset(src, 'A', __len - 1);
1641 src[__len - 1] = '\0';
1642
1643 wcscpy(__stack.__buf, src);
1644 #undef BUF
1645
1646 }
1647
1648 ATF_TC(wcscpy_heap_end);
ATF_TC_HEAD(wcscpy_heap_end,tc)1649 ATF_TC_HEAD(wcscpy_heap_end, tc)
1650 {
1651 }
ATF_TC_BODY(wcscpy_heap_end,tc)1652 ATF_TC_BODY(wcscpy_heap_end, tc)
1653 {
1654 #define BUF __stack.__buf
1655 struct {
1656 uint8_t padding_l;
1657 wchar_t * __buf;
1658 uint8_t padding_r;
1659 } __stack;
1660 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1661 const size_t __len = 42;
1662 const size_t __idx __unused = __len - 1;
1663 wchar_t src[__len];
1664
1665 __stack.__buf = malloc(__bufsz);
1666 wmemset(__stack.__buf, 0, __len);
1667 wmemset(src, 'A', __len - 1);
1668 src[__len - 1] = '\0';
1669
1670 wcscpy(__stack.__buf, src);
1671 #undef BUF
1672
1673 }
1674
1675 ATF_TC(wcscpy_heap_after_end);
ATF_TC_HEAD(wcscpy_heap_after_end,tc)1676 ATF_TC_HEAD(wcscpy_heap_after_end, tc)
1677 {
1678 }
ATF_TC_BODY(wcscpy_heap_after_end,tc)1679 ATF_TC_BODY(wcscpy_heap_after_end, tc)
1680 {
1681 #define BUF __stack.__buf
1682 struct {
1683 uint8_t padding_l;
1684 wchar_t * __buf;
1685 uint8_t padding_r;
1686 } __stack;
1687 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1688 const size_t __len = 42 + 1;
1689 const size_t __idx __unused = __len - 1;
1690 pid_t __child;
1691 int __status;
1692 wchar_t src[__len];
1693
1694 __child = fork();
1695 ATF_REQUIRE(__child >= 0);
1696 if (__child > 0)
1697 goto monitor;
1698
1699 /* Child */
1700 disable_coredumps();
1701 __stack.__buf = malloc(__bufsz);
1702 wmemset(__stack.__buf, 0, __len);
1703 wmemset(src, 'A', __len - 1);
1704 src[__len - 1] = '\0';
1705
1706 wcscpy(__stack.__buf, src);
1707 _exit(EX_SOFTWARE); /* Should have aborted. */
1708
1709 monitor:
1710 while (waitpid(__child, &__status, 0) != __child) {
1711 ATF_REQUIRE_EQ(EINTR, errno);
1712 }
1713
1714 if (!WIFSIGNALED(__status)) {
1715 switch (WEXITSTATUS(__status)) {
1716 case EX_SOFTWARE:
1717 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1718 break;
1719 case EX_OSERR:
1720 atf_tc_fail("setrlimit(2) failed");
1721 break;
1722 default:
1723 atf_tc_fail("child exited with status %d",
1724 WEXITSTATUS(__status));
1725 }
1726 } else {
1727 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1728 }
1729 #undef BUF
1730
1731 }
1732
1733 ATF_TC(wcslcpy_before_end);
ATF_TC_HEAD(wcslcpy_before_end,tc)1734 ATF_TC_HEAD(wcslcpy_before_end, tc)
1735 {
1736 }
ATF_TC_BODY(wcslcpy_before_end,tc)1737 ATF_TC_BODY(wcslcpy_before_end, tc)
1738 {
1739 #define BUF &__stack.__buf
1740 struct {
1741 uint8_t padding_l;
1742 wchar_t __buf[42];
1743 uint8_t padding_r;
1744 } __stack;
1745 const size_t __bufsz __unused = sizeof(__stack.__buf);
1746 const size_t __len = 42 - 1;
1747 const size_t __idx __unused = __len - 1;
1748 wchar_t src[__len];
1749
1750 wmemset(__stack.__buf, 0, __len);
1751 wmemset(src, 'A', __len - 1);
1752 src[__len - 1] = '\0';
1753
1754 wcslcpy(__stack.__buf, src, __len);
1755 #undef BUF
1756
1757 }
1758
1759 ATF_TC(wcslcpy_end);
ATF_TC_HEAD(wcslcpy_end,tc)1760 ATF_TC_HEAD(wcslcpy_end, tc)
1761 {
1762 }
ATF_TC_BODY(wcslcpy_end,tc)1763 ATF_TC_BODY(wcslcpy_end, tc)
1764 {
1765 #define BUF &__stack.__buf
1766 struct {
1767 uint8_t padding_l;
1768 wchar_t __buf[42];
1769 uint8_t padding_r;
1770 } __stack;
1771 const size_t __bufsz __unused = sizeof(__stack.__buf);
1772 const size_t __len = 42;
1773 const size_t __idx __unused = __len - 1;
1774 wchar_t src[__len];
1775
1776 wmemset(__stack.__buf, 0, __len);
1777 wmemset(src, 'A', __len - 1);
1778 src[__len - 1] = '\0';
1779
1780 wcslcpy(__stack.__buf, src, __len);
1781 #undef BUF
1782
1783 }
1784
1785 ATF_TC(wcslcpy_heap_before_end);
ATF_TC_HEAD(wcslcpy_heap_before_end,tc)1786 ATF_TC_HEAD(wcslcpy_heap_before_end, tc)
1787 {
1788 }
ATF_TC_BODY(wcslcpy_heap_before_end,tc)1789 ATF_TC_BODY(wcslcpy_heap_before_end, tc)
1790 {
1791 #define BUF __stack.__buf
1792 struct {
1793 uint8_t padding_l;
1794 wchar_t * __buf;
1795 uint8_t padding_r;
1796 } __stack;
1797 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1798 const size_t __len = 42 - 1;
1799 const size_t __idx __unused = __len - 1;
1800 wchar_t src[__len];
1801
1802 __stack.__buf = malloc(__bufsz);
1803 wmemset(__stack.__buf, 0, __len);
1804 wmemset(src, 'A', __len - 1);
1805 src[__len - 1] = '\0';
1806
1807 wcslcpy(__stack.__buf, src, __len);
1808 #undef BUF
1809
1810 }
1811
1812 ATF_TC(wcslcpy_heap_end);
ATF_TC_HEAD(wcslcpy_heap_end,tc)1813 ATF_TC_HEAD(wcslcpy_heap_end, tc)
1814 {
1815 }
ATF_TC_BODY(wcslcpy_heap_end,tc)1816 ATF_TC_BODY(wcslcpy_heap_end, tc)
1817 {
1818 #define BUF __stack.__buf
1819 struct {
1820 uint8_t padding_l;
1821 wchar_t * __buf;
1822 uint8_t padding_r;
1823 } __stack;
1824 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1825 const size_t __len = 42;
1826 const size_t __idx __unused = __len - 1;
1827 wchar_t src[__len];
1828
1829 __stack.__buf = malloc(__bufsz);
1830 wmemset(__stack.__buf, 0, __len);
1831 wmemset(src, 'A', __len - 1);
1832 src[__len - 1] = '\0';
1833
1834 wcslcpy(__stack.__buf, src, __len);
1835 #undef BUF
1836
1837 }
1838
1839 ATF_TC(wcslcpy_heap_after_end);
ATF_TC_HEAD(wcslcpy_heap_after_end,tc)1840 ATF_TC_HEAD(wcslcpy_heap_after_end, tc)
1841 {
1842 }
ATF_TC_BODY(wcslcpy_heap_after_end,tc)1843 ATF_TC_BODY(wcslcpy_heap_after_end, tc)
1844 {
1845 #define BUF __stack.__buf
1846 struct {
1847 uint8_t padding_l;
1848 wchar_t * __buf;
1849 uint8_t padding_r;
1850 } __stack;
1851 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1852 const size_t __len = 42 + 1;
1853 const size_t __idx __unused = __len - 1;
1854 pid_t __child;
1855 int __status;
1856 wchar_t src[__len];
1857
1858 __child = fork();
1859 ATF_REQUIRE(__child >= 0);
1860 if (__child > 0)
1861 goto monitor;
1862
1863 /* Child */
1864 disable_coredumps();
1865 __stack.__buf = malloc(__bufsz);
1866 wmemset(__stack.__buf, 0, __len);
1867 wmemset(src, 'A', __len - 1);
1868 src[__len - 1] = '\0';
1869
1870 wcslcpy(__stack.__buf, src, __len);
1871 _exit(EX_SOFTWARE); /* Should have aborted. */
1872
1873 monitor:
1874 while (waitpid(__child, &__status, 0) != __child) {
1875 ATF_REQUIRE_EQ(EINTR, errno);
1876 }
1877
1878 if (!WIFSIGNALED(__status)) {
1879 switch (WEXITSTATUS(__status)) {
1880 case EX_SOFTWARE:
1881 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1882 break;
1883 case EX_OSERR:
1884 atf_tc_fail("setrlimit(2) failed");
1885 break;
1886 default:
1887 atf_tc_fail("child exited with status %d",
1888 WEXITSTATUS(__status));
1889 }
1890 } else {
1891 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1892 }
1893 #undef BUF
1894
1895 }
1896
1897 ATF_TC(wcsncpy_before_end);
ATF_TC_HEAD(wcsncpy_before_end,tc)1898 ATF_TC_HEAD(wcsncpy_before_end, tc)
1899 {
1900 }
ATF_TC_BODY(wcsncpy_before_end,tc)1901 ATF_TC_BODY(wcsncpy_before_end, tc)
1902 {
1903 #define BUF &__stack.__buf
1904 struct {
1905 uint8_t padding_l;
1906 wchar_t __buf[42];
1907 uint8_t padding_r;
1908 } __stack;
1909 const size_t __bufsz __unused = sizeof(__stack.__buf);
1910 const size_t __len = 42 - 1;
1911 const size_t __idx __unused = __len - 1;
1912 wchar_t src[__len];
1913
1914 wmemset(__stack.__buf, 0, __len);
1915 wmemset(src, 'A', __len - 1);
1916 src[__len - 1] = '\0';
1917
1918 wcsncpy(__stack.__buf, src, __len);
1919 #undef BUF
1920
1921 }
1922
1923 ATF_TC(wcsncpy_end);
ATF_TC_HEAD(wcsncpy_end,tc)1924 ATF_TC_HEAD(wcsncpy_end, tc)
1925 {
1926 }
ATF_TC_BODY(wcsncpy_end,tc)1927 ATF_TC_BODY(wcsncpy_end, tc)
1928 {
1929 #define BUF &__stack.__buf
1930 struct {
1931 uint8_t padding_l;
1932 wchar_t __buf[42];
1933 uint8_t padding_r;
1934 } __stack;
1935 const size_t __bufsz __unused = sizeof(__stack.__buf);
1936 const size_t __len = 42;
1937 const size_t __idx __unused = __len - 1;
1938 wchar_t src[__len];
1939
1940 wmemset(__stack.__buf, 0, __len);
1941 wmemset(src, 'A', __len - 1);
1942 src[__len - 1] = '\0';
1943
1944 wcsncpy(__stack.__buf, src, __len);
1945 #undef BUF
1946
1947 }
1948
1949 ATF_TC(wcsncpy_heap_before_end);
ATF_TC_HEAD(wcsncpy_heap_before_end,tc)1950 ATF_TC_HEAD(wcsncpy_heap_before_end, tc)
1951 {
1952 }
ATF_TC_BODY(wcsncpy_heap_before_end,tc)1953 ATF_TC_BODY(wcsncpy_heap_before_end, tc)
1954 {
1955 #define BUF __stack.__buf
1956 struct {
1957 uint8_t padding_l;
1958 wchar_t * __buf;
1959 uint8_t padding_r;
1960 } __stack;
1961 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1962 const size_t __len = 42 - 1;
1963 const size_t __idx __unused = __len - 1;
1964 wchar_t src[__len];
1965
1966 __stack.__buf = malloc(__bufsz);
1967 wmemset(__stack.__buf, 0, __len);
1968 wmemset(src, 'A', __len - 1);
1969 src[__len - 1] = '\0';
1970
1971 wcsncpy(__stack.__buf, src, __len);
1972 #undef BUF
1973
1974 }
1975
1976 ATF_TC(wcsncpy_heap_end);
ATF_TC_HEAD(wcsncpy_heap_end,tc)1977 ATF_TC_HEAD(wcsncpy_heap_end, tc)
1978 {
1979 }
ATF_TC_BODY(wcsncpy_heap_end,tc)1980 ATF_TC_BODY(wcsncpy_heap_end, tc)
1981 {
1982 #define BUF __stack.__buf
1983 struct {
1984 uint8_t padding_l;
1985 wchar_t * __buf;
1986 uint8_t padding_r;
1987 } __stack;
1988 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1989 const size_t __len = 42;
1990 const size_t __idx __unused = __len - 1;
1991 wchar_t src[__len];
1992
1993 __stack.__buf = malloc(__bufsz);
1994 wmemset(__stack.__buf, 0, __len);
1995 wmemset(src, 'A', __len - 1);
1996 src[__len - 1] = '\0';
1997
1998 wcsncpy(__stack.__buf, src, __len);
1999 #undef BUF
2000
2001 }
2002
2003 ATF_TC(wcsncpy_heap_after_end);
ATF_TC_HEAD(wcsncpy_heap_after_end,tc)2004 ATF_TC_HEAD(wcsncpy_heap_after_end, tc)
2005 {
2006 }
ATF_TC_BODY(wcsncpy_heap_after_end,tc)2007 ATF_TC_BODY(wcsncpy_heap_after_end, tc)
2008 {
2009 #define BUF __stack.__buf
2010 struct {
2011 uint8_t padding_l;
2012 wchar_t * __buf;
2013 uint8_t padding_r;
2014 } __stack;
2015 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2016 const size_t __len = 42 + 1;
2017 const size_t __idx __unused = __len - 1;
2018 pid_t __child;
2019 int __status;
2020 wchar_t src[__len];
2021
2022 __child = fork();
2023 ATF_REQUIRE(__child >= 0);
2024 if (__child > 0)
2025 goto monitor;
2026
2027 /* Child */
2028 disable_coredumps();
2029 __stack.__buf = malloc(__bufsz);
2030 wmemset(__stack.__buf, 0, __len);
2031 wmemset(src, 'A', __len - 1);
2032 src[__len - 1] = '\0';
2033
2034 wcsncpy(__stack.__buf, src, __len);
2035 _exit(EX_SOFTWARE); /* Should have aborted. */
2036
2037 monitor:
2038 while (waitpid(__child, &__status, 0) != __child) {
2039 ATF_REQUIRE_EQ(EINTR, errno);
2040 }
2041
2042 if (!WIFSIGNALED(__status)) {
2043 switch (WEXITSTATUS(__status)) {
2044 case EX_SOFTWARE:
2045 atf_tc_fail("FORTIFY_SOURCE failed to abort");
2046 break;
2047 case EX_OSERR:
2048 atf_tc_fail("setrlimit(2) failed");
2049 break;
2050 default:
2051 atf_tc_fail("child exited with status %d",
2052 WEXITSTATUS(__status));
2053 }
2054 } else {
2055 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
2056 }
2057 #undef BUF
2058
2059 }
2060
ATF_TP_ADD_TCS(tp)2061 ATF_TP_ADD_TCS(tp)
2062 {
2063 ATF_TP_ADD_TC(tp, wmemcpy_before_end);
2064 ATF_TP_ADD_TC(tp, wmemcpy_end);
2065 ATF_TP_ADD_TC(tp, wmemcpy_heap_before_end);
2066 ATF_TP_ADD_TC(tp, wmemcpy_heap_end);
2067 ATF_TP_ADD_TC(tp, wmemcpy_heap_after_end);
2068 ATF_TP_ADD_TC(tp, wmempcpy_before_end);
2069 ATF_TP_ADD_TC(tp, wmempcpy_end);
2070 ATF_TP_ADD_TC(tp, wmempcpy_heap_before_end);
2071 ATF_TP_ADD_TC(tp, wmempcpy_heap_end);
2072 ATF_TP_ADD_TC(tp, wmempcpy_heap_after_end);
2073 ATF_TP_ADD_TC(tp, wmemmove_before_end);
2074 ATF_TP_ADD_TC(tp, wmemmove_end);
2075 ATF_TP_ADD_TC(tp, wmemmove_heap_before_end);
2076 ATF_TP_ADD_TC(tp, wmemmove_heap_end);
2077 ATF_TP_ADD_TC(tp, wmemmove_heap_after_end);
2078 ATF_TP_ADD_TC(tp, wmemset_before_end);
2079 ATF_TP_ADD_TC(tp, wmemset_end);
2080 ATF_TP_ADD_TC(tp, wmemset_heap_before_end);
2081 ATF_TP_ADD_TC(tp, wmemset_heap_end);
2082 ATF_TP_ADD_TC(tp, wmemset_heap_after_end);
2083 ATF_TP_ADD_TC(tp, wcpcpy_before_end);
2084 ATF_TP_ADD_TC(tp, wcpcpy_end);
2085 ATF_TP_ADD_TC(tp, wcpcpy_heap_before_end);
2086 ATF_TP_ADD_TC(tp, wcpcpy_heap_end);
2087 ATF_TP_ADD_TC(tp, wcpcpy_heap_after_end);
2088 ATF_TP_ADD_TC(tp, wcpncpy_before_end);
2089 ATF_TP_ADD_TC(tp, wcpncpy_end);
2090 ATF_TP_ADD_TC(tp, wcpncpy_heap_before_end);
2091 ATF_TP_ADD_TC(tp, wcpncpy_heap_end);
2092 ATF_TP_ADD_TC(tp, wcpncpy_heap_after_end);
2093 ATF_TP_ADD_TC(tp, wcscat_before_end);
2094 ATF_TP_ADD_TC(tp, wcscat_end);
2095 ATF_TP_ADD_TC(tp, wcscat_heap_before_end);
2096 ATF_TP_ADD_TC(tp, wcscat_heap_end);
2097 ATF_TP_ADD_TC(tp, wcscat_heap_after_end);
2098 ATF_TP_ADD_TC(tp, wcslcat_before_end);
2099 ATF_TP_ADD_TC(tp, wcslcat_end);
2100 ATF_TP_ADD_TC(tp, wcslcat_heap_before_end);
2101 ATF_TP_ADD_TC(tp, wcslcat_heap_end);
2102 ATF_TP_ADD_TC(tp, wcslcat_heap_after_end);
2103 ATF_TP_ADD_TC(tp, wcsncat_before_end);
2104 ATF_TP_ADD_TC(tp, wcsncat_end);
2105 ATF_TP_ADD_TC(tp, wcsncat_heap_before_end);
2106 ATF_TP_ADD_TC(tp, wcsncat_heap_end);
2107 ATF_TP_ADD_TC(tp, wcsncat_heap_after_end);
2108 ATF_TP_ADD_TC(tp, wcscpy_before_end);
2109 ATF_TP_ADD_TC(tp, wcscpy_end);
2110 ATF_TP_ADD_TC(tp, wcscpy_heap_before_end);
2111 ATF_TP_ADD_TC(tp, wcscpy_heap_end);
2112 ATF_TP_ADD_TC(tp, wcscpy_heap_after_end);
2113 ATF_TP_ADD_TC(tp, wcslcpy_before_end);
2114 ATF_TP_ADD_TC(tp, wcslcpy_end);
2115 ATF_TP_ADD_TC(tp, wcslcpy_heap_before_end);
2116 ATF_TP_ADD_TC(tp, wcslcpy_heap_end);
2117 ATF_TP_ADD_TC(tp, wcslcpy_heap_after_end);
2118 ATF_TP_ADD_TC(tp, wcsncpy_before_end);
2119 ATF_TP_ADD_TC(tp, wcsncpy_end);
2120 ATF_TP_ADD_TC(tp, wcsncpy_heap_before_end);
2121 ATF_TP_ADD_TC(tp, wcsncpy_heap_end);
2122 ATF_TP_ADD_TC(tp, wcsncpy_heap_after_end);
2123 return (atf_no_error());
2124 }
2125