debug/tst-chk1.c

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