1 /* Copyright (C) 2004-2022 Free Software Foundation, Inc.
2 Copyright The GNU Toolchain Authors.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 /* This file tests gets. Force it to be declared. */
20 #include <features.h>
21 #undef __GLIBC_USE_DEPRECATED_GETS
22 #define __GLIBC_USE_DEPRECATED_GETS 1
23
24 #include <assert.h>
25 #include <fcntl.h>
26 #include <locale.h>
27 #include <obstack.h>
28 #include <setjmp.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <wchar.h>
35 #include <sys/poll.h>
36 #include <sys/select.h>
37 #include <sys/socket.h>
38 #include <sys/un.h>
39
40 #ifndef _GNU_SOURCE
41 # define MEMPCPY memcpy
42 # define WMEMPCPY wmemcpy
43 # define MEMPCPY_RET(x) 0
44 # define WMEMPCPY_RET(x) 0
45 #else
46 # define MEMPCPY mempcpy
47 # define WMEMPCPY wmempcpy
48 # define MEMPCPY_RET(x) __builtin_strlen (x)
49 # define WMEMPCPY_RET(x) wcslen (x)
50 #endif
51
52 #define obstack_chunk_alloc malloc
53 #define obstack_chunk_free free
54
55 char *temp_filename;
56 static void do_prepare (void);
57 static int do_test (void);
58 #define PREPARE(argc, argv) do_prepare ()
59 #define TEST_FUNCTION do_test ()
60 #include "../test-skeleton.c"
61
62 static void
do_prepare(void)63 do_prepare (void)
64 {
65 int temp_fd = create_temp_file ("tst-chk1.", &temp_filename);
66 if (temp_fd == -1)
67 {
68 printf ("cannot create temporary file: %m\n");
69 exit (1);
70 }
71
72 const char *strs = "abcdefgh\nABCDEFGHI\nabcdefghij\nABCDEFGHIJ";
73 if ((size_t) write (temp_fd, strs, strlen (strs)) != strlen (strs))
74 {
75 puts ("could not write test strings into file");
76 unlink (temp_filename);
77 exit (1);
78 }
79 }
80
81 volatile int chk_fail_ok;
82 volatile int ret;
83 jmp_buf chk_fail_buf;
84
85 static void
handler(int sig)86 handler (int sig)
87 {
88 if (chk_fail_ok)
89 {
90 chk_fail_ok = 0;
91 longjmp (chk_fail_buf, 1);
92 }
93 else
94 _exit (127);
95 }
96
97 #if __USE_FORTIFY_LEVEL == 3
98 volatile size_t buf_size = 10;
99 #else
100 char buf[10];
101 wchar_t wbuf[10];
102 #define buf_size sizeof (buf)
103 #endif
104
105 volatile size_t l0;
106 volatile char *p;
107 volatile wchar_t *wp;
108 const char *str1 = "JIHGFEDCBA";
109 const char *str2 = "F";
110 const char *str3 = "%s%n%s%n";
111 const char *str4 = "Hello, ";
112 const char *str5 = "World!\n";
113 const wchar_t *wstr1 = L"JIHGFEDCBA";
114 const wchar_t *wstr2 = L"F";
115 const wchar_t *wstr3 = L"%s%n%s%n";
116 const wchar_t *wstr4 = L"Hello, ";
117 const wchar_t *wstr5 = L"World!\n";
118 char buf2[10] = "%s";
119 int num1 = 67;
120 int num2 = 987654;
121
122 #define FAIL() \
123 do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0)
124 #define CHK_FAIL_START \
125 chk_fail_ok = 1; \
126 if (! setjmp (chk_fail_buf)) \
127 {
128 #define CHK_FAIL_END \
129 chk_fail_ok = 0; \
130 FAIL (); \
131 }
132 #if __USE_FORTIFY_LEVEL >= 2 && (!defined __cplusplus || defined __va_arg_pack)
133 # define CHK_FAIL2_START CHK_FAIL_START
134 # define CHK_FAIL2_END CHK_FAIL_END
135 #else
136 # define CHK_FAIL2_START
137 # define CHK_FAIL2_END
138 #endif
139
140 static int
do_test(void)141 do_test (void)
142 {
143 #if __USE_FORTIFY_LEVEL == 3
144 char *buf = (char *) malloc (buf_size);
145 wchar_t *wbuf = (wchar_t *) malloc (buf_size * sizeof (wchar_t));
146 #endif
147 set_fortify_handler (handler);
148
149 struct A { char buf1[9]; char buf2[1]; } a;
150 struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;
151
152 printf ("Test checking routines at fortify level %d\n",
153 #ifdef __USE_FORTIFY_LEVEL
154 (int) __USE_FORTIFY_LEVEL
155 #else
156 0
157 #endif
158 );
159
160 #if defined __USE_FORTIFY_LEVEL && !defined __fortify_function
161 printf ("Test skipped");
162 if (l0 == 0)
163 return 0;
164 #endif
165
166 /* These ops can be done without runtime checking of object size. */
167 memcpy (buf, "abcdefghij", 10);
168 memmove (buf + 1, buf, 9);
169 if (memcmp (buf, "aabcdefghi", 10))
170 FAIL ();
171
172 memcpy (buf, "abcdefghij", 10);
173 bcopy (buf, buf + 1, 9);
174 if (memcmp (buf, "aabcdefghi", 10))
175 FAIL ();
176
177 if (MEMPCPY (buf + 5, "abcde", 5) != buf + 5 + MEMPCPY_RET ("abcde")
178 || memcmp (buf, "aabcdabcde", 10))
179 FAIL ();
180
181 memset (buf + 8, 'j', 2);
182 if (memcmp (buf, "aabcdabcjj", 10))
183 FAIL ();
184
185 bzero (buf + 8, 2);
186 if (memcmp (buf, "aabcdabc\0\0", 10))
187 FAIL ();
188
189 explicit_bzero (buf + 6, 4);
190 if (memcmp (buf, "aabcda\0\0\0\0", 10))
191 FAIL ();
192
193 strcpy (buf + 4, "EDCBA");
194 if (memcmp (buf, "aabcEDCBA", 10))
195 FAIL ();
196
197 if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
198 FAIL ();
199
200 strncpy (buf + 6, "X", 4);
201 if (memcmp (buf, "aabcEDX\0\0", 10))
202 FAIL ();
203
204 if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10))
205 FAIL ();
206
207 if (snprintf (buf + 7, 3, "%s", "987654") != 6
208 || memcmp (buf, "aabcEDX98", 10))
209 FAIL ();
210
211 /* These ops need runtime checking, but shouldn't __chk_fail. */
212 memcpy (buf, "abcdefghij", l0 + 10);
213 memmove (buf + 1, buf, l0 + 9);
214 if (memcmp (buf, "aabcdefghi", 10))
215 FAIL ();
216
217 memcpy (buf, "abcdefghij", l0 + 10);
218 bcopy (buf, buf + 1, l0 + 9);
219 if (memcmp (buf, "aabcdefghi", 10))
220 FAIL ();
221
222 if (MEMPCPY (buf + 5, "abcde", l0 + 5) != buf + 5 + MEMPCPY_RET ("abcde")
223 || memcmp (buf, "aabcdabcde", 10))
224 FAIL ();
225
226 memset (buf + 8, 'j', l0 + 2);
227 if (memcmp (buf, "aabcdabcjj", 10))
228 FAIL ();
229
230 bzero (buf + 8, l0 + 2);
231 if (memcmp (buf, "aabcdabc\0\0", 10))
232 FAIL ();
233
234 explicit_bzero (buf + 6, l0 + 4);
235 if (memcmp (buf, "aabcda\0\0\0\0", 10))
236 FAIL ();
237
238 strcpy (buf + 4, str1 + 5);
239 if (memcmp (buf, "aabcEDCBA", 10))
240 FAIL ();
241
242 if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
243 FAIL ();
244
245 strncpy (buf + 6, "X", l0 + 4);
246 if (memcmp (buf, "aabcEDX\0\0", 10))
247 FAIL ();
248
249 if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7
250 || memcmp (buf, "aabcEcd\0\0", 10))
251 FAIL ();
252
253 if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10))
254 FAIL ();
255
256 if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10))
257 FAIL ();
258
259 buf[l0 + 8] = '\0';
260 strcat (buf, "A");
261 if (memcmp (buf, "aabcEcd9A", 10))
262 FAIL ();
263
264 buf[l0 + 7] = '\0';
265 strncat (buf, "ZYXWV", l0 + 2);
266 if (memcmp (buf, "aabcEcdZY", 10))
267 FAIL ();
268
269 /* The following tests are supposed to succeed at all fortify
270 levels, even though they overflow a.buf1 into a.buf2. */
271 memcpy (a.buf1, "abcdefghij", l0 + 10);
272 memmove (a.buf1 + 1, a.buf1, l0 + 9);
273 if (memcmp (a.buf1, "aabcdefghi", 10))
274 FAIL ();
275
276 memcpy (a.buf1, "abcdefghij", l0 + 10);
277 bcopy (a.buf1, a.buf1 + 1, l0 + 9);
278 if (memcmp (a.buf1, "aabcdefghi", 10))
279 FAIL ();
280
281 if (MEMPCPY (a.buf1 + 5, "abcde", l0 + 5)
282 != a.buf1 + 5 + MEMPCPY_RET ("abcde")
283 || memcmp (a.buf1, "aabcdabcde", 10))
284 FAIL ();
285
286 memset (a.buf1 + 8, 'j', l0 + 2);
287 if (memcmp (a.buf1, "aabcdabcjj", 10))
288 FAIL ();
289
290 bzero (a.buf1 + 8, l0 + 2);
291 if (memcmp (a.buf1, "aabcdabc\0\0", 10))
292 FAIL ();
293
294 explicit_bzero (a.buf1 + 6, l0 + 4);
295 if (memcmp (a.buf1, "aabcda\0\0\0\0", 10))
296 FAIL ();
297
298 #if __USE_FORTIFY_LEVEL < 2
299 /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
300 and sufficient GCC support, as the string operations overflow
301 from a.buf1 into a.buf2. */
302 strcpy (a.buf1 + 4, str1 + 5);
303 if (memcmp (a.buf1, "aabcEDCBA", 10))
304 FAIL ();
305
306 if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9
307 || memcmp (a.buf1, "aabcEDCBF", 10))
308 FAIL ();
309
310 strncpy (a.buf1 + 6, "X", l0 + 4);
311 if (memcmp (a.buf1, "aabcEDX\0\0", 10))
312 FAIL ();
313
314 if (sprintf (a.buf1 + 7, "%d", num1) != 2
315 || memcmp (a.buf1, "aabcEDX67", 10))
316 FAIL ();
317
318 if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6
319 || memcmp (a.buf1, "aabcEDX98", 10))
320 FAIL ();
321
322 a.buf1[l0 + 8] = '\0';
323 strcat (a.buf1, "A");
324 if (memcmp (a.buf1, "aabcEDX9A", 10))
325 FAIL ();
326
327 a.buf1[l0 + 7] = '\0';
328 strncat (a.buf1, "ZYXWV", l0 + 2);
329 if (memcmp (a.buf1, "aabcEDXZY", 10))
330 FAIL ();
331
332 #endif
333
334 #if __USE_FORTIFY_LEVEL >= 1
335 /* Now check if all buffer overflows are caught at runtime.
336 N.B. All tests involving a length parameter need to be done
337 twice: once with the length a compile-time constant, once without. */
338
339 CHK_FAIL_START
340 memcpy (buf + 1, "abcdefghij", 10);
341 CHK_FAIL_END
342
343 CHK_FAIL_START
344 memcpy (buf + 1, "abcdefghij", l0 + 10);
345 CHK_FAIL_END
346
347 CHK_FAIL_START
348 memmove (buf + 2, buf + 1, 9);
349 CHK_FAIL_END
350
351 CHK_FAIL_START
352 memmove (buf + 2, buf + 1, l0 + 9);
353 CHK_FAIL_END
354
355 CHK_FAIL_START
356 bcopy (buf + 1, buf + 2, 9);
357 CHK_FAIL_END
358
359 CHK_FAIL_START
360 bcopy (buf + 1, buf + 2, l0 + 9);
361 CHK_FAIL_END
362
363 #ifdef _GNU_SOURCE
364 CHK_FAIL_START
365 p = (char *) mempcpy (buf + 6, "abcde", 5);
366 CHK_FAIL_END
367
368 CHK_FAIL_START
369 p = (char *) mempcpy (buf + 6, "abcde", l0 + 5);
370 CHK_FAIL_END
371 #endif
372
373 CHK_FAIL_START
374 memset (buf + 9, 'j', 2);
375 CHK_FAIL_END
376
377 CHK_FAIL_START
378 memset (buf + 9, 'j', l0 + 2);
379 CHK_FAIL_END
380
381 CHK_FAIL_START
382 bzero (buf + 9, 2);
383 CHK_FAIL_END
384
385 CHK_FAIL_START
386 bzero (buf + 9, l0 + 2);
387 CHK_FAIL_END
388
389 CHK_FAIL_START
390 explicit_bzero (buf + 9, 2);
391 CHK_FAIL_END
392
393 CHK_FAIL_START
394 explicit_bzero (buf + 9, l0 + 2);
395 CHK_FAIL_END
396
397 CHK_FAIL_START
398 strcpy (buf + 5, str1 + 5);
399 CHK_FAIL_END
400
401 CHK_FAIL_START
402 p = stpcpy (buf + 9, str2);
403 CHK_FAIL_END
404
405 CHK_FAIL_START
406 strncpy (buf + 7, "X", 4);
407 CHK_FAIL_END
408
409 CHK_FAIL_START
410 strncpy (buf + 7, "X", l0 + 4);
411 CHK_FAIL_END
412
413 CHK_FAIL_START
414 stpncpy (buf + 6, "cd", 5);
415 CHK_FAIL_END
416
417 CHK_FAIL_START
418 stpncpy (buf + 6, "cd", l0 + 5);
419 CHK_FAIL_END
420
421 # if !defined __cplusplus || defined __va_arg_pack
422 CHK_FAIL_START
423 sprintf (buf + 8, "%d", num1);
424 CHK_FAIL_END
425
426 CHK_FAIL_START
427 snprintf (buf + 8, 3, "%d", num2);
428 CHK_FAIL_END
429
430 CHK_FAIL_START
431 snprintf (buf + 8, l0 + 3, "%d", num2);
432 CHK_FAIL_END
433
434 CHK_FAIL_START
435 swprintf (wbuf + 8, 3, L"%d", num1);
436 CHK_FAIL_END
437
438 CHK_FAIL_START
439 swprintf (wbuf + 8, l0 + 3, L"%d", num1);
440 CHK_FAIL_END
441 # endif
442
443 memcpy (buf, str1 + 2, 9);
444 CHK_FAIL_START
445 strcat (buf, "AB");
446 CHK_FAIL_END
447
448 memcpy (buf, str1 + 3, 8);
449 CHK_FAIL_START
450 strncat (buf, "ZYXWV", 3);
451 CHK_FAIL_END
452
453 memcpy (buf, str1 + 3, 8);
454 CHK_FAIL_START
455 strncat (buf, "ZYXWV", l0 + 3);
456 CHK_FAIL_END
457
458 CHK_FAIL_START
459 memcpy (a.buf1 + 1, "abcdefghij", 10);
460 CHK_FAIL_END
461
462 CHK_FAIL_START
463 memcpy (a.buf1 + 1, "abcdefghij", l0 + 10);
464 CHK_FAIL_END
465
466 CHK_FAIL_START
467 memmove (a.buf1 + 2, a.buf1 + 1, 9);
468 CHK_FAIL_END
469
470 CHK_FAIL_START
471 memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9);
472 CHK_FAIL_END
473
474 CHK_FAIL_START
475 bcopy (a.buf1 + 1, a.buf1 + 2, 9);
476 CHK_FAIL_END
477
478 CHK_FAIL_START
479 bcopy (a.buf1 + 1, a.buf1 + 2, l0 + 9);
480 CHK_FAIL_END
481
482 #ifdef _GNU_SOURCE
483 CHK_FAIL_START
484 p = (char *) mempcpy (a.buf1 + 6, "abcde", 5);
485 CHK_FAIL_END
486
487 CHK_FAIL_START
488 p = (char *) mempcpy (a.buf1 + 6, "abcde", l0 + 5);
489 CHK_FAIL_END
490 #endif
491
492 CHK_FAIL_START
493 memset (a.buf1 + 9, 'j', 2);
494 CHK_FAIL_END
495
496 CHK_FAIL_START
497 memset (a.buf1 + 9, 'j', l0 + 2);
498 CHK_FAIL_END
499
500 CHK_FAIL_START
501 bzero (a.buf1 + 9, 2);
502 CHK_FAIL_END
503
504 CHK_FAIL_START
505 bzero (a.buf1 + 9, l0 + 2);
506 CHK_FAIL_END
507
508 CHK_FAIL_START
509 explicit_bzero (a.buf1 + 9, 2);
510 CHK_FAIL_END
511
512 CHK_FAIL_START
513 explicit_bzero (a.buf1 + 9, l0 + 2);
514 CHK_FAIL_END
515
516 # if __USE_FORTIFY_LEVEL >= 2
517 # define O 0
518 # else
519 # define O 1
520 # endif
521
522 CHK_FAIL_START
523 strcpy (a.buf1 + (O + 4), str1 + 5);
524 CHK_FAIL_END
525
526 CHK_FAIL_START
527 p = stpcpy (a.buf1 + (O + 8), str2);
528 CHK_FAIL_END
529
530 CHK_FAIL_START
531 strncpy (a.buf1 + (O + 6), "X", 4);
532 CHK_FAIL_END
533
534 CHK_FAIL_START
535 strncpy (a.buf1 + (O + 6), "X", l0 + 4);
536 CHK_FAIL_END
537
538 # if !defined __cplusplus || defined __va_arg_pack
539 CHK_FAIL_START
540 sprintf (a.buf1 + (O + 7), "%d", num1);
541 CHK_FAIL_END
542
543 CHK_FAIL_START
544 snprintf (a.buf1 + (O + 7), 3, "%d", num2);
545 CHK_FAIL_END
546
547 CHK_FAIL_START
548 snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2);
549 CHK_FAIL_END
550 # endif
551
552 memcpy (a.buf1, str1 + (3 - O), 8 + O);
553 CHK_FAIL_START
554 strcat (a.buf1, "AB");
555 CHK_FAIL_END
556
557 memcpy (a.buf1, str1 + (4 - O), 7 + O);
558 CHK_FAIL_START
559 strncat (a.buf1, "ZYXWV", l0 + 3);
560 CHK_FAIL_END
561 #endif
562
563
564 /* These ops can be done without runtime checking of object size. */
565 wmemcpy (wbuf, L"abcdefghij", 10);
566 wmemmove (wbuf + 1, wbuf, 9);
567 if (wmemcmp (wbuf, L"aabcdefghi", 10))
568 FAIL ();
569
570 if (WMEMPCPY (wbuf + 5, L"abcde", 5) != wbuf + 5 + WMEMPCPY_RET (L"abcde")
571 || wmemcmp (wbuf, L"aabcdabcde", 10))
572 FAIL ();
573
574 wmemset (wbuf + 8, L'j', 2);
575 if (wmemcmp (wbuf, L"aabcdabcjj", 10))
576 FAIL ();
577
578 wcscpy (wbuf + 4, L"EDCBA");
579 if (wmemcmp (wbuf, L"aabcEDCBA", 10))
580 FAIL ();
581
582 if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
583 FAIL ();
584
585 wcsncpy (wbuf + 6, L"X", 4);
586 if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
587 FAIL ();
588
589 if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0
590 || wmemcmp (wbuf, L"aabcEDX98", 10))
591 FAIL ();
592
593 if (swprintf (wbuf + 7, 3, L"64") != 2
594 || wmemcmp (wbuf, L"aabcEDX64", 10))
595 FAIL ();
596
597 /* These ops need runtime checking, but shouldn't __chk_fail. */
598 wmemcpy (wbuf, L"abcdefghij", l0 + 10);
599 wmemmove (wbuf + 1, wbuf, l0 + 9);
600 if (wmemcmp (wbuf, L"aabcdefghi", 10))
601 FAIL ();
602
603 if (WMEMPCPY (wbuf + 5, L"abcde", l0 + 5)
604 != wbuf + 5 + WMEMPCPY_RET (L"abcde")
605 || wmemcmp (wbuf, L"aabcdabcde", 10))
606 FAIL ();
607
608 wmemset (wbuf + 8, L'j', l0 + 2);
609 if (wmemcmp (wbuf, L"aabcdabcjj", 10))
610 FAIL ();
611
612 wcscpy (wbuf + 4, wstr1 + 5);
613 if (wmemcmp (wbuf, L"aabcEDCBA", 10))
614 FAIL ();
615
616 if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
617 FAIL ();
618
619 wcsncpy (wbuf + 6, L"X", l0 + 4);
620 if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
621 FAIL ();
622
623 if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7
624 || wmemcmp (wbuf, L"aabcEcd\0\0", 10))
625 FAIL ();
626
627 if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0
628 || wmemcmp (wbuf, L"aabcEcd98", 10))
629 FAIL ();
630
631 wbuf[l0 + 8] = L'\0';
632 wcscat (wbuf, L"A");
633 if (wmemcmp (wbuf, L"aabcEcd9A", 10))
634 FAIL ();
635
636 wbuf[l0 + 7] = L'\0';
637 wcsncat (wbuf, L"ZYXWV", l0 + 2);
638 if (wmemcmp (wbuf, L"aabcEcdZY", 10))
639 FAIL ();
640
641 wmemcpy (wa.buf1, L"abcdefghij", l0 + 10);
642 wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9);
643 if (wmemcmp (wa.buf1, L"aabcdefghi", 10))
644 FAIL ();
645
646 if (WMEMPCPY (wa.buf1 + 5, L"abcde", l0 + 5)
647 != wa.buf1 + 5 + WMEMPCPY_RET (L"abcde")
648 || wmemcmp (wa.buf1, L"aabcdabcde", 10))
649 FAIL ();
650
651 wmemset (wa.buf1 + 8, L'j', l0 + 2);
652 if (wmemcmp (wa.buf1, L"aabcdabcjj", 10))
653 FAIL ();
654
655 #if __USE_FORTIFY_LEVEL < 2
656 /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
657 and sufficient GCC support, as the string operations overflow
658 from a.buf1 into a.buf2. */
659 wcscpy (wa.buf1 + 4, wstr1 + 5);
660 if (wmemcmp (wa.buf1, L"aabcEDCBA", 10))
661 FAIL ();
662
663 if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9
664 || wmemcmp (wa.buf1, L"aabcEDCBF", 10))
665 FAIL ();
666
667 wcsncpy (wa.buf1 + 6, L"X", l0 + 4);
668 if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10))
669 FAIL ();
670
671 if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0
672 || wmemcmp (wa.buf1, L"aabcEDX98", 10))
673 FAIL ();
674
675 wa.buf1[l0 + 8] = L'\0';
676 wcscat (wa.buf1, L"A");
677 if (wmemcmp (wa.buf1, L"aabcEDX9A", 10))
678 FAIL ();
679
680 wa.buf1[l0 + 7] = L'\0';
681 wcsncat (wa.buf1, L"ZYXWV", l0 + 2);
682 if (wmemcmp (wa.buf1, L"aabcEDXZY", 10))
683 FAIL ();
684
685 #endif
686
687 #if __USE_FORTIFY_LEVEL >= 1
688 /* Now check if all buffer overflows are caught at runtime.
689 N.B. All tests involving a length parameter need to be done
690 twice: once with the length a compile-time constant, once without. */
691
692 CHK_FAIL_START
693 wmemcpy (wbuf + 1, L"abcdefghij", 10);
694 CHK_FAIL_END
695
696 CHK_FAIL_START
697 wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10);
698 CHK_FAIL_END
699
700 CHK_FAIL_START
701 wmemcpy (wbuf + 9, L"abcdefghij", 10);
702 CHK_FAIL_END
703
704 CHK_FAIL_START
705 wmemcpy (wbuf + 9, L"abcdefghij", l0 + 10);
706 CHK_FAIL_END
707
708 CHK_FAIL_START
709 wmemmove (wbuf + 2, wbuf + 1, 9);
710 CHK_FAIL_END
711
712 CHK_FAIL_START
713 wmemmove (wbuf + 2, wbuf + 1, l0 + 9);
714 CHK_FAIL_END
715
716 #ifdef _GNU_SOURCE
717 CHK_FAIL_START
718 wp = wmempcpy (wbuf + 6, L"abcde", 5);
719 CHK_FAIL_END
720
721 CHK_FAIL_START
722 wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5);
723 CHK_FAIL_END
724 #endif
725
726 CHK_FAIL_START
727 wmemset (wbuf + 9, L'j', 2);
728 CHK_FAIL_END
729
730 CHK_FAIL_START
731 wmemset (wbuf + 9, L'j', l0 + 2);
732 CHK_FAIL_END
733
734 CHK_FAIL_START
735 wcscpy (wbuf + 5, wstr1 + 5);
736 CHK_FAIL_END
737
738 CHK_FAIL_START
739 wp = wcpcpy (wbuf + 9, wstr2);
740 CHK_FAIL_END
741
742 CHK_FAIL_START
743 wcsncpy (wbuf + 7, L"X", 4);
744 CHK_FAIL_END
745
746 CHK_FAIL_START
747 wcsncpy (wbuf + 7, L"X", l0 + 4);
748 CHK_FAIL_END
749
750 CHK_FAIL_START
751 wcsncpy (wbuf + 9, L"XABCDEFGH", 8);
752 CHK_FAIL_END
753
754 CHK_FAIL_START
755 wcpncpy (wbuf + 9, L"XABCDEFGH", 8);
756 CHK_FAIL_END
757
758 CHK_FAIL_START
759 wcpncpy (wbuf + 6, L"cd", 5);
760 CHK_FAIL_END
761
762 CHK_FAIL_START
763 wcpncpy (wbuf + 6, L"cd", l0 + 5);
764 CHK_FAIL_END
765
766 wmemcpy (wbuf, wstr1 + 2, 9);
767 CHK_FAIL_START
768 wcscat (wbuf, L"AB");
769 CHK_FAIL_END
770
771 wmemcpy (wbuf, wstr1 + 3, 8);
772 CHK_FAIL_START
773 wcsncat (wbuf, L"ZYXWV", l0 + 3);
774 CHK_FAIL_END
775
776 CHK_FAIL_START
777 wmemcpy (wa.buf1 + 1, L"abcdefghij", 10);
778 CHK_FAIL_END
779
780 CHK_FAIL_START
781 wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10);
782 CHK_FAIL_END
783
784 CHK_FAIL_START
785 wmemmove (wa.buf1 + 2, wa.buf1 + 1, 9);
786 CHK_FAIL_END
787
788 CHK_FAIL_START
789 wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9);
790 CHK_FAIL_END
791
792 #ifdef _GNU_SOURCE
793 CHK_FAIL_START
794 wp = wmempcpy (wa.buf1 + 6, L"abcde", 5);
795 CHK_FAIL_END
796
797 CHK_FAIL_START
798 wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5);
799 CHK_FAIL_END
800 #endif
801
802 CHK_FAIL_START
803 wmemset (wa.buf1 + 9, L'j', 2);
804 CHK_FAIL_END
805
806 CHK_FAIL_START
807 wmemset (wa.buf1 + 9, L'j', l0 + 2);
808 CHK_FAIL_END
809
810 #if __USE_FORTIFY_LEVEL >= 2
811 # define O 0
812 #else
813 # define O 1
814 #endif
815
816 CHK_FAIL_START
817 wcscpy (wa.buf1 + (O + 4), wstr1 + 5);
818 CHK_FAIL_END
819
820 CHK_FAIL_START
821 wp = wcpcpy (wa.buf1 + (O + 8), wstr2);
822 CHK_FAIL_END
823
824 CHK_FAIL_START
825 wcsncpy (wa.buf1 + (O + 6), L"X", 4);
826 CHK_FAIL_END
827
828 CHK_FAIL_START
829 wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4);
830 CHK_FAIL_END
831
832 wmemcpy (wa.buf1, wstr1 + (3 - O), 8 + O);
833 CHK_FAIL_START
834 wcscat (wa.buf1, L"AB");
835 CHK_FAIL_END
836
837 wmemcpy (wa.buf1, wstr1 + (4 - O), 7 + O);
838 CHK_FAIL_START
839 wcsncat (wa.buf1, L"ZYXWV", l0 + 3);
840 CHK_FAIL_END
841 #endif
842
843
844 /* Now checks for %n protection. */
845
846 /* Constant literals passed directly are always ok
847 (even with warnings about possible bugs from GCC). */
848 int n1, n2;
849 if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2
850 || n1 != 1 || n2 != 2)
851 FAIL ();
852
853 /* In this case the format string is not known at compile time,
854 but resides in read-only memory, so is ok. */
855 if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2
856 || n1 != 1 || n2 != 2)
857 FAIL ();
858
859 strcpy (buf2 + 2, "%n%s%n");
860 /* When the format string is writable and contains %n,
861 with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
862 CHK_FAIL2_START
863 if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2)
864 FAIL ();
865 CHK_FAIL2_END
866
867 CHK_FAIL2_START
868 if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2)
869 FAIL ();
870 CHK_FAIL2_END
871
872 /* But if there is no %n, even writable format string
873 should work. */
874 buf2[6] = '\0';
875 if (sprintf (buf, buf2 + 4, str2) != 1)
876 FAIL ();
877
878 /* Constant literals passed directly are always ok
879 (even with warnings about possible bugs from GCC). */
880 if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14
881 || n1 != 7 || n2 != 14)
882 FAIL ();
883
884 /* In this case the format string is not known at compile time,
885 but resides in read-only memory, so is ok. */
886 if (printf (str3, str4, &n1, str5, &n2) != 14
887 || n1 != 7 || n2 != 14)
888 FAIL ();
889
890 strcpy (buf2 + 2, "%n%s%n");
891 /* When the format string is writable and contains %n,
892 with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
893 CHK_FAIL2_START
894 if (printf (buf2, str4, &n1, str5, &n1) != 14)
895 FAIL ();
896 CHK_FAIL2_END
897
898 /* But if there is no %n, even writable format string
899 should work. */
900 buf2[6] = '\0';
901 if (printf (buf2 + 4, str5) != 7)
902 FAIL ();
903
904 FILE *fp = stdout;
905
906 /* Constant literals passed directly are always ok
907 (even with warnings about possible bugs from GCC). */
908 if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14
909 || n1 != 7 || n2 != 14)
910 FAIL ();
911
912 /* In this case the format string is not known at compile time,
913 but resides in read-only memory, so is ok. */
914 if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14
915 || n1 != 7 || n2 != 14)
916 FAIL ();
917
918 strcpy (buf2 + 2, "%n%s%n");
919 /* When the format string is writable and contains %n,
920 with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
921 CHK_FAIL2_START
922 if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14)
923 FAIL ();
924 CHK_FAIL2_END
925
926 /* But if there is no %n, even writable format string
927 should work. */
928 buf2[6] = '\0';
929 if (fprintf (fp, buf2 + 4, str5) != 7)
930 FAIL ();
931
932 #ifdef _GNU_SOURCE
933 char *my_ptr = NULL;
934 strcpy (buf2 + 2, "%n%s%n");
935 /* When the format string is writable and contains %n,
936 with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
937 CHK_FAIL2_START
938 if (asprintf (&my_ptr, buf2, str4, &n1, str5, &n1) != 14)
939 FAIL ();
940 else
941 free (my_ptr);
942 CHK_FAIL2_END
943
944 struct obstack obs;
945 obstack_init (&obs);
946 CHK_FAIL2_START
947 if (obstack_printf (&obs, buf2, str4, &n1, str5, &n1) != 14)
948 FAIL ();
949 CHK_FAIL2_END
950 obstack_free (&obs, NULL);
951
952 my_ptr = NULL;
953 if (asprintf (&my_ptr, "%s%n%s%n", str4, &n1, str5, &n1) != 14)
954 FAIL ();
955 else
956 free (my_ptr);
957
958 obstack_init (&obs);
959 if (obstack_printf (&obs, "%s%n%s%n", str4, &n1, str5, &n1) != 14)
960 FAIL ();
961 obstack_free (&obs, NULL);
962 #endif
963
964 if (freopen (temp_filename, "r", stdin) == NULL)
965 {
966 puts ("could not open temporary file");
967 exit (1);
968 }
969
970 if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9))
971 FAIL ();
972 if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10))
973 FAIL ();
974
975 #if __USE_FORTIFY_LEVEL >= 1
976 CHK_FAIL_START
977 if (gets (buf) != buf)
978 FAIL ();
979 CHK_FAIL_END
980 #endif
981
982 rewind (stdin);
983
984 if (fgets (buf, buf_size, stdin) != buf
985 || memcmp (buf, "abcdefgh\n", 10))
986 FAIL ();
987 if (fgets (buf, buf_size, stdin) != buf || memcmp (buf, "ABCDEFGHI", 10))
988 FAIL ();
989
990 rewind (stdin);
991
992 if (fgets (buf, l0 + buf_size, stdin) != buf
993 || memcmp (buf, "abcdefgh\n", 10))
994 FAIL ();
995
996 #if __USE_FORTIFY_LEVEL >= 1
997 CHK_FAIL_START
998 if (fgets (buf, buf_size + 1, stdin) != buf)
999 FAIL ();
1000 CHK_FAIL_END
1001
1002 CHK_FAIL_START
1003 if (fgets (buf, l0 + buf_size + 1, stdin) != buf)
1004 FAIL ();
1005 CHK_FAIL_END
1006 #endif
1007
1008 rewind (stdin);
1009
1010 #ifdef _GNU_SOURCE
1011 if (fgets_unlocked (buf, buf_size, stdin) != buf
1012 || memcmp (buf, "abcdefgh\n", 10))
1013 FAIL ();
1014 if (fgets_unlocked (buf, buf_size, stdin) != buf
1015 || memcmp (buf, "ABCDEFGHI", 10))
1016 FAIL ();
1017
1018 rewind (stdin);
1019
1020 if (fgets_unlocked (buf, l0 + buf_size, stdin) != buf
1021 || memcmp (buf, "abcdefgh\n", 10))
1022 FAIL ();
1023
1024 #if __USE_FORTIFY_LEVEL >= 1
1025 CHK_FAIL_START
1026 if (fgets_unlocked (buf, buf_size + 1, stdin) != buf)
1027 FAIL ();
1028 CHK_FAIL_END
1029
1030 CHK_FAIL_START
1031 if (fgets_unlocked (buf, l0 + buf_size + 1, stdin) != buf)
1032 FAIL ();
1033 CHK_FAIL_END
1034 #endif
1035
1036 rewind (stdin);
1037 #endif
1038
1039 if (fread (buf, 1, buf_size, stdin) != buf_size
1040 || memcmp (buf, "abcdefgh\nA", 10))
1041 FAIL ();
1042 if (fread (buf, buf_size, 1, stdin) != 1
1043 || memcmp (buf, "BCDEFGHI\na", 10))
1044 FAIL ();
1045
1046 rewind (stdin);
1047
1048 if (fread (buf, l0 + 1, buf_size, stdin) != buf_size
1049 || memcmp (buf, "abcdefgh\nA", 10))
1050 FAIL ();
1051 if (fread (buf, buf_size, l0 + 1, stdin) != 1
1052 || memcmp (buf, "BCDEFGHI\na", 10))
1053 FAIL ();
1054
1055 #if __USE_FORTIFY_LEVEL >= 1
1056 CHK_FAIL_START
1057 if (fread (buf, 1, buf_size + 1, stdin) != buf_size + 1)
1058 FAIL ();
1059 CHK_FAIL_END
1060
1061 CHK_FAIL_START
1062 if (fread (buf, buf_size + 1, l0 + 1, stdin) != 1)
1063 FAIL ();
1064 CHK_FAIL_END
1065 #endif
1066
1067 rewind (stdin);
1068
1069 if (fread_unlocked (buf, 1, buf_size, stdin) != buf_size
1070 || memcmp (buf, "abcdefgh\nA", 10))
1071 FAIL ();
1072 if (fread_unlocked (buf, buf_size, 1, stdin) != 1
1073 || memcmp (buf, "BCDEFGHI\na", 10))
1074 FAIL ();
1075
1076 rewind (stdin);
1077
1078 if (fread_unlocked (buf, 1, 4, stdin) != 4
1079 || memcmp (buf, "abcdFGHI\na", 10))
1080 FAIL ();
1081 if (fread_unlocked (buf, 4, 1, stdin) != 1
1082 || memcmp (buf, "efghFGHI\na", 10))
1083 FAIL ();
1084
1085 rewind (stdin);
1086
1087 if (fread_unlocked (buf, l0 + 1, buf_size, stdin) != buf_size
1088 || memcmp (buf, "abcdefgh\nA", 10))
1089 FAIL ();
1090 if (fread_unlocked (buf, buf_size, l0 + 1, stdin) != 1
1091 || memcmp (buf, "BCDEFGHI\na", 10))
1092 FAIL ();
1093
1094 #if __USE_FORTIFY_LEVEL >= 1
1095 CHK_FAIL_START
1096 if (fread_unlocked (buf, 1, buf_size + 1, stdin) != buf_size + 1)
1097 FAIL ();
1098 CHK_FAIL_END
1099
1100 CHK_FAIL_START
1101 if (fread_unlocked (buf, buf_size + 1, l0 + 1, stdin) != 1)
1102 FAIL ();
1103 CHK_FAIL_END
1104 #endif
1105
1106 lseek (fileno (stdin), 0, SEEK_SET);
1107
1108 if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1
1109 || memcmp (buf, "abcdefgh\n", 9))
1110 FAIL ();
1111 if (read (fileno (stdin), buf, buf_size - 1) != buf_size - 1
1112 || memcmp (buf, "ABCDEFGHI", 9))
1113 FAIL ();
1114
1115 lseek (fileno (stdin), 0, SEEK_SET);
1116
1117 if (read (fileno (stdin), buf, l0 + buf_size - 1) != buf_size - 1
1118 || memcmp (buf, "abcdefgh\n", 9))
1119 FAIL ();
1120
1121 #if __USE_FORTIFY_LEVEL >= 1
1122 CHK_FAIL_START
1123 if (read (fileno (stdin), buf, buf_size + 1) != buf_size + 1)
1124 FAIL ();
1125 CHK_FAIL_END
1126
1127 CHK_FAIL_START
1128 if (read (fileno (stdin), buf, l0 + buf_size + 1) != buf_size + 1)
1129 FAIL ();
1130 CHK_FAIL_END
1131 #endif
1132
1133 if (pread (fileno (stdin), buf, buf_size - 1, buf_size - 2)
1134 != buf_size - 1
1135 || memcmp (buf, "\nABCDEFGH", 9))
1136 FAIL ();
1137 if (pread (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1
1138 || memcmp (buf, "abcdefgh\n", 9))
1139 FAIL ();
1140 if (pread (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3)
1141 != buf_size - 1
1142 || memcmp (buf, "h\nABCDEFG", 9))
1143 FAIL ();
1144
1145 #if __USE_FORTIFY_LEVEL >= 1
1146 CHK_FAIL_START
1147 if (pread (fileno (stdin), buf, buf_size + 1, 2 * buf_size)
1148 != buf_size + 1)
1149 FAIL ();
1150 CHK_FAIL_END
1151
1152 CHK_FAIL_START
1153 if (pread (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size)
1154 != buf_size + 1)
1155 FAIL ();
1156 CHK_FAIL_END
1157 #endif
1158
1159 if (pread64 (fileno (stdin), buf, buf_size - 1, buf_size - 2)
1160 != buf_size - 1
1161 || memcmp (buf, "\nABCDEFGH", 9))
1162 FAIL ();
1163 if (pread64 (fileno (stdin), buf, buf_size - 1, 0) != buf_size - 1
1164 || memcmp (buf, "abcdefgh\n", 9))
1165 FAIL ();
1166 if (pread64 (fileno (stdin), buf, l0 + buf_size - 1, buf_size - 3)
1167 != buf_size - 1
1168 || memcmp (buf, "h\nABCDEFG", 9))
1169 FAIL ();
1170
1171 #if __USE_FORTIFY_LEVEL >= 1
1172 CHK_FAIL_START
1173 if (pread64 (fileno (stdin), buf, buf_size + 1, 2 * buf_size)
1174 != buf_size + 1)
1175 FAIL ();
1176 CHK_FAIL_END
1177
1178 CHK_FAIL_START
1179 if (pread64 (fileno (stdin), buf, l0 + buf_size + 1, 2 * buf_size)
1180 != buf_size + 1)
1181 FAIL ();
1182 CHK_FAIL_END
1183 #endif
1184
1185 if (freopen (temp_filename, "r", stdin) == NULL)
1186 {
1187 puts ("could not open temporary file");
1188 exit (1);
1189 }
1190
1191 if (fseek (stdin, 9 + 10 + 11, SEEK_SET))
1192 {
1193 puts ("could not seek in test file");
1194 exit (1);
1195 }
1196
1197 #if __USE_FORTIFY_LEVEL >= 1
1198 CHK_FAIL_START
1199 if (gets (buf) != buf)
1200 FAIL ();
1201 CHK_FAIL_END
1202 #endif
1203
1204 /* Check whether missing N$ formats are detected. */
1205 CHK_FAIL2_START
1206 printf ("%3$d\n", 1, 2, 3, 4);
1207 CHK_FAIL2_END
1208
1209 CHK_FAIL2_START
1210 fprintf (stdout, "%3$d\n", 1, 2, 3, 4);
1211 CHK_FAIL2_END
1212
1213 CHK_FAIL2_START
1214 sprintf (buf, "%3$d\n", 1, 2, 3, 4);
1215 CHK_FAIL2_END
1216
1217 CHK_FAIL2_START
1218 snprintf (buf, buf_size, "%3$d\n", 1, 2, 3, 4);
1219 CHK_FAIL2_END
1220
1221 int sp[2];
1222 if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp))
1223 FAIL ();
1224 else
1225 {
1226 const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n";
1227 if ((size_t) send (sp[0], sendstr, strlen (sendstr), 0)
1228 != strlen (sendstr))
1229 FAIL ();
1230
1231 char recvbuf[12];
1232 if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK)
1233 != sizeof recvbuf
1234 || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
1235 FAIL ();
1236
1237 if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK)
1238 != sizeof recvbuf - 7
1239 || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
1240 FAIL ();
1241
1242 #if __USE_FORTIFY_LEVEL >= 1
1243 CHK_FAIL_START
1244 if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK)
1245 != sizeof recvbuf)
1246 FAIL ();
1247 CHK_FAIL_END
1248
1249 CHK_FAIL_START
1250 if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK)
1251 != sizeof recvbuf - 3)
1252 FAIL ();
1253 CHK_FAIL_END
1254 #endif
1255
1256 socklen_t sl;
1257 struct sockaddr_un sa_un;
1258
1259 sl = sizeof (sa_un);
1260 if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK,
1261 (struct sockaddr *) &sa_un, &sl)
1262 != sizeof recvbuf
1263 || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
1264 FAIL ();
1265
1266 sl = sizeof (sa_un);
1267 if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK,
1268 (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 7
1269 || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
1270 FAIL ();
1271
1272 #if __USE_FORTIFY_LEVEL >= 1
1273 CHK_FAIL_START
1274 sl = sizeof (sa_un);
1275 if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK,
1276 (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf)
1277 FAIL ();
1278 CHK_FAIL_END
1279
1280 CHK_FAIL_START
1281 sl = sizeof (sa_un);
1282 if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK,
1283 (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 3)
1284 FAIL ();
1285 CHK_FAIL_END
1286 #endif
1287
1288 close (sp[0]);
1289 close (sp[1]);
1290 }
1291
1292 char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo";
1293 char *enddir = strchr (fname, '\0');
1294 if (mkdtemp (fname) == NULL)
1295 {
1296 printf ("mkdtemp failed: %m\n");
1297 return 1;
1298 }
1299 *enddir = '/';
1300 if (symlink ("bar", fname) != 0)
1301 FAIL ();
1302
1303 char readlinkbuf[4];
1304 if (readlink (fname, readlinkbuf, 4) != 3
1305 || memcmp (readlinkbuf, "bar", 3) != 0)
1306 FAIL ();
1307 if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3
1308 || memcmp (readlinkbuf, "bbar", 4) != 0)
1309 FAIL ();
1310
1311 #if __USE_FORTIFY_LEVEL >= 1
1312 CHK_FAIL_START
1313 if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3)
1314 FAIL ();
1315 CHK_FAIL_END
1316
1317 CHK_FAIL_START
1318 if (readlink (fname, readlinkbuf + 3, 4) != 3)
1319 FAIL ();
1320 CHK_FAIL_END
1321 #endif
1322
1323 int tmpfd = open ("/tmp", O_RDONLY | O_DIRECTORY);
1324 if (tmpfd < 0)
1325 FAIL ();
1326
1327 if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf, 4) != 3
1328 || memcmp (readlinkbuf, "bar", 3) != 0)
1329 FAIL ();
1330 if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 1,
1331 l0 + 3) != 3
1332 || memcmp (readlinkbuf, "bbar", 4) != 0)
1333 FAIL ();
1334
1335 #if __USE_FORTIFY_LEVEL >= 1
1336 CHK_FAIL_START
1337 if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 2,
1338 l0 + 3) != 3)
1339 FAIL ();
1340 CHK_FAIL_END
1341
1342 CHK_FAIL_START
1343 if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 3,
1344 4) != 3)
1345 FAIL ();
1346 CHK_FAIL_END
1347 #endif
1348
1349 close (tmpfd);
1350
1351 char *cwd1 = getcwd (NULL, 0);
1352 if (cwd1 == NULL)
1353 FAIL ();
1354
1355 char *cwd2 = getcwd (NULL, 250);
1356 if (cwd2 == NULL)
1357 FAIL ();
1358
1359 if (cwd1 && cwd2)
1360 {
1361 if (strcmp (cwd1, cwd2) != 0)
1362 FAIL ();
1363
1364 *enddir = '\0';
1365 if (chdir (fname))
1366 FAIL ();
1367
1368 char *cwd3 = getcwd (NULL, 0);
1369 if (cwd3 == NULL)
1370 FAIL ();
1371 if (strcmp (fname, cwd3) != 0)
1372 printf ("getcwd after chdir is '%s' != '%s',"
1373 "get{c,}wd tests skipped\n", cwd3, fname);
1374 else
1375 {
1376 char getcwdbuf[sizeof fname - 3];
1377
1378 char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf);
1379 if (cwd4 != getcwdbuf
1380 || strcmp (getcwdbuf, fname) != 0)
1381 FAIL ();
1382
1383 cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1);
1384 if (cwd4 != getcwdbuf + 1
1385 || getcwdbuf[0] != fname[0]
1386 || strcmp (getcwdbuf + 1, fname) != 0)
1387 FAIL ();
1388
1389 #if __USE_FORTIFY_LEVEL >= 1
1390 CHK_FAIL_START
1391 if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf)
1392 != getcwdbuf + 2)
1393 FAIL ();
1394 CHK_FAIL_END
1395
1396 CHK_FAIL_START
1397 if (getcwd (getcwdbuf + 2, sizeof getcwdbuf)
1398 != getcwdbuf + 2)
1399 FAIL ();
1400 CHK_FAIL_END
1401 #endif
1402
1403 if (getwd (getcwdbuf) != getcwdbuf
1404 || strcmp (getcwdbuf, fname) != 0)
1405 FAIL ();
1406
1407 if (getwd (getcwdbuf + 1) != getcwdbuf + 1
1408 || strcmp (getcwdbuf + 1, fname) != 0)
1409 FAIL ();
1410
1411 #if __USE_FORTIFY_LEVEL >= 1
1412 CHK_FAIL_START
1413 if (getwd (getcwdbuf + 2) != getcwdbuf + 2)
1414 FAIL ();
1415 CHK_FAIL_END
1416 #endif
1417 }
1418
1419 if (chdir (cwd1) != 0)
1420 FAIL ();
1421 free (cwd3);
1422 }
1423
1424 free (cwd1);
1425 free (cwd2);
1426 *enddir = '/';
1427 if (unlink (fname) != 0)
1428 FAIL ();
1429
1430 *enddir = '\0';
1431 if (rmdir (fname) != 0)
1432 FAIL ();
1433
1434
1435 #if PATH_MAX > 0
1436 char largebuf[PATH_MAX];
1437 char *realres = realpath (".", largebuf);
1438 if (realres != largebuf)
1439 FAIL ();
1440
1441 # if __USE_FORTIFY_LEVEL >= 1
1442 CHK_FAIL_START
1443 char realbuf[1];
1444 realres = realpath (".", realbuf);
1445 if (realres != realbuf)
1446 FAIL ();
1447 CHK_FAIL_END
1448 # endif
1449 #endif
1450
1451 if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL)
1452 {
1453 assert (MB_CUR_MAX <= 10);
1454
1455 /* First a simple test. */
1456 char enough[10];
1457 if (wctomb (enough, L'A') != 1)
1458 FAIL ();
1459
1460 #if __USE_FORTIFY_LEVEL >= 1
1461 /* We know the wchar_t encoding is ISO 10646. So pick a
1462 character which has a multibyte representation which does not
1463 fit. */
1464 CHK_FAIL_START
1465 char smallbuf[2];
1466 if (wctomb (smallbuf, L'\x100') != 2)
1467 FAIL ();
1468 CHK_FAIL_END
1469 #endif
1470
1471 mbstate_t s;
1472 memset (&s, '\0', sizeof (s));
1473 if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D')
1474 FAIL ();
1475
1476 #if __USE_FORTIFY_LEVEL >= 1
1477 /* We know the wchar_t encoding is ISO 10646. So pick a
1478 character which has a multibyte representation which does not
1479 fit. */
1480 CHK_FAIL_START
1481 char smallbuf[1];
1482 if (wcrtomb (smallbuf, L'\x100', &s) != 2)
1483 FAIL ();
1484 CHK_FAIL_END
1485
1486 /* Same input with a large enough buffer and we're good. */
1487 char bigenoughbuf[2];
1488 if (wcrtomb (bigenoughbuf, L'\x100', &s) != 2)
1489 FAIL ();
1490 #endif
1491
1492 wchar_t wenough[10];
1493 memset (&s, '\0', sizeof (s));
1494 const char *cp = "A";
1495 if (mbsrtowcs (wenough, &cp, 10, &s) != 1
1496 || wcscmp (wenough, L"A") != 0)
1497 FAIL ();
1498
1499 cp = "BC";
1500 if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2
1501 || wcscmp (wenough, L"BC") != 0)
1502 FAIL ();
1503
1504 #if __USE_FORTIFY_LEVEL >= 1
1505 CHK_FAIL_START
1506 wchar_t wsmallbuf[2];
1507 cp = "ABC";
1508 mbsrtowcs (wsmallbuf, &cp, 10, &s);
1509 CHK_FAIL_END
1510 #endif
1511
1512 /* Bug 29030 regresion check */
1513 cp = "HelloWorld";
1514 if (mbsrtowcs (NULL, &cp, (size_t)-1, &s) != 10)
1515 FAIL ();
1516
1517 cp = "A";
1518 if (mbstowcs (wenough, cp, 10) != 1
1519 || wcscmp (wenough, L"A") != 0)
1520 FAIL ();
1521
1522 cp = "DEF";
1523 if (mbstowcs (wenough, cp, l0 + 10) != 3
1524 || wcscmp (wenough, L"DEF") != 0)
1525 FAIL ();
1526
1527 #if __USE_FORTIFY_LEVEL >= 1
1528 CHK_FAIL_START
1529 wchar_t wsmallbuf[2];
1530 cp = "ABC";
1531 mbstowcs (wsmallbuf, cp, 10);
1532 CHK_FAIL_END
1533 #endif
1534
1535 memset (&s, '\0', sizeof (s));
1536 cp = "ABC";
1537 wcscpy (wenough, L"DEF");
1538 if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1
1539 || wcscmp (wenough, L"AEF") != 0)
1540 FAIL ();
1541
1542 cp = "IJ";
1543 if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1
1544 || wcscmp (wenough, L"IEF") != 0)
1545 FAIL ();
1546
1547 #if __USE_FORTIFY_LEVEL >= 1
1548 CHK_FAIL_START
1549 wchar_t wsmallbuf[2];
1550 cp = "ABC";
1551 mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s);
1552 CHK_FAIL_END
1553 #endif
1554
1555 memset (&s, '\0', sizeof (s));
1556 const wchar_t *wcp = L"A";
1557 if (wcsrtombs (enough, &wcp, 10, &s) != 1
1558 || strcmp (enough, "A") != 0)
1559 FAIL ();
1560
1561 wcp = L"BC";
1562 if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2
1563 || strcmp (enough, "BC") != 0)
1564 FAIL ();
1565
1566 #if __USE_FORTIFY_LEVEL >= 1
1567 CHK_FAIL_START
1568 char smallbuf[2];
1569 wcp = L"ABC";
1570 wcsrtombs (smallbuf, &wcp, 10, &s);
1571 CHK_FAIL_END
1572 #endif
1573
1574 memset (enough, 'Z', sizeof (enough));
1575 wcp = L"EF";
1576 if (wcstombs (enough, wcp, 10) != 2
1577 || strcmp (enough, "EF") != 0)
1578 FAIL ();
1579
1580 wcp = L"G";
1581 if (wcstombs (enough, wcp, l0 + 10) != 1
1582 || strcmp (enough, "G") != 0)
1583 FAIL ();
1584
1585 #if __USE_FORTIFY_LEVEL >= 1
1586 CHK_FAIL_START
1587 char smallbuf[2];
1588 wcp = L"ABC";
1589 wcstombs (smallbuf, wcp, 10);
1590 CHK_FAIL_END
1591 #endif
1592
1593 memset (&s, '\0', sizeof (s));
1594 wcp = L"AB";
1595 if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1
1596 || strcmp (enough, "A") != 0)
1597 FAIL ();
1598
1599 wcp = L"BCD";
1600 if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1
1601 || strcmp (enough, "B") != 0)
1602 FAIL ();
1603
1604 #if __USE_FORTIFY_LEVEL >= 1
1605 CHK_FAIL_START
1606 char smallbuf[2];
1607 wcp = L"ABC";
1608 wcsnrtombs (smallbuf, &wcp, 3, 10, &s);
1609 CHK_FAIL_END
1610 #endif
1611 }
1612 else
1613 {
1614 puts ("cannot set locale");
1615 ret = 1;
1616 }
1617
1618 int fd;
1619
1620 #ifdef _GNU_SOURCE
1621 fd = posix_openpt (O_RDWR);
1622 if (fd != -1)
1623 {
1624 char enough[1000];
1625 if (ptsname_r (fd, enough, sizeof (enough)) != 0)
1626 FAIL ();
1627
1628 #if __USE_FORTIFY_LEVEL >= 1
1629 CHK_FAIL_START
1630 char smallbuf[2];
1631 if (ptsname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
1632 FAIL ();
1633 CHK_FAIL_END
1634 #endif
1635 close (fd);
1636 }
1637 #endif
1638
1639 #if PATH_MAX > 0
1640 confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf));
1641 # if __USE_FORTIFY_LEVEL >= 1
1642 CHK_FAIL_START
1643 char smallbuf[1];
1644 confstr (_CS_GNU_LIBC_VERSION, smallbuf, sizeof (largebuf));
1645 CHK_FAIL_END
1646 # endif
1647 #endif
1648
1649 gid_t grpslarge[5];
1650 int ngr = getgroups (5, grpslarge);
1651 asm volatile ("" : : "r" (ngr));
1652 #if __USE_FORTIFY_LEVEL >= 1
1653 CHK_FAIL_START
1654 char smallbuf[1];
1655 ngr = getgroups (5, (gid_t *) smallbuf);
1656 asm volatile ("" : : "r" (ngr));
1657 CHK_FAIL_END
1658 #endif
1659
1660 fd = open (_PATH_TTY, O_RDONLY);
1661 if (fd != -1)
1662 {
1663 char enough[1000];
1664 if (ttyname_r (fd, enough, sizeof (enough)) != 0)
1665 FAIL ();
1666
1667 #if __USE_FORTIFY_LEVEL >= 1
1668 CHK_FAIL_START
1669 char smallbuf[2];
1670 if (ttyname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
1671 FAIL ();
1672 CHK_FAIL_END
1673 #endif
1674 close (fd);
1675 }
1676
1677 char hostnamelarge[1000];
1678 gethostname (hostnamelarge, sizeof (hostnamelarge));
1679 #if __USE_FORTIFY_LEVEL >= 1
1680 CHK_FAIL_START
1681 char smallbuf[1];
1682 gethostname (smallbuf, sizeof (hostnamelarge));
1683 CHK_FAIL_END
1684 #endif
1685
1686 char loginlarge[1000];
1687 getlogin_r (loginlarge, sizeof (hostnamelarge));
1688 #if __USE_FORTIFY_LEVEL >= 1
1689 CHK_FAIL_START
1690 char smallbuf[1];
1691 getlogin_r (smallbuf, sizeof (loginlarge));
1692 CHK_FAIL_END
1693 #endif
1694
1695 char domainnamelarge[1000];
1696 int res = getdomainname (domainnamelarge, sizeof (domainnamelarge));
1697 asm volatile ("" : : "r" (res));
1698 #if __USE_FORTIFY_LEVEL >= 1
1699 CHK_FAIL_START
1700 char smallbuf[1];
1701 res = getdomainname (smallbuf, sizeof (domainnamelarge));
1702 asm volatile ("" : : "r" (res));
1703 CHK_FAIL_END
1704 #endif
1705
1706 fd_set s;
1707 FD_ZERO (&s);
1708
1709 FD_SET (FD_SETSIZE - 1, &s);
1710 #if __USE_FORTIFY_LEVEL >= 1
1711 CHK_FAIL_START
1712 FD_SET (FD_SETSIZE, &s);
1713 CHK_FAIL_END
1714
1715 CHK_FAIL_START
1716 FD_SET (l0 + FD_SETSIZE, &s);
1717 CHK_FAIL_END
1718 #endif
1719
1720 FD_CLR (FD_SETSIZE - 1, &s);
1721 #if __USE_FORTIFY_LEVEL >= 1
1722 CHK_FAIL_START
1723 FD_CLR (FD_SETSIZE, &s);
1724 CHK_FAIL_END
1725
1726 CHK_FAIL_START
1727 FD_SET (l0 + FD_SETSIZE, &s);
1728 CHK_FAIL_END
1729 #endif
1730
1731 FD_ISSET (FD_SETSIZE - 1, &s);
1732 #if __USE_FORTIFY_LEVEL >= 1
1733 CHK_FAIL_START
1734 FD_ISSET (FD_SETSIZE, &s);
1735 CHK_FAIL_END
1736
1737 CHK_FAIL_START
1738 FD_ISSET (l0 + FD_SETSIZE, &s);
1739 CHK_FAIL_END
1740 #endif
1741
1742 struct pollfd fds[1];
1743 fds[0].fd = STDOUT_FILENO;
1744 fds[0].events = POLLOUT;
1745 poll (fds, 1, 0);
1746 #if __USE_FORTIFY_LEVEL >= 1
1747 CHK_FAIL_START
1748 poll (fds, 2, 0);
1749 CHK_FAIL_END
1750
1751 CHK_FAIL_START
1752 poll (fds, l0 + 2, 0);
1753 CHK_FAIL_END
1754 #endif
1755 #ifdef _GNU_SOURCE
1756 ppoll (fds, 1, NULL, NULL);
1757 # if __USE_FORTIFY_LEVEL >= 1
1758 CHK_FAIL_START
1759 ppoll (fds, 2, NULL, NULL);
1760 CHK_FAIL_END
1761
1762 CHK_FAIL_START
1763 ppoll (fds, l0 + 2, NULL, NULL);
1764 CHK_FAIL_END
1765 # endif
1766 #endif
1767
1768 return ret;
1769 }
1770