debug/tst-chk1.c

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