Generic __longjmp.c.
[kopensolaris-gnu/glibc.git] / debug / tst-chk1.c
1 /* Copyright (C) 2004, 2005 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Jakub Jelinek <jakub@redhat.com>, 2004.
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, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <assert.h>
21 #include <fcntl.h>
22 #include <locale.h>
23 #include <paths.h>
24 #include <setjmp.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <wchar.h>
31 #include <sys/socket.h>
32 #include <sys/un.h>
33
34 char *temp_filename;
35 static void do_prepare (void);
36 static int do_test (void);
37 #define PREPARE(argc, argv) do_prepare ()
38 #define TEST_FUNCTION do_test ()
39 #include "../test-skeleton.c"
40
41 static void
42 do_prepare (void)
43 {
44   int temp_fd = create_temp_file ("tst-chk1.", &temp_filename);
45   if (temp_fd == -1)
46     {
47       printf ("cannot create temporary file: %m\n");
48       exit (1);
49     }
50
51   const char *strs = "abcdefgh\nABCDEFGHI\nabcdefghij\nABCDEFGHIJ";
52   if (write (temp_fd, strs, strlen (strs)) != strlen (strs))
53     {
54       puts ("could not write test strings into file");
55       unlink (temp_filename);
56       exit (1);
57     }
58 }
59
60 volatile int chk_fail_ok;
61 volatile int ret;
62 jmp_buf chk_fail_buf;
63
64 static void
65 handler (int sig)
66 {
67   if (chk_fail_ok)
68     {
69       chk_fail_ok = 0;
70       longjmp (chk_fail_buf, 1);
71     }
72   else
73     _exit (127);
74 }
75
76 char buf[10];
77 wchar_t wbuf[10];
78 volatile size_t l0;
79 volatile char *p;
80 volatile wchar_t *wp;
81 const char *str1 = "JIHGFEDCBA";
82 const char *str2 = "F";
83 const char *str3 = "%s%n%s%n";
84 const char *str4 = "Hello, ";
85 const char *str5 = "World!\n";
86 const wchar_t *wstr1 = L"JIHGFEDCBA";
87 const wchar_t *wstr2 = L"F";
88 const wchar_t *wstr3 = L"%s%n%s%n";
89 const wchar_t *wstr4 = L"Hello, ";
90 const wchar_t *wstr5 = L"World!\n";
91 char buf2[10] = "%s";
92 int num1 = 67;
93 int num2 = 987654;
94
95 #define FAIL() \
96   do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0)
97 #define CHK_FAIL_START \
98   chk_fail_ok = 1;                              \
99   if (! setjmp (chk_fail_buf))                  \
100     {
101 #define CHK_FAIL_END \
102       chk_fail_ok = 0;                          \
103       FAIL ();                                  \
104     }
105 #if __USE_FORTIFY_LEVEL >= 2
106 #define CHK_FAIL2_START CHK_FAIL_START
107 #define CHK_FAIL2_END CHK_FAIL_END
108 #else
109 #define CHK_FAIL2_START
110 #define CHK_FAIL2_END
111 #endif
112
113 static int
114 do_test (void)
115 {
116   struct sigaction sa;
117   sa.sa_handler = handler;
118   sa.sa_flags = 0;
119   sigemptyset (&sa.sa_mask);
120
121   sigaction (SIGABRT, &sa, NULL);
122
123   /* Avoid all the buffer overflow messages on stderr.  */
124   int fd = open (_PATH_DEVNULL, O_WRONLY);
125   if (fd == -1)
126     close (STDERR_FILENO);
127   else
128     {
129       dup2 (fd, STDERR_FILENO);
130       close (fd);
131     }
132   setenv ("LIBC_FATAL_STDERR_", "1", 1);
133
134   struct A { char buf1[9]; char buf2[1]; } a;
135   struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;
136
137   printf ("Test checking routines at fortify level %d\n",
138 #ifdef __USE_FORTIFY_LEVEL
139           (int) __USE_FORTIFY_LEVEL
140 #else
141           0
142 #endif
143           );
144
145   /* These ops can be done without runtime checking of object size.  */
146   memcpy (buf, "abcdefghij", 10);
147   memmove (buf + 1, buf, 9);
148   if (memcmp (buf, "aabcdefghi", 10))
149     FAIL ();
150
151   if (mempcpy (buf + 5, "abcde", 5) != buf + 10
152       || memcmp (buf, "aabcdabcde", 10))
153     FAIL ();
154
155   memset (buf + 8, 'j', 2);
156   if (memcmp (buf, "aabcdabcjj", 10))
157     FAIL ();
158
159   strcpy (buf + 4, "EDCBA");
160   if (memcmp (buf, "aabcEDCBA", 10))
161     FAIL ();
162
163   if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
164     FAIL ();
165
166   strncpy (buf + 6, "X", 4);
167   if (memcmp (buf, "aabcEDX\0\0", 10))
168     FAIL ();
169
170   if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10))
171     FAIL ();
172
173   if (snprintf (buf + 7, 3, "%s", "987654") != 6
174       || memcmp (buf, "aabcEDX98", 10))
175     FAIL ();
176
177   /* These ops need runtime checking, but shouldn't __chk_fail.  */
178   memcpy (buf, "abcdefghij", l0 + 10);
179   memmove (buf + 1, buf, l0 + 9);
180   if (memcmp (buf, "aabcdefghi", 10))
181     FAIL ();
182
183   if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10
184       || memcmp (buf, "aabcdabcde", 10))
185     FAIL ();
186
187   memset (buf + 8, 'j', l0 + 2);
188   if (memcmp (buf, "aabcdabcjj", 10))
189     FAIL ();
190
191   strcpy (buf + 4, str1 + 5);
192   if (memcmp (buf, "aabcEDCBA", 10))
193     FAIL ();
194
195   if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
196     FAIL ();
197
198   strncpy (buf + 6, "X", l0 + 4);
199   if (memcmp (buf, "aabcEDX\0\0", 10))
200     FAIL ();
201
202   if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7
203       || memcmp (buf, "aabcEcd\0\0", 10))
204     FAIL ();
205
206   if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10))
207     FAIL ();
208
209   if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10))
210     FAIL ();
211
212   buf[l0 + 8] = '\0';
213   strcat (buf, "A");
214   if (memcmp (buf, "aabcEcd9A", 10))
215     FAIL ();
216
217   buf[l0 + 7] = '\0';
218   strncat (buf, "ZYXWV", l0 + 2);
219   if (memcmp (buf, "aabcEcdZY", 10))
220     FAIL ();
221
222   memcpy (a.buf1, "abcdefghij", l0 + 10);
223   memmove (a.buf1 + 1, a.buf1, l0 + 9);
224   if (memcmp (a.buf1, "aabcdefghi", 10))
225     FAIL ();
226
227   if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10
228       || memcmp (a.buf1, "aabcdabcde", 10))
229     FAIL ();
230
231   memset (a.buf1 + 8, 'j', l0 + 2);
232   if (memcmp (a.buf1, "aabcdabcjj", 10))
233     FAIL ();
234
235 #if __USE_FORTIFY_LEVEL < 2
236   /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
237      and sufficient GCC support, as the string operations overflow
238      from a.buf1 into a.buf2.  */
239   strcpy (a.buf1 + 4, str1 + 5);
240   if (memcmp (a.buf1, "aabcEDCBA", 10))
241     FAIL ();
242
243   if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9
244       || memcmp (a.buf1, "aabcEDCBF", 10))
245     FAIL ();
246
247   strncpy (a.buf1 + 6, "X", l0 + 4);
248   if (memcmp (a.buf1, "aabcEDX\0\0", 10))
249     FAIL ();
250
251   if (sprintf (a.buf1 + 7, "%d", num1) != 2
252       || memcmp (a.buf1, "aabcEDX67", 10))
253     FAIL ();
254
255   if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6
256       || memcmp (a.buf1, "aabcEDX98", 10))
257     FAIL ();
258
259   a.buf1[l0 + 8] = '\0';
260   strcat (a.buf1, "A");
261   if (memcmp (a.buf1, "aabcEDX9A", 10))
262     FAIL ();
263
264   a.buf1[l0 + 7] = '\0';
265   strncat (a.buf1, "ZYXWV", l0 + 2);
266   if (memcmp (a.buf1, "aabcEDXZY", 10))
267     FAIL ();
268
269 #endif
270
271 #if __USE_FORTIFY_LEVEL >= 1
272   /* Now check if all buffer overflows are caught at runtime.  */
273
274   CHK_FAIL_START
275   memcpy (buf + 1, "abcdefghij", l0 + 10);
276   CHK_FAIL_END
277
278   CHK_FAIL_START
279   memmove (buf + 2, buf + 1, l0 + 9);
280   CHK_FAIL_END
281
282   CHK_FAIL_START
283   p = mempcpy (buf + 6, "abcde", l0 + 5);
284   CHK_FAIL_END
285
286   CHK_FAIL_START
287   memset (buf + 9, 'j', l0 + 2);
288   CHK_FAIL_END
289
290   CHK_FAIL_START
291   strcpy (buf + 5, str1 + 5);
292   CHK_FAIL_END
293
294   CHK_FAIL_START
295   p = stpcpy (buf + 9, str2);
296   CHK_FAIL_END
297
298   CHK_FAIL_START
299   strncpy (buf + 7, "X", l0 + 4);
300   CHK_FAIL_END
301
302   CHK_FAIL_START
303   stpncpy (buf + 6, "cd", l0 + 5);
304   CHK_FAIL_END
305
306   CHK_FAIL_START
307   sprintf (buf + 8, "%d", num1);
308   CHK_FAIL_END
309
310   CHK_FAIL_START
311   snprintf (buf + 8, l0 + 3, "%d", num2);
312   CHK_FAIL_END
313
314   memcpy (buf, str1 + 2, l0 + 9);
315   CHK_FAIL_START
316   strcat (buf, "AB");
317   CHK_FAIL_END
318
319   memcpy (buf, str1 + 3, l0 + 8);
320   CHK_FAIL_START
321   strncat (buf, "ZYXWV", l0 + 3);
322   CHK_FAIL_END
323
324   CHK_FAIL_START
325   memcpy (a.buf1 + 1, "abcdefghij", l0 + 10);
326   CHK_FAIL_END
327
328   CHK_FAIL_START
329   memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9);
330   CHK_FAIL_END
331
332   CHK_FAIL_START
333   p = mempcpy (a.buf1 + 6, "abcde", l0 + 5);
334   CHK_FAIL_END
335
336   CHK_FAIL_START
337   memset (a.buf1 + 9, 'j', l0 + 2);
338   CHK_FAIL_END
339
340 #if __USE_FORTIFY_LEVEL >= 2
341 # define O 0
342 #else
343 # define O 1
344 #endif
345
346   CHK_FAIL_START
347   strcpy (a.buf1 + (O + 4), str1 + 5);
348   CHK_FAIL_END
349
350   CHK_FAIL_START
351   p = stpcpy (a.buf1 + (O + 8), str2);
352   CHK_FAIL_END
353
354   CHK_FAIL_START
355   strncpy (a.buf1 + (O + 6), "X", l0 + 4);
356   CHK_FAIL_END
357
358   CHK_FAIL_START
359   sprintf (a.buf1 + (O + 7), "%d", num1);
360   CHK_FAIL_END
361
362   CHK_FAIL_START
363   snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2);
364   CHK_FAIL_END
365
366   memcpy (a.buf1, str1 + (3 - O), l0 + 8 + O);
367   CHK_FAIL_START
368   strcat (a.buf1, "AB");
369   CHK_FAIL_END
370
371   memcpy (a.buf1, str1 + (4 - O), l0 + 7 + O);
372   CHK_FAIL_START
373   strncat (a.buf1, "ZYXWV", l0 + 3);
374   CHK_FAIL_END
375 #endif
376
377
378   /* These ops can be done without runtime checking of object size.  */
379   wmemcpy (wbuf, L"abcdefghij", 10);
380   wmemmove (wbuf + 1, wbuf, 9);
381   if (wmemcmp (wbuf, L"aabcdefghi", 10))
382     FAIL ();
383
384   if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10
385       || wmemcmp (wbuf, L"aabcdabcde", 10))
386     FAIL ();
387
388   wmemset (wbuf + 8, L'j', 2);
389   if (wmemcmp (wbuf, L"aabcdabcjj", 10))
390     FAIL ();
391
392   wcscpy (wbuf + 4, L"EDCBA");
393   if (wmemcmp (wbuf, L"aabcEDCBA", 10))
394     FAIL ();
395
396   if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
397     FAIL ();
398
399   wcsncpy (wbuf + 6, L"X", 4);
400   if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
401     FAIL ();
402
403   if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0
404       || wmemcmp (wbuf, L"aabcEDX98", 10))
405     FAIL ();
406
407   if (swprintf (wbuf + 7, 3, L"64") != 2
408       || wmemcmp (wbuf, L"aabcEDX64", 10))
409     FAIL ();
410
411   /* These ops need runtime checking, but shouldn't __chk_fail.  */
412   wmemcpy (wbuf, L"abcdefghij", l0 + 10);
413   wmemmove (wbuf + 1, wbuf, l0 + 9);
414   if (wmemcmp (wbuf, L"aabcdefghi", 10))
415     FAIL ();
416
417   if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10
418       || wmemcmp (wbuf, L"aabcdabcde", 10))
419     FAIL ();
420
421   wmemset (wbuf + 8, L'j', l0 + 2);
422   if (wmemcmp (wbuf, L"aabcdabcjj", 10))
423     FAIL ();
424
425   wcscpy (wbuf + 4, wstr1 + 5);
426   if (wmemcmp (wbuf, L"aabcEDCBA", 10))
427     FAIL ();
428
429   if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
430     FAIL ();
431
432   wcsncpy (wbuf + 6, L"X", l0 + 4);
433   if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
434     FAIL ();
435
436   if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7
437       || wmemcmp (wbuf, L"aabcEcd\0\0", 10))
438     FAIL ();
439
440   if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0
441       || wmemcmp (wbuf, L"aabcEcd98", 10))
442     FAIL ();
443
444   wbuf[l0 + 8] = L'\0';
445   wcscat (wbuf, L"A");
446   if (wmemcmp (wbuf, L"aabcEcd9A", 10))
447     FAIL ();
448
449   wbuf[l0 + 7] = L'\0';
450   wcsncat (wbuf, L"ZYXWV", l0 + 2);
451   if (wmemcmp (wbuf, L"aabcEcdZY", 10))
452     FAIL ();
453
454   wmemcpy (wa.buf1, L"abcdefghij", l0 + 10);
455   wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9);
456   if (wmemcmp (wa.buf1, L"aabcdefghi", 10))
457     FAIL ();
458
459   if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10
460       || wmemcmp (wa.buf1, L"aabcdabcde", 10))
461     FAIL ();
462
463   wmemset (wa.buf1 + 8, L'j', l0 + 2);
464   if (wmemcmp (wa.buf1, L"aabcdabcjj", 10))
465     FAIL ();
466
467 #if __USE_FORTIFY_LEVEL < 2
468   /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
469      and sufficient GCC support, as the string operations overflow
470      from a.buf1 into a.buf2.  */
471   wcscpy (wa.buf1 + 4, wstr1 + 5);
472   if (wmemcmp (wa.buf1, L"aabcEDCBA", 10))
473     FAIL ();
474
475   if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9
476       || wmemcmp (wa.buf1, L"aabcEDCBF", 10))
477     FAIL ();
478
479   wcsncpy (wa.buf1 + 6, L"X", l0 + 4);
480   if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10))
481     FAIL ();
482
483   if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0
484       || wmemcmp (wa.buf1, L"aabcEDX98", 10))
485     FAIL ();
486
487   wa.buf1[l0 + 8] = L'\0';
488   wcscat (wa.buf1, L"A");
489   if (wmemcmp (wa.buf1, L"aabcEDX9A", 10))
490     FAIL ();
491
492   wa.buf1[l0 + 7] = L'\0';
493   wcsncat (wa.buf1, L"ZYXWV", l0 + 2);
494   if (wmemcmp (wa.buf1, L"aabcEDXZY", 10))
495     FAIL ();
496
497 #endif
498
499 #if __USE_FORTIFY_LEVEL >= 1
500   /* Now check if all buffer overflows are caught at runtime.  */
501
502   CHK_FAIL_START
503   wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10);
504   CHK_FAIL_END
505
506   CHK_FAIL_START
507   wmemmove (wbuf + 2, wbuf + 1, l0 + 9);
508   CHK_FAIL_END
509
510   CHK_FAIL_START
511     wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5);
512   CHK_FAIL_END
513
514   CHK_FAIL_START
515   wmemset (wbuf + 9, L'j', l0 + 2);
516   CHK_FAIL_END
517
518   CHK_FAIL_START
519   wcscpy (wbuf + 5, wstr1 + 5);
520   CHK_FAIL_END
521
522   CHK_FAIL_START
523   wp = wcpcpy (wbuf + 9, wstr2);
524   CHK_FAIL_END
525
526   CHK_FAIL_START
527   wcsncpy (wbuf + 7, L"X", l0 + 4);
528   CHK_FAIL_END
529
530   CHK_FAIL_START
531   wcpncpy (wbuf + 6, L"cd", l0 + 5);
532   CHK_FAIL_END
533
534   wmemcpy (wbuf, wstr1 + 2, l0 + 9);
535   CHK_FAIL_START
536   wcscat (wbuf, L"AB");
537   CHK_FAIL_END
538
539   wmemcpy (wbuf, wstr1 + 3, l0 + 8);
540   CHK_FAIL_START
541   wcsncat (wbuf, L"ZYXWV", l0 + 3);
542   CHK_FAIL_END
543
544   CHK_FAIL_START
545   wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10);
546   CHK_FAIL_END
547
548   CHK_FAIL_START
549   wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9);
550   CHK_FAIL_END
551
552   CHK_FAIL_START
553   wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5);
554   CHK_FAIL_END
555
556   CHK_FAIL_START
557   wmemset (wa.buf1 + 9, L'j', l0 + 2);
558   CHK_FAIL_END
559
560 #if __USE_FORTIFY_LEVEL >= 2
561 # define O 0
562 #else
563 # define O 1
564 #endif
565
566   CHK_FAIL_START
567   wcscpy (wa.buf1 + (O + 4), wstr1 + 5);
568   CHK_FAIL_END
569
570   CHK_FAIL_START
571   wp = wcpcpy (wa.buf1 + (O + 8), wstr2);
572   CHK_FAIL_END
573
574   CHK_FAIL_START
575   wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4);
576   CHK_FAIL_END
577
578   wmemcpy (wa.buf1, wstr1 + (3 - O), l0 + 8 + O);
579   CHK_FAIL_START
580   wcscat (wa.buf1, L"AB");
581   CHK_FAIL_END
582
583   wmemcpy (wa.buf1, wstr1 + (4 - O), l0 + 7 + O);
584   CHK_FAIL_START
585   wcsncat (wa.buf1, L"ZYXWV", l0 + 3);
586   CHK_FAIL_END
587 #endif
588
589
590   /* Now checks for %n protection.  */
591
592   /* Constant literals passed directly are always ok
593      (even with warnings about possible bugs from GCC).  */
594   int n1, n2;
595   if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2
596       || n1 != 1 || n2 != 2)
597     FAIL ();
598
599   /* In this case the format string is not known at compile time,
600      but resides in read-only memory, so is ok.  */
601   if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2
602       || n1 != 1 || n2 != 2)
603     FAIL ();
604
605   strcpy (buf2 + 2, "%n%s%n");
606   /* When the format string is writable and contains %n,
607      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
608   CHK_FAIL2_START
609   if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2)
610     FAIL ();
611   CHK_FAIL2_END
612
613   CHK_FAIL2_START
614   if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2)
615     FAIL ();
616   CHK_FAIL2_END
617
618   /* But if there is no %n, even writable format string
619      should work.  */
620   buf2[6] = '\0';
621   if (sprintf (buf, buf2 + 4, str2) != 1)
622     FAIL ();
623
624   /* Constant literals passed directly are always ok
625      (even with warnings about possible bugs from GCC).  */
626   if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14
627       || n1 != 7 || n2 != 14)
628     FAIL ();
629
630   /* In this case the format string is not known at compile time,
631      but resides in read-only memory, so is ok.  */
632   if (printf (str3, str4, &n1, str5, &n2) != 14
633       || n1 != 7 || n2 != 14)
634     FAIL ();
635
636   strcpy (buf2 + 2, "%n%s%n");
637   /* When the format string is writable and contains %n,
638      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
639   CHK_FAIL2_START
640   if (printf (buf2, str4, &n1, str5, &n1) != 14)
641     FAIL ();
642   CHK_FAIL2_END
643
644   /* But if there is no %n, even writable format string
645      should work.  */
646   buf2[6] = '\0';
647   if (printf (buf2 + 4, str5) != 7)
648     FAIL ();
649
650   FILE *fp = stdout;
651
652   /* Constant literals passed directly are always ok
653      (even with warnings about possible bugs from GCC).  */
654   if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14
655       || n1 != 7 || n2 != 14)
656     FAIL ();
657
658   /* In this case the format string is not known at compile time,
659      but resides in read-only memory, so is ok.  */
660   if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14
661       || n1 != 7 || n2 != 14)
662     FAIL ();
663
664   strcpy (buf2 + 2, "%n%s%n");
665   /* When the format string is writable and contains %n,
666      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
667   CHK_FAIL2_START
668   if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14)
669     FAIL ();
670   CHK_FAIL2_END
671
672   /* But if there is no %n, even writable format string
673      should work.  */
674   buf2[6] = '\0';
675   if (fprintf (fp, buf2 + 4, str5) != 7)
676     FAIL ();
677
678   if (freopen (temp_filename, "r", stdin) == NULL)
679     {
680       puts ("could not open temporary file");
681       exit (1);
682     }
683
684   if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9))
685     FAIL ();
686   if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10))
687     FAIL ();
688
689 #if __USE_FORTIFY_LEVEL >= 1
690   CHK_FAIL_START
691   if (gets (buf) != buf)
692     FAIL ();
693   CHK_FAIL_END
694 #endif
695
696   rewind (stdin);
697
698   if (fgets (buf, sizeof (buf), stdin) != buf
699       || memcmp (buf, "abcdefgh\n", 10))
700     FAIL ();
701   if (fgets (buf, sizeof (buf), stdin) != buf || memcmp (buf, "ABCDEFGHI", 10))
702     FAIL ();
703
704   rewind (stdin);
705
706   if (fgets (buf, l0 + sizeof (buf), stdin) != buf
707       || memcmp (buf, "abcdefgh\n", 10))
708     FAIL ();
709
710 #if __USE_FORTIFY_LEVEL >= 1
711   CHK_FAIL_START
712   if (fgets (buf, sizeof (buf) + 1, stdin) != buf)
713     FAIL ();
714   CHK_FAIL_END
715
716   CHK_FAIL_START
717   if (fgets (buf, l0 + sizeof (buf) + 1, stdin) != buf)
718     FAIL ();
719   CHK_FAIL_END
720 #endif
721
722   rewind (stdin);
723
724   if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
725       || memcmp (buf, "abcdefgh\n", 10))
726     FAIL ();
727   if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
728       || memcmp (buf, "ABCDEFGHI", 10))
729     FAIL ();
730
731   rewind (stdin);
732
733   if (fgets_unlocked (buf, l0 + sizeof (buf), stdin) != buf
734       || memcmp (buf, "abcdefgh\n", 10))
735     FAIL ();
736
737 #if __USE_FORTIFY_LEVEL >= 1
738   CHK_FAIL_START
739   if (fgets_unlocked (buf, sizeof (buf) + 1, stdin) != buf)
740     FAIL ();
741   CHK_FAIL_END
742
743   CHK_FAIL_START
744   if (fgets_unlocked (buf, l0 + sizeof (buf) + 1, stdin) != buf)
745     FAIL ();
746   CHK_FAIL_END
747 #endif
748
749   lseek (fileno (stdin), 0, SEEK_SET);
750
751   if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
752       || memcmp (buf, "abcdefgh\n", 9))
753     FAIL ();
754   if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
755       || memcmp (buf, "ABCDEFGHI", 9))
756     FAIL ();
757
758   lseek (fileno (stdin), 0, SEEK_SET);
759
760   if (read (fileno (stdin), buf, l0 + sizeof (buf) - 1) != sizeof (buf) - 1
761       || memcmp (buf, "abcdefgh\n", 9))
762     FAIL ();
763
764 #if __USE_FORTIFY_LEVEL >= 1
765   CHK_FAIL_START
766   if (read (fileno (stdin), buf, sizeof (buf) + 1) != sizeof (buf) + 1)
767     FAIL ();
768   CHK_FAIL_END
769 #endif
770
771   if (pread (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
772       != sizeof (buf) - 1
773       || memcmp (buf, "\nABCDEFGH", 9))
774     FAIL ();
775   if (pread (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
776       || memcmp (buf, "abcdefgh\n", 9))
777     FAIL ();
778   if (pread (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
779       != sizeof (buf) - 1
780       || memcmp (buf, "h\nABCDEFG", 9))
781     FAIL ();
782
783 #if __USE_FORTIFY_LEVEL >= 1
784   CHK_FAIL_START
785   if (pread (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
786       != sizeof (buf) + 1)
787     FAIL ();
788   CHK_FAIL_END
789 #endif
790
791   if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
792       != sizeof (buf) - 1
793       || memcmp (buf, "\nABCDEFGH", 9))
794     FAIL ();
795   if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
796       || memcmp (buf, "abcdefgh\n", 9))
797     FAIL ();
798   if (pread64 (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
799       != sizeof (buf) - 1
800       || memcmp (buf, "h\nABCDEFG", 9))
801     FAIL ();
802
803 #if __USE_FORTIFY_LEVEL >= 1
804   CHK_FAIL_START
805   if (pread64 (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
806       != sizeof (buf) + 1)
807     FAIL ();
808   CHK_FAIL_END
809 #endif
810
811   if (freopen (temp_filename, "r", stdin) == NULL)
812     {
813       puts ("could not open temporary file");
814       exit (1);
815     }
816
817   if (fseek (stdin, 9 + 10 + 11, SEEK_SET))
818     {
819       puts ("could not seek in test file");
820       exit (1);
821     }
822
823 #if __USE_FORTIFY_LEVEL >= 1
824   CHK_FAIL_START
825   if (gets (buf) != buf)
826     FAIL ();
827   CHK_FAIL_END
828 #endif
829
830   /* Check whether missing N$ formats are detected.  */
831   CHK_FAIL2_START
832   printf ("%3$d\n", 1, 2, 3, 4);
833   CHK_FAIL2_END
834
835   CHK_FAIL2_START
836   fprintf (stdout, "%3$d\n", 1, 2, 3, 4);
837   CHK_FAIL2_END
838
839   CHK_FAIL2_START
840   sprintf (buf, "%3$d\n", 1, 2, 3, 4);
841   CHK_FAIL2_END
842
843   CHK_FAIL2_START
844   snprintf (buf, sizeof (buf), "%3$d\n", 1, 2, 3, 4);
845   CHK_FAIL2_END
846
847   int sp[2];
848   if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp))
849     FAIL ();
850   else
851     {
852       const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n";
853       if (send (sp[0], sendstr, strlen (sendstr), 0) != strlen (sendstr))
854         FAIL ();
855
856       char recvbuf[12];
857       if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK)
858           != sizeof recvbuf
859           || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
860         FAIL ();
861
862       if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK)
863           != sizeof recvbuf - 7
864           || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
865         FAIL ();
866
867 #if __USE_FORTIFY_LEVEL >= 1
868       CHK_FAIL_START
869       if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK)
870           != sizeof recvbuf)
871         FAIL ();
872       CHK_FAIL_END
873
874       CHK_FAIL_START
875       if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK)
876           != sizeof recvbuf - 3)
877         FAIL ();
878       CHK_FAIL_END
879 #endif
880
881       socklen_t sl;
882       struct sockaddr_un sa_un;
883
884       sl = sizeof (sa_un);
885       if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
886           != sizeof recvbuf
887           || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
888         FAIL ();
889
890       sl = sizeof (sa_un);
891       if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK,
892           &sa_un, &sl) != sizeof recvbuf - 7
893           || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
894         FAIL ();
895
896 #if __USE_FORTIFY_LEVEL >= 1
897       CHK_FAIL_START
898       sl = sizeof (sa_un);
899       if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
900           != sizeof recvbuf)
901         FAIL ();
902       CHK_FAIL_END
903
904       CHK_FAIL_START
905       sl = sizeof (sa_un);
906       if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK,
907           &sa_un, &sl) != sizeof recvbuf - 3)
908         FAIL ();
909       CHK_FAIL_END
910 #endif
911
912       close (sp[0]);
913       close (sp[1]);
914     }
915
916   char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo";
917   char *enddir = strchr (fname, '\0');
918   if (mkdtemp (fname) == NULL)
919     {
920       printf ("mkdtemp failed: %m\n");
921       return 1;
922     }
923   *enddir = '/';
924   if (symlink ("bar", fname) != 0)
925     FAIL ();
926
927   char readlinkbuf[4];
928   if (readlink (fname, readlinkbuf, 4) != 3
929       || memcmp (readlinkbuf, "bar", 3) != 0)
930     FAIL ();
931   if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3
932       || memcmp (readlinkbuf, "bbar", 4) != 0)
933     FAIL ();
934
935 #if __USE_FORTIFY_LEVEL >= 1
936   CHK_FAIL_START
937   if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3)
938     FAIL ();
939   CHK_FAIL_END
940
941   CHK_FAIL_START
942   if (readlink (fname, readlinkbuf + 3, 4) != 3)
943     FAIL ();
944   CHK_FAIL_END
945 #endif
946
947   char *cwd1 = getcwd (NULL, 0);
948   if (cwd1 == NULL)
949     FAIL ();
950
951   char *cwd2 = getcwd (NULL, 250);
952   if (cwd2 == NULL)
953     FAIL ();
954
955   if (cwd1 && cwd2)
956     {
957       if (strcmp (cwd1, cwd2) != 0)
958         FAIL ();
959
960       *enddir = '\0';
961       if (chdir (fname))
962         FAIL ();
963
964       char *cwd3 = getcwd (NULL, 0);
965       if (cwd3 == NULL)
966         FAIL ();
967       if (strcmp (fname, cwd3) != 0)
968         printf ("getcwd after chdir is '%s' != '%s',"
969                 "get{c,}wd tests skipped\n", cwd3, fname);
970       else
971         {
972           char getcwdbuf[sizeof fname - 3];
973
974           char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf);
975           if (cwd4 != getcwdbuf
976               || strcmp (getcwdbuf, fname) != 0)
977             FAIL ();
978
979           cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1);
980           if (cwd4 != getcwdbuf + 1
981               || getcwdbuf[0] != fname[0]
982               || strcmp (getcwdbuf + 1, fname) != 0)
983             FAIL ();
984
985 #if __USE_FORTIFY_LEVEL >= 1
986           CHK_FAIL_START
987           if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf)
988               != getcwdbuf + 2)
989             FAIL ();
990           CHK_FAIL_END
991
992           CHK_FAIL_START
993           if (getcwd (getcwdbuf + 2, sizeof getcwdbuf)
994               != getcwdbuf + 2)
995             FAIL ();
996           CHK_FAIL_END
997 #endif
998
999           if (getwd (getcwdbuf) != getcwdbuf
1000               || strcmp (getcwdbuf, fname) != 0)
1001             FAIL ();
1002
1003           if (getwd (getcwdbuf + 1) != getcwdbuf + 1
1004               || strcmp (getcwdbuf + 1, fname) != 0)
1005             FAIL ();
1006
1007 #if __USE_FORTIFY_LEVEL >= 1
1008           CHK_FAIL_START
1009           if (getwd (getcwdbuf + 2) != getcwdbuf + 2)
1010             FAIL ();
1011           CHK_FAIL_END
1012 #endif
1013         }
1014
1015       if (chdir (cwd1) != 0)
1016         FAIL ();
1017       free (cwd3);
1018     }
1019
1020   free (cwd1);
1021   free (cwd2);
1022   *enddir = '/';
1023   if (unlink (fname) != 0)
1024     FAIL ();
1025
1026   *enddir = '\0';
1027   if (rmdir (fname) != 0)
1028     FAIL ();
1029
1030
1031 #if PATH_MAX > 0
1032   char largebuf[PATH_MAX];
1033   char *realres = realpath (".", largebuf);
1034   if (realres != largebuf)
1035     FAIL ();
1036
1037 # if __USE_FORTIFY_LEVEL >= 1
1038   CHK_FAIL_START
1039   char realbuf[1];
1040   realres = realpath (".", realbuf);
1041   if (realres != realbuf)
1042     FAIL ();
1043   CHK_FAIL_END
1044 # endif
1045 #endif
1046
1047   if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL)
1048     {
1049       assert (MB_CUR_MAX <= 10);
1050
1051       /* First a simple test.  */
1052       char enough[10];
1053       if (wctomb (enough, L'A') != 1)
1054         FAIL ();
1055
1056 #if __USE_FORTIFY_LEVEL >= 1
1057       /* We know the wchar_t encoding is ISO 10646.  So pick a
1058          character which has a multibyte representation which does not
1059          fit.  */
1060       CHK_FAIL_START
1061       char smallbuf[2];
1062       if (wctomb (smallbuf, L'\x100') != 2)
1063         FAIL ();
1064       CHK_FAIL_END
1065 #endif
1066
1067       mbstate_t s;
1068       memset (&s, '\0', sizeof (s));
1069       if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D')
1070         FAIL ();
1071
1072 #if __USE_FORTIFY_LEVEL >= 1
1073       /* We know the wchar_t encoding is ISO 10646.  So pick a
1074          character which has a multibyte representation which does not
1075          fit.  */
1076       CHK_FAIL_START
1077       char smallbuf[2];
1078       if (wcrtomb (smallbuf, L'\x100', &s) != 2)
1079         FAIL ();
1080       CHK_FAIL_END
1081 #endif
1082
1083       wchar_t wenough[10];
1084       memset (&s, '\0', sizeof (s));
1085       const char *cp = "A";
1086       if (mbsrtowcs (wenough, &cp, 10, &s) != 1
1087           || wcscmp (wenough, L"A") != 0)
1088         FAIL ();
1089
1090       cp = "BC";
1091       if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2
1092           || wcscmp (wenough, L"BC") != 0)
1093         FAIL ();
1094
1095 #if __USE_FORTIFY_LEVEL >= 1
1096       CHK_FAIL_START
1097       wchar_t wsmallbuf[2];
1098       cp = "ABC";
1099       mbsrtowcs (wsmallbuf, &cp, 10, &s);
1100       CHK_FAIL_END
1101 #endif
1102
1103       cp = "A";
1104       if (mbstowcs (wenough, cp, 10) != 1
1105           || wcscmp (wenough, L"A") != 0)
1106         FAIL ();
1107
1108       cp = "DEF";
1109       if (mbstowcs (wenough, cp, l0 + 10) != 3
1110           || wcscmp (wenough, L"DEF") != 0)
1111         FAIL ();
1112
1113 #if __USE_FORTIFY_LEVEL >= 1
1114       CHK_FAIL_START
1115       wchar_t wsmallbuf[2];
1116       cp = "ABC";
1117       mbstowcs (wsmallbuf, cp, 10);
1118       CHK_FAIL_END
1119 #endif
1120
1121       memset (&s, '\0', sizeof (s));
1122       cp = "ABC";
1123       wcscpy (wenough, L"DEF");
1124       if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1
1125           || wcscmp (wenough, L"AEF") != 0)
1126         FAIL ();
1127
1128       cp = "IJ";
1129       if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1
1130           || wcscmp (wenough, L"IEF") != 0)
1131         FAIL ();
1132
1133 #if __USE_FORTIFY_LEVEL >= 1
1134       CHK_FAIL_START
1135       wchar_t wsmallbuf[2];
1136       cp = "ABC";
1137       mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s);
1138       CHK_FAIL_END
1139 #endif
1140
1141       memset (&s, '\0', sizeof (s));
1142       const wchar_t *wcp = L"A";
1143       if (wcsrtombs (enough, &wcp, 10, &s) != 1
1144           || strcmp (enough, "A") != 0)
1145         FAIL ();
1146
1147       wcp = L"BC";
1148       if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2
1149           || strcmp (enough, "BC") != 0)
1150         FAIL ();
1151
1152 #if __USE_FORTIFY_LEVEL >= 1
1153       CHK_FAIL_START
1154       char smallbuf[2];
1155       wcp = L"ABC";
1156       wcsrtombs (smallbuf, &wcp, 10, &s);
1157       CHK_FAIL_END
1158 #endif
1159
1160       memset (enough, 'Z', sizeof (enough));
1161       wcp = L"EF";
1162       if (wcstombs (enough, wcp, 10) != 2
1163           || strcmp (enough, "EF") != 0)
1164         FAIL ();
1165
1166       wcp = L"G";
1167       if (wcstombs (enough, wcp, l0 + 10) != 1
1168           || strcmp (enough, "G") != 0)
1169         FAIL ();
1170
1171 #if __USE_FORTIFY_LEVEL >= 1
1172       CHK_FAIL_START
1173       char smallbuf[2];
1174       wcp = L"ABC";
1175       wcstombs (smallbuf, wcp, 10);
1176       CHK_FAIL_END
1177 #endif
1178
1179       memset (&s, '\0', sizeof (s));
1180       wcp = L"AB";
1181       if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1
1182           || strcmp (enough, "A") != 0)
1183         FAIL ();
1184
1185       wcp = L"BCD";
1186       if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1
1187           || strcmp (enough, "B") != 0)
1188         FAIL ();
1189
1190 #if __USE_FORTIFY_LEVEL >= 1
1191       CHK_FAIL_START
1192       char smallbuf[2];
1193       wcp = L"ABC";
1194       wcsnrtombs (smallbuf, &wcp, 3, 10, &s);
1195       CHK_FAIL_END
1196 #endif
1197     }
1198   else
1199     {
1200       puts ("cannot set locale");
1201       ret = 1;
1202     }
1203
1204   fd = posix_openpt (O_RDWR);
1205   if (fd != -1)
1206     {
1207       char enough[1000];
1208       if (ptsname_r (fd, enough, sizeof (enough)) != 0)
1209         FAIL ();
1210
1211 #if __USE_FORTIFY_LEVEL >= 1
1212       CHK_FAIL_START
1213       char smallbuf[2];
1214       if (ptsname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
1215         FAIL ();
1216       CHK_FAIL_END
1217 #endif
1218       close (fd);
1219     }
1220
1221 #if PATH_MAX > 0
1222   confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf));
1223 # if __USE_FORTIFY_LEVEL >= 1
1224   CHK_FAIL_START
1225   char smallbuf[1];
1226   confstr (_CS_GNU_LIBC_VERSION, smallbuf, sizeof (largebuf));
1227   CHK_FAIL_END
1228 # endif
1229 #endif
1230
1231   gid_t grpslarge[5];
1232   int ngr = getgroups (5, grpslarge);
1233   asm volatile ("" : : "r" (ngr));
1234 #if __USE_FORTIFY_LEVEL >= 1
1235   CHK_FAIL_START
1236   char smallbuf[1];
1237   ngr = getgroups (5, (gid_t *) smallbuf);
1238   asm volatile ("" : : "r" (ngr));
1239   CHK_FAIL_END
1240 #endif
1241
1242   fd = open (_PATH_TTY, O_RDONLY);
1243   if (fd != -1)
1244     {
1245       char enough[1000];
1246       if (ttyname_r (fd, enough, sizeof (enough)) != 0)
1247         FAIL ();
1248
1249 #if __USE_FORTIFY_LEVEL >= 1
1250       CHK_FAIL_START
1251       char smallbuf[2];
1252       if (ttyname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
1253         FAIL ();
1254       CHK_FAIL_END
1255 #endif
1256       close (fd);
1257     }
1258
1259   char hostnamelarge[1000];
1260   gethostname (hostnamelarge, sizeof (hostnamelarge));
1261 #if __USE_FORTIFY_LEVEL >= 1
1262   CHK_FAIL_START
1263   char smallbuf[1];
1264   gethostname (smallbuf, sizeof (hostnamelarge));
1265   CHK_FAIL_END
1266 #endif
1267
1268   char loginlarge[1000];
1269   getlogin_r (loginlarge, sizeof (hostnamelarge));
1270 #if __USE_FORTIFY_LEVEL >= 1
1271   CHK_FAIL_START
1272   char smallbuf[1];
1273   getlogin_r (smallbuf, sizeof (loginlarge));
1274   CHK_FAIL_END
1275 #endif
1276
1277   char domainnamelarge[1000];
1278   int res = getdomainname (domainnamelarge, sizeof (domainnamelarge));
1279   asm volatile ("" : : "r" (res));
1280 #if __USE_FORTIFY_LEVEL >= 1
1281   CHK_FAIL_START
1282   char smallbuf[1];
1283   res = getdomainname (smallbuf, sizeof (domainnamelarge));
1284   asm volatile ("" : : "r" (res));
1285   CHK_FAIL_END
1286 #endif
1287
1288   return ret;
1289 }