PageRenderTime 63ms CodeModel.GetById 26ms RepoModel.GetById 1ms app.codeStats 0ms

/eglibc-2.14/libc/debug/tst-chk1.c

https://github.com/Scorpiion/Renux_cross_eglibc
C | 1459 lines | 1132 code | 261 blank | 66 comment | 467 complexity | 0570a24859f97fc286a0f96666200b1d MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, BSD-3-Clause, LGPL-2.0 
    

  1. /* Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
    2. 

  2.    This file is part of the GNU C Library.
    3. 

  3.    Contributed by Jakub Jelinek <jakub@redhat.com>, 2004.
    4. 

    5. 

  5.    The GNU C Library is free software; you can redistribute it and/or
    6. 

  6.    modify it under the terms of the GNU Lesser General Public
    7. 

  7.    License as published by the Free Software Foundation; either
    8. 

  8.    version 2.1 of the License, or (at your option) any later version.
    9. 

    10. 

  10.    The GNU C Library is distributed in the hope that it will be useful,
    11. 

  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13. 

  13.    Lesser General Public License for more details.
    14. 

    15. 

  15.    You should have received a copy of the GNU Lesser General Public
    16. 

  16.    License along with the GNU C Library; if not, write to the Free
    17. 

  17.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    18. 

  18.    02111-1307 USA.  */
    19. 

  19. 

  20. #include <assert.h>
    21. 

  21. #include <fcntl.h>
    22. 

  22. #include <locale.h>
    23. 

  23. #include <obstack.h>
    24. 

  24. #include <paths.h>
    25. 

  25. #include <setjmp.h>
    26. 

  26. #include <signal.h>
    27. 

  27. #include <stdio.h>
    28. 

  28. #include <stdlib.h>
    29. 

  29. #include <string.h>
    30. 

  30. #include <unistd.h>
    31. 

  31. #include <wchar.h>
    32. 

  32. #include <sys/socket.h>
    33. 

  33. #include <sys/un.h>
    34. 

  34. #include <gnu/option-groups.h>
    35. 

  35. 

  36. #define obstack_chunk_alloc malloc
    37. 

  37. #define obstack_chunk_free free
    38. 

  38. 

  39. char *temp_filename;
    40. 

  40. static void do_prepare (void);
    41. 

  41. static int do_test (void);
    42. 

  42. #define PREPARE(argc, argv) do_prepare ()
    43. 

  43. #define TEST_FUNCTION do_test ()
    44. 

  44. #include "../test-skeleton.c"
    45. 

  45. 

  46. static void
    47. 

  47. do_prepare (void)
    48. 

  48. {
    49. 

  49.   int temp_fd = create_temp_file ("tst-chk1.", &temp_filename);
    50. 

  50.   if (temp_fd == -1)
    51. 

  51.     {
    52. 

  52.       printf ("cannot create temporary file: %m\n");
    53. 

  53.       exit (1);
    54. 

  54.     }
    55. 

  55. 

  56.   const char *strs = "abcdefgh\nABCDEFGHI\nabcdefghij\nABCDEFGHIJ";
    57. 

  57.   if ((size_t) write (temp_fd, strs, strlen (strs)) != strlen (strs))
    58. 

  58.     {
    59. 

  59.       puts ("could not write test strings into file");
    60. 

  60.       unlink (temp_filename);
    61. 

  61.       exit (1);
    62. 

  62.     }
    63. 

  63. }
    64. 

  64. 

  65. volatile int chk_fail_ok;
    66. 

  66. volatile int ret;
    67. 

  67. jmp_buf chk_fail_buf;
    68. 

  68. 

  69. static void
    70. 

  70. handler (int sig)
    71. 

  71. {
    72. 

  72.   if (chk_fail_ok)
    73. 

  73.     {
    74. 

  74.       chk_fail_ok = 0;
    75. 

  75.       longjmp (chk_fail_buf, 1);
    76. 

  76.     }
    77. 

  77.   else
    78. 

  78.     _exit (127);
    79. 

  79. }
    80. 

  80. 

  81. char buf[10];
    82. 

  82. wchar_t wbuf[10];
    83. 

  83. volatile size_t l0;
    84. 

  84. volatile char *p;
    85. 

  85. volatile wchar_t *wp;
    86. 

  86. const char *str1 = "JIHGFEDCBA";
    87. 

  87. const char *str2 = "F";
    88. 

  88. const char *str3 = "%s%n%s%n";
    89. 

  89. const char *str4 = "Hello, ";
    90. 

  90. const char *str5 = "World!\n";
    91. 

  91. const wchar_t *wstr1 = L"JIHGFEDCBA";
    92. 

  92. const wchar_t *wstr2 = L"F";
    93. 

  93. const wchar_t *wstr3 = L"%s%n%s%n";
    94. 

  94. const wchar_t *wstr4 = L"Hello, ";
    95. 

  95. const wchar_t *wstr5 = L"World!\n";
    96. 

  96. char buf2[10] = "%s";
    97. 

  97. int num1 = 67;
    98. 

  98. int num2 = 987654;
    99. 

  99. 

  100. #define FAIL() \
    101. 

  101.   do { printf ("Failure on line %d\n", __LINE__); ret = 1; } while (0)
    102. 

  102. #define CHK_FAIL_START \
    103. 

  103.   chk_fail_ok = 1;				\
    104. 

  104.   if (! setjmp (chk_fail_buf))			\
    105. 

  105.     {
    106. 

  106. #define CHK_FAIL_END \
    107. 

  107.       chk_fail_ok = 0;				\
    108. 

  108.       FAIL ();					\
    109. 

  109.     }
    110. 

  110. #if __USE_FORTIFY_LEVEL >= 2 && (!defined __cplusplus || defined __va_arg_pack)
    111. 

  111. #define CHK_FAIL2_START CHK_FAIL_START
    112. 

  112. #define CHK_FAIL2_END CHK_FAIL_END
    113. 

  113. #else
    114. 

  114. #define CHK_FAIL2_START
    115. 

  115. #define CHK_FAIL2_END
    116. 

  116. #endif
    117. 

  117. 

  118. static int
    119. 

  119. do_test (void)
    120. 

  120. {
    121. 

  121.   struct sigaction sa;
    122. 

  122.   sa.sa_handler = handler;
    123. 

  123.   sa.sa_flags = 0;
    124. 

  124.   sigemptyset (&sa.sa_mask);
    125. 

  125. 

  126.   sigaction (SIGABRT, &sa, NULL);
    127. 

  127. 

  128.   /* Avoid all the buffer overflow messages on stderr.  */
    129. 

  129.   int fd = open (_PATH_DEVNULL, O_WRONLY);
    130. 

  130.   if (fd == -1)
    131. 

  131.     close (STDERR_FILENO);
    132. 

  132.   else
    133. 

  133.     {
    134. 

  134.       dup2 (fd, STDERR_FILENO);
    135. 

  135.       close (fd);
    136. 

  136.     }
    137. 

  137.   setenv ("LIBC_FATAL_STDERR_", "1", 1);
    138. 

  138. 

  139.   struct A { char buf1[9]; char buf2[1]; } a;
    140. 

  140.   struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;
    141. 

  141. 

  142.   printf ("Test checking routines at fortify level %d\n",
    143. 

  143. #ifdef __USE_FORTIFY_LEVEL
    144. 

  144. 	  (int) __USE_FORTIFY_LEVEL
    145. 

  145. #else
    146. 

  146. 	  0
    147. 

  147. #endif
    148. 

  148. 	  );
    149. 

  149. 

  150. #if defined __USE_FORTIFY_LEVEL && !defined __extern_always_inline
    151. 

  151.   printf ("Test skipped");
    152. 

  152.   if (l0 == 0)
    153. 

  153.     return 0;
    154. 

  154. #endif
    155. 

  155. 

  156.   /* These ops can be done without runtime checking of object size.  */
    157. 

  157.   memcpy (buf, "abcdefghij", 10);
    158. 

  158.   memmove (buf + 1, buf, 9);
    159. 

  159.   if (memcmp (buf, "aabcdefghi", 10))
    160. 

  160.     FAIL ();
    161. 

  161. 

  162.   if (mempcpy (buf + 5, "abcde", 5) != buf + 10
    163. 

  163.       || memcmp (buf, "aabcdabcde", 10))
    164. 

  164.     FAIL ();
    165. 

  165. 

  166.   memset (buf + 8, 'j', 2);
    167. 

  167.   if (memcmp (buf, "aabcdabcjj", 10))
    168. 

  168.     FAIL ();
    169. 

  169. 

  170.   strcpy (buf + 4, "EDCBA");
    171. 

  171.   if (memcmp (buf, "aabcEDCBA", 10))
    172. 

  172.     FAIL ();
    173. 

  173. 

  174.   if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
    175. 

  175.     FAIL ();
    176. 

  176. 

  177.   strncpy (buf + 6, "X", 4);
    178. 

  178.   if (memcmp (buf, "aabcEDX\0\0", 10))
    179. 

  179.     FAIL ();
    180. 

  180. 

  181.   if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10))
    182. 

  182.     FAIL ();
    183. 

  183. 

  184.   if (snprintf (buf + 7, 3, "%s", "987654") != 6
    185. 

  185.       || memcmp (buf, "aabcEDX98", 10))
    186. 

  186.     FAIL ();
    187. 

  187. 

  188.   /* These ops need runtime checking, but shouldn't __chk_fail.  */
    189. 

  189.   memcpy (buf, "abcdefghij", l0 + 10);
    190. 

  190.   memmove (buf + 1, buf, l0 + 9);
    191. 

  191.   if (memcmp (buf, "aabcdefghi", 10))
    192. 

  192.     FAIL ();
    193. 

  193. 

  194.   if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10
    195. 

  195.       || memcmp (buf, "aabcdabcde", 10))
    196. 

  196.     FAIL ();
    197. 

  197. 

  198.   memset (buf + 8, 'j', l0 + 2);
    199. 

  199.   if (memcmp (buf, "aabcdabcjj", 10))
    200. 

  200.     FAIL ();
    201. 

  201. 

  202.   strcpy (buf + 4, str1 + 5);
    203. 

  203.   if (memcmp (buf, "aabcEDCBA", 10))
    204. 

  204.     FAIL ();
    205. 

  205. 

  206.   if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
    207. 

  207.     FAIL ();
    208. 

  208. 

  209.   strncpy (buf + 6, "X", l0 + 4);
    210. 

  210.   if (memcmp (buf, "aabcEDX\0\0", 10))
    211. 

  211.     FAIL ();
    212. 

  212. 

  213.   if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7
    214. 

  214.       || memcmp (buf, "aabcEcd\0\0", 10))
    215. 

  215.     FAIL ();
    216. 

  216. 

  217.   if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10))
    218. 

  218.     FAIL ();
    219. 

  219. 

  220.   if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10))
    221. 

  221.     FAIL ();
    222. 

  222. 

  223.   buf[l0 + 8] = '\0';
    224. 

  224.   strcat (buf, "A");
    225. 

  225.   if (memcmp (buf, "aabcEcd9A", 10))
    226. 

  226.     FAIL ();
    227. 

  227. 

  228.   buf[l0 + 7] = '\0';
    229. 

  229.   strncat (buf, "ZYXWV", l0 + 2);
    230. 

  230.   if (memcmp (buf, "aabcEcdZY", 10))
    231. 

  231.     FAIL ();
    232. 

  232. 

  233.   memcpy (a.buf1, "abcdefghij", l0 + 10);
    234. 

  234.   memmove (a.buf1 + 1, a.buf1, l0 + 9);
    235. 

  235.   if (memcmp (a.buf1, "aabcdefghi", 10))
    236. 

  236.     FAIL ();
    237. 

  237. 

  238.   if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10
    239. 

  239.       || memcmp (a.buf1, "aabcdabcde", 10))
    240. 

  240.     FAIL ();
    241. 

  241. 

  242.   memset (a.buf1 + 8, 'j', l0 + 2);
    243. 

  243.   if (memcmp (a.buf1, "aabcdabcjj", 10))
    244. 

  244.     FAIL ();
    245. 

  245. 

  246. #if __USE_FORTIFY_LEVEL < 2
    247. 

  247.   /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
    248. 

  248.      and sufficient GCC support, as the string operations overflow
    249. 

  249.      from a.buf1 into a.buf2.  */
    250. 

  250.   strcpy (a.buf1 + 4, str1 + 5);
    251. 

  251.   if (memcmp (a.buf1, "aabcEDCBA", 10))
    252. 

  252.     FAIL ();
    253. 

  253. 

  254.   if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9
    255. 

  255.       || memcmp (a.buf1, "aabcEDCBF", 10))
    256. 

  256.     FAIL ();
    257. 

  257. 

  258.   strncpy (a.buf1 + 6, "X", l0 + 4);
    259. 

  259.   if (memcmp (a.buf1, "aabcEDX\0\0", 10))
    260. 

  260.     FAIL ();
    261. 

  261. 

  262.   if (sprintf (a.buf1 + 7, "%d", num1) != 2
    263. 

  263.       || memcmp (a.buf1, "aabcEDX67", 10))
    264. 

  264.     FAIL ();
    265. 

  265. 

  266.   if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6
    267. 

  267.       || memcmp (a.buf1, "aabcEDX98", 10))
    268. 

  268.     FAIL ();
    269. 

  269. 

  270.   a.buf1[l0 + 8] = '\0';
    271. 

  271.   strcat (a.buf1, "A");
    272. 

  272.   if (memcmp (a.buf1, "aabcEDX9A", 10))
    273. 

  273.     FAIL ();
    274. 

  274. 

  275.   a.buf1[l0 + 7] = '\0';
    276. 

  276.   strncat (a.buf1, "ZYXWV", l0 + 2);
    277. 

  277.   if (memcmp (a.buf1, "aabcEDXZY", 10))
    278. 

  278.     FAIL ();
    279. 

  279. 

  280. #endif
    281. 

  281. 

  282. #if __USE_FORTIFY_LEVEL >= 1
    283. 

  283.   /* Now check if all buffer overflows are caught at runtime.  */
    284. 

  284. 

  285.   CHK_FAIL_START
    286. 

  286.   memcpy (buf + 1, "abcdefghij", l0 + 10);
    287. 

  287.   CHK_FAIL_END
    288. 

  288. 

  289.   CHK_FAIL_START
    290. 

  290.   memmove (buf + 2, buf + 1, l0 + 9);
    291. 

  291.   CHK_FAIL_END
    292. 

  292. 

  293.   CHK_FAIL_START
    294. 

  294.   p = (char *) mempcpy (buf + 6, "abcde", l0 + 5);
    295. 

  295.   CHK_FAIL_END
    296. 

  296. 

  297.   CHK_FAIL_START
    298. 

  298.   memset (buf + 9, 'j', l0 + 2);
    299. 

  299.   CHK_FAIL_END
    300. 

  300. 

  301.   CHK_FAIL_START
    302. 

  302.   strcpy (buf + 5, str1 + 5);
    303. 

  303.   CHK_FAIL_END
    304. 

  304. 

  305.   CHK_FAIL_START
    306. 

  306.   p = stpcpy (buf + 9, str2);
    307. 

  307.   CHK_FAIL_END
    308. 

  308. 

  309.   CHK_FAIL_START
    310. 

  310.   strncpy (buf + 7, "X", l0 + 4);
    311. 

  311.   CHK_FAIL_END
    312. 

  312. 

  313.   CHK_FAIL_START
    314. 

  314.   stpncpy (buf + 6, "cd", l0 + 5);
    315. 

  315.   CHK_FAIL_END
    316. 

  316. 

  317. # if !defined __cplusplus || defined __va_arg_pack
    318. 

  318.   CHK_FAIL_START
    319. 

  319.   sprintf (buf + 8, "%d", num1);
    320. 

  320.   CHK_FAIL_END
    321. 

  321. 

  322.   CHK_FAIL_START
    323. 

  323.   snprintf (buf + 8, l0 + 3, "%d", num2);
    324. 

  324.   CHK_FAIL_END
    325. 

  325. 

  326. #if __OPTION_POSIX_C_LANG_WIDE_CHAR
    327. 

  327.   CHK_FAIL_START
    328. 

  328.   swprintf (wbuf + 8, 3, L"%d", num1);
    329. 

  329.   CHK_FAIL_END
    330. 

  330. 

  331.   CHK_FAIL_START
    332. 

  332.   swprintf (wbuf + 8, l0 + 3, L"%d", num1);
    333. 

  333.   CHK_FAIL_END
    334. 

  334. #endif /* __OPTION_POSIX_C_LANG_WIDE_CHAR */
    335. 

  335. # endif
    336. 

  336. 

  337.   memcpy (buf, str1 + 2, l0 + 9);
    338. 

  338.   CHK_FAIL_START
    339. 

  339.   strcat (buf, "AB");
    340. 

  340.   CHK_FAIL_END
    341. 

  341. 

  342.   memcpy (buf, str1 + 3, l0 + 8);
    343. 

  343.   CHK_FAIL_START
    344. 

  344.   strncat (buf, "ZYXWV", l0 + 3);
    345. 

  345.   CHK_FAIL_END
    346. 

  346. 

  347.   CHK_FAIL_START
    348. 

  348.   memcpy (a.buf1 + 1, "abcdefghij", l0 + 10);
    349. 

  349.   CHK_FAIL_END
    350. 

  350. 

  351.   CHK_FAIL_START
    352. 

  352.   memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9);
    353. 

  353.   CHK_FAIL_END
    354. 

  354. 

  355.   CHK_FAIL_START
    356. 

  356.   p = (char *) mempcpy (a.buf1 + 6, "abcde", l0 + 5);
    357. 

  357.   CHK_FAIL_END
    358. 

  358. 

  359.   CHK_FAIL_START
    360. 

  360.   memset (a.buf1 + 9, 'j', l0 + 2);
    361. 

  361.   CHK_FAIL_END
    362. 

  362. 

  363. # if __USE_FORTIFY_LEVEL >= 2
    364. 

  364. #  define O 0
    365. 

  365. # else
    366. 

  366. #  define O 1
    367. 

  367. # endif
    368. 

  368. 

  369.   CHK_FAIL_START
    370. 

  370.   strcpy (a.buf1 + (O + 4), str1 + 5);
    371. 

  371.   CHK_FAIL_END
    372. 

  372. 

  373.   CHK_FAIL_START
    374. 

  374.   p = stpcpy (a.buf1 + (O + 8), str2);
    375. 

  375.   CHK_FAIL_END
    376. 

  376. 

  377.   CHK_FAIL_START
    378. 

  378.   strncpy (a.buf1 + (O + 6), "X", l0 + 4);
    379. 

  379.   CHK_FAIL_END
    380. 

  380. 

  381. # if !defined __cplusplus || defined __va_arg_pack
    382. 

  382.   CHK_FAIL_START
    383. 

  383.   sprintf (a.buf1 + (O + 7), "%d", num1);
    384. 

  384.   CHK_FAIL_END
    385. 

  385. 

  386.   CHK_FAIL_START
    387. 

  387.   snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2);
    388. 

  388.   CHK_FAIL_END
    389. 

  389. # endif
    390. 

  390. 

  391.   memcpy (a.buf1, str1 + (3 - O), l0 + 8 + O);
    392. 

  392.   CHK_FAIL_START
    393. 

  393.   strcat (a.buf1, "AB");
    394. 

  394.   CHK_FAIL_END
    395. 

  395. 

  396.   memcpy (a.buf1, str1 + (4 - O), l0 + 7 + O);
    397. 

  397.   CHK_FAIL_START
    398. 

  398.   strncat (a.buf1, "ZYXWV", l0 + 3);
    399. 

  399.   CHK_FAIL_END
    400. 

  400. #endif
    401. 

  401. 

  402. #if __OPTION_POSIX_C_LANG_WIDE_CHAR
    403. 

  403. 

  404.   /* These ops can be done without runtime checking of object size.  */
    405. 

  405.   wmemcpy (wbuf, L"abcdefghij", 10);
    406. 

  406.   wmemmove (wbuf + 1, wbuf, 9);
    407. 

  407.   if (wmemcmp (wbuf, L"aabcdefghi", 10))
    408. 

  408.     FAIL ();
    409. 

  409. 

  410.   if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10
    411. 

  411.       || wmemcmp (wbuf, L"aabcdabcde", 10))
    412. 

  412.     FAIL ();
    413. 

  413. 

  414.   wmemset (wbuf + 8, L'j', 2);
    415. 

  415.   if (wmemcmp (wbuf, L"aabcdabcjj", 10))
    416. 

  416.     FAIL ();
    417. 

  417. 

  418.   wcscpy (wbuf + 4, L"EDCBA");
    419. 

  419.   if (wmemcmp (wbuf, L"aabcEDCBA", 10))
    420. 

  420.     FAIL ();
    421. 

  421. 

  422.   if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
    423. 

  423.     FAIL ();
    424. 

  424. 

  425.   wcsncpy (wbuf + 6, L"X", 4);
    426. 

  426.   if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
    427. 

  427.     FAIL ();
    428. 

  428. 

  429.   if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0
    430. 

  430.       || wmemcmp (wbuf, L"aabcEDX98", 10))
    431. 

  431.     FAIL ();
    432. 

  432. 

  433.   if (swprintf (wbuf + 7, 3, L"64") != 2
    434. 

  434.       || wmemcmp (wbuf, L"aabcEDX64", 10))
    435. 

  435.     FAIL ();
    436. 

  436. 

  437.   /* These ops need runtime checking, but shouldn't __chk_fail.  */
    438. 

  438.   wmemcpy (wbuf, L"abcdefghij", l0 + 10);
    439. 

  439.   wmemmove (wbuf + 1, wbuf, l0 + 9);
    440. 

  440.   if (wmemcmp (wbuf, L"aabcdefghi", 10))
    441. 

  441.     FAIL ();
    442. 

  442. 

  443.   if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10
    444. 

  444.       || wmemcmp (wbuf, L"aabcdabcde", 10))
    445. 

  445.     FAIL ();
    446. 

  446. 

  447.   wmemset (wbuf + 8, L'j', l0 + 2);
    448. 

  448.   if (wmemcmp (wbuf, L"aabcdabcjj", 10))
    449. 

  449.     FAIL ();
    450. 

  450. 

  451.   wcscpy (wbuf + 4, wstr1 + 5);
    452. 

  452.   if (wmemcmp (wbuf, L"aabcEDCBA", 10))
    453. 

  453.     FAIL ();
    454. 

  454. 

  455.   if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
    456. 

  456.     FAIL ();
    457. 

  457. 

  458.   wcsncpy (wbuf + 6, L"X", l0 + 4);
    459. 

  459.   if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
    460. 

  460.     FAIL ();
    461. 

  461. 

  462.   if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7
    463. 

  463.       || wmemcmp (wbuf, L"aabcEcd\0\0", 10))
    464. 

  464.     FAIL ();
    465. 

  465. 

  466.   if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0
    467. 

  467.       || wmemcmp (wbuf, L"aabcEcd98", 10))
    468. 

  468.     FAIL ();
    469. 

  469. 

  470.   wbuf[l0 + 8] = L'\0';
    471. 

  471.   wcscat (wbuf, L"A");
    472. 

  472.   if (wmemcmp (wbuf, L"aabcEcd9A", 10))
    473. 

  473.     FAIL ();
    474. 

  474. 

  475.   wbuf[l0 + 7] = L'\0';
    476. 

  476.   wcsncat (wbuf, L"ZYXWV", l0 + 2);
    477. 

  477.   if (wmemcmp (wbuf, L"aabcEcdZY", 10))
    478. 

  478.     FAIL ();
    479. 

  479. 

  480.   wmemcpy (wa.buf1, L"abcdefghij", l0 + 10);
    481. 

  481.   wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9);
    482. 

  482.   if (wmemcmp (wa.buf1, L"aabcdefghi", 10))
    483. 

  483.     FAIL ();
    484. 

  484. 

  485.   if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10
    486. 

  486.       || wmemcmp (wa.buf1, L"aabcdabcde", 10))
    487. 

  487.     FAIL ();
    488. 

  488. 

  489.   wmemset (wa.buf1 + 8, L'j', l0 + 2);
    490. 

  490.   if (wmemcmp (wa.buf1, L"aabcdabcjj", 10))
    491. 

  491.     FAIL ();
    492. 

  492. 

  493. #if __USE_FORTIFY_LEVEL < 2
    494. 

  494.   /* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
    495. 

  495.      and sufficient GCC support, as the string operations overflow
    496. 

  496.      from a.buf1 into a.buf2.  */
    497. 

  497.   wcscpy (wa.buf1 + 4, wstr1 + 5);
    498. 

  498.   if (wmemcmp (wa.buf1, L"aabcEDCBA", 10))
    499. 

  499.     FAIL ();
    500. 

  500. 

  501.   if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9
    502. 

  502.       || wmemcmp (wa.buf1, L"aabcEDCBF", 10))
    503. 

  503.     FAIL ();
    504. 

  504. 

  505.   wcsncpy (wa.buf1 + 6, L"X", l0 + 4);
    506. 

  506.   if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10))
    507. 

  507.     FAIL ();
    508. 

  508. 

  509.   if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0
    510. 

  510.       || wmemcmp (wa.buf1, L"aabcEDX98", 10))
    511. 

  511.     FAIL ();
    512. 

  512. 

  513.   wa.buf1[l0 + 8] = L'\0';
    514. 

  514.   wcscat (wa.buf1, L"A");
    515. 

  515.   if (wmemcmp (wa.buf1, L"aabcEDX9A", 10))
    516. 

  516.     FAIL ();
    517. 

  517. 

  518.   wa.buf1[l0 + 7] = L'\0';
    519. 

  519.   wcsncat (wa.buf1, L"ZYXWV", l0 + 2);
    520. 

  520.   if (wmemcmp (wa.buf1, L"aabcEDXZY", 10))
    521. 

  521.     FAIL ();
    522. 

  522. 

  523. #endif
    524. 

  524. 

  525. #if __USE_FORTIFY_LEVEL >= 1
    526. 

  526.   /* Now check if all buffer overflows are caught at runtime.  */
    527. 

  527. 

  528.   CHK_FAIL_START
    529. 

  529.   wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10);
    530. 

  530.   CHK_FAIL_END
    531. 

  531. 

  532.   CHK_FAIL_START
    533. 

  533.   wmemcpy (wbuf + 9, L"abcdefghij", l0 + 10);
    534. 

  534.   CHK_FAIL_END
    535. 

  535. 

  536.   CHK_FAIL_START
    537. 

  537.   wmemmove (wbuf + 2, wbuf + 1, l0 + 9);
    538. 

  538.   CHK_FAIL_END
    539. 

  539. 

  540.   CHK_FAIL_START
    541. 

  541.   wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5);
    542. 

  542.   CHK_FAIL_END
    543. 

  543. 

  544.   CHK_FAIL_START
    545. 

  545.   wmemset (wbuf + 9, L'j', l0 + 2);
    546. 

  546.   CHK_FAIL_END
    547. 

  547. 

  548.   CHK_FAIL_START
    549. 

  549.   wcscpy (wbuf + 5, wstr1 + 5);
    550. 

  550.   CHK_FAIL_END
    551. 

  551. 

  552.   CHK_FAIL_START
    553. 

  553.   wp = wcpcpy (wbuf + 9, wstr2);
    554. 

  554.   CHK_FAIL_END
    555. 

  555. 

  556.   CHK_FAIL_START
    557. 

  557.   wcsncpy (wbuf + 7, L"X", l0 + 4);
    558. 

  558.   CHK_FAIL_END
    559. 

  559. 

  560.   CHK_FAIL_START
    561. 

  561.   wcsncpy (wbuf + 9, L"XABCDEFGH", 8);
    562. 

  562.   CHK_FAIL_END
    563. 

  563. 

  564.   CHK_FAIL_START
    565. 

  565.   wcpncpy (wbuf + 9, L"XABCDEFGH", 8);
    566. 

  566.   CHK_FAIL_END
    567. 

  567. 

  568.   CHK_FAIL_START
    569. 

  569.   wcpncpy (wbuf + 6, L"cd", l0 + 5);
    570. 

  570.   CHK_FAIL_END
    571. 

  571. 

  572.   wmemcpy (wbuf, wstr1 + 2, l0 + 9);
    573. 

  573.   CHK_FAIL_START
    574. 

  574.   wcscat (wbuf, L"AB");
    575. 

  575.   CHK_FAIL_END
    576. 

  576. 

  577.   wmemcpy (wbuf, wstr1 + 3, l0 + 8);
    578. 

  578.   CHK_FAIL_START
    579. 

  579.   wcsncat (wbuf, L"ZYXWV", l0 + 3);
    580. 

  580.   CHK_FAIL_END
    581. 

  581. 

  582.   CHK_FAIL_START
    583. 

  583.   wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10);
    584. 

  584.   CHK_FAIL_END
    585. 

  585. 

  586.   CHK_FAIL_START
    587. 

  587.   wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9);
    588. 

  588.   CHK_FAIL_END
    589. 

  589. 

  590.   CHK_FAIL_START
    591. 

  591.   wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5);
    592. 

  592.   CHK_FAIL_END
    593. 

  593. 

  594.   CHK_FAIL_START
    595. 

  595.   wmemset (wa.buf1 + 9, L'j', l0 + 2);
    596. 

  596.   CHK_FAIL_END
    597. 

  597. 

  598. #if __USE_FORTIFY_LEVEL >= 2
    599. 

  599. # define O 0
    600. 

  600. #else
    601. 

  601. # define O 1
    602. 

  602. #endif
    603. 

  603. 

  604.   CHK_FAIL_START
    605. 

  605.   wcscpy (wa.buf1 + (O + 4), wstr1 + 5);
    606. 

  606.   CHK_FAIL_END
    607. 

  607. 

  608.   CHK_FAIL_START
    609. 

  609.   wp = wcpcpy (wa.buf1 + (O + 8), wstr2);
    610. 

  610.   CHK_FAIL_END
    611. 

  611. 

  612.   CHK_FAIL_START
    613. 

  613.   wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4);
    614. 

  614.   CHK_FAIL_END
    615. 

  615. 

  616.   wmemcpy (wa.buf1, wstr1 + (3 - O), l0 + 8 + O);
    617. 

  617.   CHK_FAIL_START
    618. 

  618.   wcscat (wa.buf1, L"AB");
    619. 

  619.   CHK_FAIL_END
    620. 

  620. 

  621.   wmemcpy (wa.buf1, wstr1 + (4 - O), l0 + 7 + O);
    622. 

  622.   CHK_FAIL_START
    623. 

  623.   wcsncat (wa.buf1, L"ZYXWV", l0 + 3);
    624. 

  624.   CHK_FAIL_END
    625. 

  625. #endif
    626. 

  626. 

  627. #endif /* __OPTION_POSIX_C_LANG_WIDE_CHAR */
    628. 

  628. 

  629.   /* Now checks for %n protection.  */
    630. 

  630. 

  631.   /* Constant literals passed directly are always ok
    632. 

  632.      (even with warnings about possible bugs from GCC).  */
    633. 

  633.   int n1, n2;
    634. 

  634.   if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2
    635. 

  635.       || n1 != 1 || n2 != 2)
    636. 

  636.     FAIL ();
    637. 

  637. 

  638.   /* In this case the format string is not known at compile time,
    639. 

  639.      but resides in read-only memory, so is ok.  */
    640. 

  640.   if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2
    641. 

  641.       || n1 != 1 || n2 != 2)
    642. 

  642.     FAIL ();
    643. 

  643. 

  644.   strcpy (buf2 + 2, "%n%s%n");
    645. 

  645.   /* When the format string is writable and contains %n,
    646. 

  646.      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
    647. 

  647.   CHK_FAIL2_START
    648. 

  648.   if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2)
    649. 

  649.     FAIL ();
    650. 

  650.   CHK_FAIL2_END
    651. 

  651. 

  652.   CHK_FAIL2_START
    653. 

  653.   if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2)
    654. 

  654.     FAIL ();
    655. 

  655.   CHK_FAIL2_END
    656. 

  656. 

  657.   /* But if there is no %n, even writable format string
    658. 

  658.      should work.  */
    659. 

  659.   buf2[6] = '\0';
    660. 

  660.   if (sprintf (buf, buf2 + 4, str2) != 1)
    661. 

  661.     FAIL ();
    662. 

  662. 

  663.   /* Constant literals passed directly are always ok
    664. 

  664.      (even with warnings about possible bugs from GCC).  */
    665. 

  665.   if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14
    666. 

  666.       || n1 != 7 || n2 != 14)
    667. 

  667.     FAIL ();
    668. 

  668. 

  669.   /* In this case the format string is not known at compile time,
    670. 

  670.      but resides in read-only memory, so is ok.  */
    671. 

  671.   if (printf (str3, str4, &n1, str5, &n2) != 14
    672. 

  672.       || n1 != 7 || n2 != 14)
    673. 

  673.     FAIL ();
    674. 

  674. 

  675.   strcpy (buf2 + 2, "%n%s%n");
    676. 

  676.   /* When the format string is writable and contains %n,
    677. 

  677.      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
    678. 

  678.   CHK_FAIL2_START
    679. 

  679.   if (printf (buf2, str4, &n1, str5, &n1) != 14)
    680. 

  680.     FAIL ();
    681. 

  681.   CHK_FAIL2_END
    682. 

  682. 

  683.   /* But if there is no %n, even writable format string
    684. 

  684.      should work.  */
    685. 

  685.   buf2[6] = '\0';
    686. 

  686.   if (printf (buf2 + 4, str5) != 7)
    687. 

  687.     FAIL ();
    688. 

  688. 

  689.   FILE *fp = stdout;
    690. 

  690. 

  691.   /* Constant literals passed directly are always ok
    692. 

  692.      (even with warnings about possible bugs from GCC).  */
    693. 

  693.   if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14
    694. 

  694.       || n1 != 7 || n2 != 14)
    695. 

  695.     FAIL ();
    696. 

  696. 

  697.   /* In this case the format string is not known at compile time,
    698. 

  698.      but resides in read-only memory, so is ok.  */
    699. 

  699.   if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14
    700. 

  700.       || n1 != 7 || n2 != 14)
    701. 

  701.     FAIL ();
    702. 

  702. 

  703.   strcpy (buf2 + 2, "%n%s%n");
    704. 

  704.   /* When the format string is writable and contains %n,
    705. 

  705.      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
    706. 

  706.   CHK_FAIL2_START
    707. 

  707.   if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14)
    708. 

  708.     FAIL ();
    709. 

  709.   CHK_FAIL2_END
    710. 

  710. 

  711.   /* But if there is no %n, even writable format string
    712. 

  712.      should work.  */
    713. 

  713.   buf2[6] = '\0';
    714. 

  714.   if (fprintf (fp, buf2 + 4, str5) != 7)
    715. 

  715.     FAIL ();
    716. 

  716. 

  717.   char *my_ptr = NULL;
    718. 

  718.   strcpy (buf2 + 2, "%n%s%n");
    719. 

  719.   /* When the format string is writable and contains %n,
    720. 

  720.      with -D_FORTIFY_SOURCE=2 it causes __chk_fail.  */
    721. 

  721.   CHK_FAIL2_START
    722. 

  722.   if (asprintf (&my_ptr, buf2, str4, &n1, str5, &n1) != 14)
    723. 

  723.     FAIL ();
    724. 

  724.   else
    725. 

  725.     free (my_ptr);
    726. 

  726.   CHK_FAIL2_END
    727. 

  727. 

  728.   struct obstack obs;
    729. 

  729.   obstack_init (&obs);
    730. 

  730.   CHK_FAIL2_START
    731. 

  731.   if (obstack_printf (&obs, buf2, str4, &n1, str5, &n1) != 14)
    732. 

  732.     FAIL ();
    733. 

  733.   CHK_FAIL2_END
    734. 

  734.   obstack_free (&obs, NULL);
    735. 

  735. 

  736.   my_ptr = NULL;
    737. 

  737.   if (asprintf (&my_ptr, "%s%n%s%n", str4, &n1, str5, &n1) != 14)
    738. 

  738.     FAIL ();
    739. 

  739.   else
    740. 

  740.     free (my_ptr);
    741. 

  741. 

  742.   obstack_init (&obs);
    743. 

  743.   if (obstack_printf (&obs, "%s%n%s%n", str4, &n1, str5, &n1) != 14)
    744. 

  744.     FAIL ();
    745. 

  745.   obstack_free (&obs, NULL);
    746. 

  746. 

  747.   if (freopen (temp_filename, "r", stdin) == NULL)
    748. 

  748.     {
    749. 

  749.       puts ("could not open temporary file");
    750. 

  750.       exit (1);
    751. 

  751.     }
    752. 

  752. 

  753.   if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9))
    754. 

  754.     FAIL ();
    755. 

  755.   if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10))
    756. 

  756.     FAIL ();
    757. 

  757. 

  758. #if __USE_FORTIFY_LEVEL >= 1
    759. 

  759.   CHK_FAIL_START
    760. 

  760.   if (gets (buf) != buf)
    761. 

  761.     FAIL ();
    762. 

  762.   CHK_FAIL_END
    763. 

  763. #endif
    764. 

  764. 

  765.   rewind (stdin);
    766. 

  766. 

  767.   if (fgets (buf, sizeof (buf), stdin) != buf
    768. 

  768.       || memcmp (buf, "abcdefgh\n", 10))
    769. 

  769.     FAIL ();
    770. 

  770.   if (fgets (buf, sizeof (buf), stdin) != buf || memcmp (buf, "ABCDEFGHI", 10))
    771. 

  771.     FAIL ();
    772. 

  772. 

  773.   rewind (stdin);
    774. 

  774. 

  775.   if (fgets (buf, l0 + sizeof (buf), stdin) != buf
    776. 

  776.       || memcmp (buf, "abcdefgh\n", 10))
    777. 

  777.     FAIL ();
    778. 

  778. 

  779. #if __USE_FORTIFY_LEVEL >= 1
    780. 

  780.   CHK_FAIL_START
    781. 

  781.   if (fgets (buf, sizeof (buf) + 1, stdin) != buf)
    782. 

  782.     FAIL ();
    783. 

  783.   CHK_FAIL_END
    784. 

  784. 

  785.   CHK_FAIL_START
    786. 

  786.   if (fgets (buf, l0 + sizeof (buf) + 1, stdin) != buf)
    787. 

  787.     FAIL ();
    788. 

  788.   CHK_FAIL_END
    789. 

  789. #endif
    790. 

  790. 

  791.   rewind (stdin);
    792. 

  792. 

  793.   if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
    794. 

  794.       || memcmp (buf, "abcdefgh\n", 10))
    795. 

  795.     FAIL ();
    796. 

  796.   if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
    797. 

  797.       || memcmp (buf, "ABCDEFGHI", 10))
    798. 

  798.     FAIL ();
    799. 

  799. 

  800.   rewind (stdin);
    801. 

  801. 

  802.   if (fgets_unlocked (buf, l0 + sizeof (buf), stdin) != buf
    803. 

  803.       || memcmp (buf, "abcdefgh\n", 10))
    804. 

  804.     FAIL ();
    805. 

  805. 

  806. #if __USE_FORTIFY_LEVEL >= 1
    807. 

  807.   CHK_FAIL_START
    808. 

  808.   if (fgets_unlocked (buf, sizeof (buf) + 1, stdin) != buf)
    809. 

  809.     FAIL ();
    810. 

  810.   CHK_FAIL_END
    811. 

  811. 

  812.   CHK_FAIL_START
    813. 

  813.   if (fgets_unlocked (buf, l0 + sizeof (buf) + 1, stdin) != buf)
    814. 

  814.     FAIL ();
    815. 

  815.   CHK_FAIL_END
    816. 

  816. #endif
    817. 

  817. 

  818.   rewind (stdin);
    819. 

  819. 

  820.   if (fread (buf, 1, sizeof (buf), stdin) != sizeof (buf)
    821. 

  821.       || memcmp (buf, "abcdefgh\nA", 10))
    822. 

  822.     FAIL ();
    823. 

  823.   if (fread (buf, sizeof (buf), 1, stdin) != 1
    824. 

  824.       || memcmp (buf, "BCDEFGHI\na", 10))
    825. 

  825.     FAIL ();
    826. 

  826. 

  827.   rewind (stdin);
    828. 

  828. 

  829.   if (fread (buf, l0 + 1, sizeof (buf), stdin) != sizeof (buf)
    830. 

  830.       || memcmp (buf, "abcdefgh\nA", 10))
    831. 

  831.     FAIL ();
    832. 

  832.   if (fread (buf, sizeof (buf), l0 + 1, stdin) != 1
    833. 

  833.       || memcmp (buf, "BCDEFGHI\na", 10))
    834. 

  834.     FAIL ();
    835. 

  835. 

  836. #if __USE_FORTIFY_LEVEL >= 1
    837. 

  837.   CHK_FAIL_START
    838. 

  838.   if (fread (buf, 1, sizeof (buf) + 1, stdin) != sizeof (buf) + 1)
    839. 

  839.     FAIL ();
    840. 

  840.   CHK_FAIL_END
    841. 

  841. 

  842.   CHK_FAIL_START
    843. 

  843.   if (fread (buf, sizeof (buf) + 1, l0 + 1, stdin) != 1)
    844. 

  844.     FAIL ();
    845. 

  845.   CHK_FAIL_END
    846. 

  846. #endif
    847. 

  847. 

  848.   rewind (stdin);
    849. 

  849. 

  850.   if (fread_unlocked (buf, 1, sizeof (buf), stdin) != sizeof (buf)
    851. 

  851.       || memcmp (buf, "abcdefgh\nA", 10))
    852. 

  852.     FAIL ();
    853. 

  853.   if (fread_unlocked (buf, sizeof (buf), 1, stdin) != 1
    854. 

  854.       || memcmp (buf, "BCDEFGHI\na", 10))
    855. 

  855.     FAIL ();
    856. 

  856. 

  857.   rewind (stdin);
    858. 

  858. 

  859.   if (fread_unlocked (buf, 1, 4, stdin) != 4
    860. 

  860.       || memcmp (buf, "abcdFGHI\na", 10))
    861. 

  861.     FAIL ();
    862. 

  862.   if (fread_unlocked (buf, 4, 1, stdin) != 1
    863. 

  863.       || memcmp (buf, "efghFGHI\na", 10))
    864. 

  864.     FAIL ();
    865. 

  865. 

  866.   rewind (stdin);
    867. 

  867. 

  868.   if (fread_unlocked (buf, l0 + 1, sizeof (buf), stdin) != sizeof (buf)
    869. 

  869.       || memcmp (buf, "abcdefgh\nA", 10))
    870. 

  870.     FAIL ();
    871. 

  871.   if (fread_unlocked (buf, sizeof (buf), l0 + 1, stdin) != 1
    872. 

  872.       || memcmp (buf, "BCDEFGHI\na", 10))
    873. 

  873.     FAIL ();
    874. 

  874. 

  875. #if __USE_FORTIFY_LEVEL >= 1
    876. 

  876.   CHK_FAIL_START
    877. 

  877.   if (fread_unlocked (buf, 1, sizeof (buf) + 1, stdin) != sizeof (buf) + 1)
    878. 

  878.     FAIL ();
    879. 

  879.   CHK_FAIL_END
    880. 

  880. 

  881.   CHK_FAIL_START
    882. 

  882.   if (fread_unlocked (buf, sizeof (buf) + 1, l0 + 1, stdin) != 1)
    883. 

  883.     FAIL ();
    884. 

  884.   CHK_FAIL_END
    885. 

  885. #endif
    886. 

  886. 

  887.   lseek (fileno (stdin), 0, SEEK_SET);
    888. 

  888. 

  889.   if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
    890. 

  890.       || memcmp (buf, "abcdefgh\n", 9))
    891. 

  891.     FAIL ();
    892. 

  892.   if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
    893. 

  893.       || memcmp (buf, "ABCDEFGHI", 9))
    894. 

  894.     FAIL ();
    895. 

  895. 

  896.   lseek (fileno (stdin), 0, SEEK_SET);
    897. 

  897. 

  898.   if (read (fileno (stdin), buf, l0 + sizeof (buf) - 1) != sizeof (buf) - 1
    899. 

  899.       || memcmp (buf, "abcdefgh\n", 9))
    900. 

  900.     FAIL ();
    901. 

  901. 

  902. #if __USE_FORTIFY_LEVEL >= 1
    903. 

  903.   CHK_FAIL_START
    904. 

  904.   if (read (fileno (stdin), buf, sizeof (buf) + 1) != sizeof (buf) + 1)
    905. 

  905.     FAIL ();
    906. 

  906.   CHK_FAIL_END
    907. 

  907. #endif
    908. 

  908. 

  909.   if (pread (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
    910. 

  910.       != sizeof (buf) - 1
    911. 

  911.       || memcmp (buf, "\nABCDEFGH", 9))
    912. 

  912.     FAIL ();
    913. 

  913.   if (pread (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
    914. 

  914.       || memcmp (buf, "abcdefgh\n", 9))
    915. 

  915.     FAIL ();
    916. 

  916.   if (pread (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
    917. 

  917.       != sizeof (buf) - 1
    918. 

  918.       || memcmp (buf, "h\nABCDEFG", 9))
    919. 

  919.     FAIL ();
    920. 

  920. 

  921. #if __USE_FORTIFY_LEVEL >= 1
    922. 

  922.   CHK_FAIL_START
    923. 

  923.   if (pread (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
    924. 

  924.       != sizeof (buf) + 1)
    925. 

  925.     FAIL ();
    926. 

  926.   CHK_FAIL_END
    927. 

  927. #endif
    928. 

  928. 

  929.   if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
    930. 

  930.       != sizeof (buf) - 1
    931. 

  931.       || memcmp (buf, "\nABCDEFGH", 9))
    932. 

  932.     FAIL ();
    933. 

  933.   if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
    934. 

  934.       || memcmp (buf, "abcdefgh\n", 9))
    935. 

  935.     FAIL ();
    936. 

  936.   if (pread64 (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
    937. 

  937.       != sizeof (buf) - 1
    938. 

  938.       || memcmp (buf, "h\nABCDEFG", 9))
    939. 

  939.     FAIL ();
    940. 

  940. 

  941. #if __USE_FORTIFY_LEVEL >= 1
    942. 

  942.   CHK_FAIL_START
    943. 

  943.   if (pread64 (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
    944. 

  944.       != sizeof (buf) + 1)
    945. 

  945.     FAIL ();
    946. 

  946.   CHK_FAIL_END
    947. 

  947. #endif
    948. 

  948. 

  949.   if (freopen (temp_filename, "r", stdin) == NULL)
    950. 

  950.     {
    951. 

  951.       puts ("could not open temporary file");
    952. 

  952.       exit (1);
    953. 

  953.     }
    954. 

  954. 

  955.   if (fseek (stdin, 9 + 10 + 11, SEEK_SET))
    956. 

  956.     {
    957. 

  957.       puts ("could not seek in test file");
    958. 

  958.       exit (1);
    959. 

  959.     }
    960. 

  960. 

  961. #if __USE_FORTIFY_LEVEL >= 1
    962. 

  962.   CHK_FAIL_START
    963. 

  963.   if (gets (buf) != buf)
    964. 

  964.     FAIL ();
    965. 

  965.   CHK_FAIL_END
    966. 

  966. #endif
    967. 

  967. 

  968.   /* Check whether missing N$ formats are detected.  */
    969. 

  969.   CHK_FAIL2_START
    970. 

  970.   printf ("%3$d\n", 1, 2, 3, 4);
    971. 

  971.   CHK_FAIL2_END
    972. 

  972. 

  973.   CHK_FAIL2_START
    974. 

  974.   fprintf (stdout, "%3$d\n", 1, 2, 3, 4);
    975. 

  975.   CHK_FAIL2_END
    976. 

  976. 

  977.   CHK_FAIL2_START
    978. 

  978.   sprintf (buf, "%3$d\n", 1, 2, 3, 4);
    979. 

  979.   CHK_FAIL2_END
    980. 

  980. 

  981.   CHK_FAIL2_START
    982. 

  982.   snprintf (buf, sizeof (buf), "%3$d\n", 1, 2, 3, 4);
    983. 

  983.   CHK_FAIL2_END
    984. 

  984. 

  985.   int sp[2];
    986. 

  986.   if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp))
    987. 

  987.     FAIL ();
    988. 

  988.   else
    989. 

  989.     {
    990. 

  990.       const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n";
    991. 

  991.       if ((size_t) send (sp[0], sendstr, strlen (sendstr), 0)
    992. 

  992. 	  != strlen (sendstr))
    993. 

  993. 	FAIL ();
    994. 

  994. 

  995.       char recvbuf[12];
    996. 

  996.       if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK)
    997. 

  997. 	  != sizeof recvbuf
    998. 

  998. 	  || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
    999. 

  999. 	FAIL ();
    1000. 

  1000. 

  1001.       if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK)
    1002. 

  1002. 	  != sizeof recvbuf - 7
    1003. 

  1003. 	  || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
    1004. 

  1004. 	FAIL ();
    1005. 

  1005. 

  1006. #if __USE_FORTIFY_LEVEL >= 1
    1007. 

  1007.       CHK_FAIL_START
    1008. 

  1008.       if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK)
    1009. 

  1009. 	  != sizeof recvbuf)
    1010. 

  1010. 	FAIL ();
    1011. 

  1011.       CHK_FAIL_END
    1012. 

  1012. 

  1013.       CHK_FAIL_START
    1014. 

  1014.       if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK)
    1015. 

  1015. 	  != sizeof recvbuf - 3)
    1016. 

  1016. 	FAIL ();
    1017. 

  1017.       CHK_FAIL_END
    1018. 

  1018. #endif
    1019. 

  1019. 

  1020.       socklen_t sl;
    1021. 

  1021.       struct sockaddr_un sa_un;
    1022. 

  1022. 

  1023.       sl = sizeof (sa_un);
    1024. 

  1024.       if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK,
    1025. 

  1025. 		    (struct sockaddr *) &sa_un, &sl)
    1026. 

  1026. 	  != sizeof recvbuf
    1027. 

  1027. 	  || memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
    1028. 

  1028. 	FAIL ();
    1029. 

  1029. 

  1030.       sl = sizeof (sa_un);
    1031. 

  1031.       if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK,
    1032. 

  1032. 		    (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 7
    1033. 

  1033. 	  || memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
    1034. 

  1034. 	FAIL ();
    1035. 

  1035. 

  1036. #if __USE_FORTIFY_LEVEL >= 1
    1037. 

  1037.       CHK_FAIL_START
    1038. 

  1038.       sl = sizeof (sa_un);
    1039. 

  1039.       if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK,
    1040. 

  1040. 		    (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf)
    1041. 

  1041. 	FAIL ();
    1042. 

  1042.       CHK_FAIL_END
    1043. 

  1043. 

  1044.       CHK_FAIL_START
    1045. 

  1045.       sl = sizeof (sa_un);
    1046. 

  1046.       if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK,
    1047. 

  1047. 		    (struct sockaddr *) &sa_un, &sl) != sizeof recvbuf - 3)
    1048. 

  1048. 	FAIL ();
    1049. 

  1049.       CHK_FAIL_END
    1050. 

  1050. #endif
    1051. 

  1051. 

  1052.       close (sp[0]);
    1053. 

  1053.       close (sp[1]);
    1054. 

  1054.     }
    1055. 

  1055. 

  1056.   char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo";
    1057. 

  1057.   char *enddir = strchr (fname, '\0');
    1058. 

  1058.   if (mkdtemp (fname) == NULL)
    1059. 

  1059.     {
    1060. 

  1060.       printf ("mkdtemp failed: %m\n");
    1061. 

  1061.       return 1;
    1062. 

  1062.     }
    1063. 

  1063.   *enddir = '/';
    1064. 

  1064.   if (symlink ("bar", fname) != 0)
    1065. 

  1065.     FAIL ();
    1066. 

  1066. 

  1067.   char readlinkbuf[4];
    1068. 

  1068.   if (readlink (fname, readlinkbuf, 4) != 3
    1069. 

  1069.       || memcmp (readlinkbuf, "bar", 3) != 0)
    1070. 

  1070.     FAIL ();
    1071. 

  1071.   if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3
    1072. 

  1072.       || memcmp (readlinkbuf, "bbar", 4) != 0)
    1073. 

  1073.     FAIL ();
    1074. 

  1074. 

  1075. #if __USE_FORTIFY_LEVEL >= 1
    1076. 

  1076.   CHK_FAIL_START
    1077. 

  1077.   if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3)
    1078. 

  1078.     FAIL ();
    1079. 

  1079.   CHK_FAIL_END
    1080. 

  1080. 

  1081.   CHK_FAIL_START
    1082. 

  1082.   if (readlink (fname, readlinkbuf + 3, 4) != 3)
    1083. 

  1083.     FAIL ();
    1084. 

  1084.   CHK_FAIL_END
    1085. 

  1085. #endif
    1086. 

  1086. 

  1087.   int tmpfd = open ("/tmp", O_RDONLY | O_DIRECTORY);
    1088. 

  1088.   if (tmpfd < 0)
    1089. 

  1089.     FAIL ();
    1090. 

  1090. 

  1091.   if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf, 4) != 3
    1092. 

  1092.       || memcmp (readlinkbuf, "bar", 3) != 0)
    1093. 

  1093.     FAIL ();
    1094. 

  1094.   if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 1,
    1095. 

  1095. 		  l0 + 3) != 3
    1096. 

  1096.       || memcmp (readlinkbuf, "bbar", 4) != 0)
    1097. 

  1097.     FAIL ();
    1098. 

  1098. 

  1099. #if __USE_FORTIFY_LEVEL >= 1
    1100. 

  1100.   CHK_FAIL_START
    1101. 

  1101.   if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 2,
    1102. 

  1102. 		  l0 + 3) != 3)
    1103. 

  1103.     FAIL ();
    1104. 

  1104.   CHK_FAIL_END
    1105. 

  1105. 

  1106.   CHK_FAIL_START
    1107. 

  1107.   if (readlinkat (tmpfd, fname + sizeof ("/tmp/") - 1, readlinkbuf + 3,
    1108. 

  1108. 		  4) != 3)
    1109. 

  1109.     FAIL ();
    1110. 

  1110.   CHK_FAIL_END
    1111. 

  1111. #endif
    1112. 

  1112. 

  1113.   close (tmpfd);
    1114. 

  1114. 

  1115.   char *cwd1 = getcwd (NULL, 0);
    1116. 

  1116.   if (cwd1 == NULL)
    1117. 

  1117.     FAIL ();
    1118. 

  1118. 

  1119.   char *cwd2 = getcwd (NULL, 250);
    1120. 

  1120.   if (cwd2 == NULL)
    1121. 

  1121.     FAIL ();
    1122. 

  1122. 

  1123.   if (cwd1 && cwd2)
    1124. 

  1124.     {
    1125. 

  1125.       if (strcmp (cwd1, cwd2) != 0)
    1126. 

  1126. 	FAIL ();
    1127. 

  1127. 

  1128.       *enddir = '\0';
    1129. 

  1129.       if (chdir (fname))
    1130. 

  1130. 	FAIL ();
    1131. 

  1131. 

  1132.       char *cwd3 = getcwd (NULL, 0);
    1133. 

  1133.       if (cwd3 == NULL)
    1134. 

  1134. 	FAIL ();
    1135. 

  1135.       if (strcmp (fname, cwd3) != 0)
    1136. 

  1136. 	printf ("getcwd after chdir is '%s' != '%s',"
    1137. 

  1137. 		"get{c,}wd tests skipped\n", cwd3, fname);
    1138. 

  1138.       else
    1139. 

  1139. 	{
    1140. 

  1140. 	  char getcwdbuf[sizeof fname - 3];
    1141. 

  1141. 

  1142. 	  char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf);
    1143. 

  1143. 	  if (cwd4 != getcwdbuf
    1144. 

  1144. 	      || strcmp (getcwdbuf, fname) != 0)
    1145. 

  1145. 	    FAIL ();
    1146. 

  1146. 

  1147. 	  cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1);
    1148. 

  1148. 	  if (cwd4 != getcwdbuf + 1
    1149. 

  1149. 	      || getcwdbuf[0] != fname[0]
    1150. 

  1150. 	      || strcmp (getcwdbuf + 1, fname) != 0)
    1151. 

  1151. 	    FAIL ();
    1152. 

  1152. 

  1153. #if __USE_FORTIFY_LEVEL >= 1
    1154. 

  1154. 	  CHK_FAIL_START
    1155. 

  1155. 	  if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf)
    1156. 

  1156. 	      != getcwdbuf + 2)
    1157. 

  1157. 	    FAIL ();
    1158. 

  1158. 	  CHK_FAIL_END
    1159. 

  1159. 

  1160. 	  CHK_FAIL_START
    1161. 

  1161. 	  if (getcwd (getcwdbuf + 2, sizeof getcwdbuf)
    1162. 

  1162. 	      != getcwdbuf + 2)
    1163. 

  1163. 	    FAIL ();
    1164. 

  1164. 	  CHK_FAIL_END
    1165. 

  1165. #endif
    1166. 

  1166. 

  1167. 	  if (getwd (getcwdbuf) != getcwdbuf
    1168. 

  1168. 	      || strcmp (getcwdbuf, fname) != 0)
    1169. 

  1169. 	    FAIL ();
    1170. 

  1170. 

  1171. 	  if (getwd (getcwdbuf + 1) != getcwdbuf + 1
    1172. 

  1172. 	      || strcmp (getcwdbuf + 1, fname) != 0)
    1173. 

  1173. 	    FAIL ();
    1174. 

  1174. 

  1175. #if __USE_FORTIFY_LEVEL >= 1
    1176. 

  1176. 	  CHK_FAIL_START
    1177. 

  1177. 	  if (getwd (getcwdbuf + 2) != getcwdbuf + 2)
    1178. 

  1178. 	    FAIL ();
    1179. 

  1179. 	  CHK_FAIL_END
    1180. 

  1180. #endif
    1181. 

  1181. 	}
    1182. 

  1182. 

  1183.       if (chdir (cwd1) != 0)
    1184. 

  1184. 	FAIL ();
    1185. 

  1185.       free (cwd3);
    1186. 

  1186.     }
    1187. 

  1187. 

  1188.   free (cwd1);
    1189. 

  1189.   free (cwd2);
    1190. 

  1190.   *enddir = '/';
    1191. 

  1191.   if (unlink (fname) != 0)
    1192. 

  1192.     FAIL ();
    1193. 

  1193. 

  1194.   *enddir = '\0';
    1195. 

  1195.   if (rmdir (fname) != 0)
    1196. 

  1196.     FAIL ();
    1197. 

  1197. 

  1198. 

  1199. #if PATH_MAX > 0
    1200. 

  1200.   char largebuf[PATH_MAX];
    1201. 

  1201.   char *realres = realpath (".", largebuf);
    1202. 

  1202.   if (realres != largebuf)
    1203. 

  1203.     FAIL ();
    1204. 

  1204. 

  1205. # if __USE_FORTIFY_LEVEL >= 1
    1206. 

  1206.   CHK_FAIL_START
    1207. 

  1207.   char realbuf[1];
    1208. 

  1208.   realres = realpath (".", realbuf);
    1209. 

  1209.   if (realres != realbuf)
    1210. 

  1210.     FAIL ();
    1211. 

  1211.   CHK_FAIL_END
    1212. 

  1212. # endif
    1213. 

  1213. #endif
    1214. 

  1214. 

  1215. #if __OPTION_POSIX_C_LANG_WIDE_CHAR
    1216. 

  1216.   if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL)
    1217. 

  1217.     {
    1218. 

  1218.       assert (MB_CUR_MAX <= 10);
    1219. 

  1219. 

  1220.       /* First a simple test.  */
    1221. 

  1221.       char enough[10];
    1222. 

  1222.       if (wctomb (enough, L'A') != 1)
    1223. 

  1223. 	FAIL ();
    1224. 

  1224. 

  1225. #if __USE_FORTIFY_LEVEL >= 1
    1226. 

  1226.       /* We know the wchar_t encoding is ISO 10646.  So pick a
    1227. 

  1227. 	 character which has a multibyte representation which does not
    1228. 

  1228. 	 fit.  */
    1229. 

  1229.       CHK_FAIL_START
    1230. 

  1230.       char smallbuf[2];
    1231. 

  1231.       if (wctomb (smallbuf, L'\x100') != 2)
    1232. 

  1232. 	FAIL ();
    1233. 

  1233.       CHK_FAIL_END
    1234. 

  1234. #endif
    1235. 

  1235. 

  1236.       mbstate_t s;
    1237. 

  1237.       memset (&s, '\0', sizeof (s));
    1238. 

  1238.       if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D')
    1239. 

  1239. 	FAIL ();
    1240. 

  1240. 

  1241. #if __USE_FORTIFY_LEVEL >= 1
    1242. 

  1242.       /* We know the wchar_t encoding is ISO 10646.  So pick a
    1243. 

  1243. 	 character which has a multibyte representation which does not
    1244. 

  1244. 	 fit.  */
    1245. 

  1245.       CHK_FAIL_START
    1246. 

  1246.       char smallbuf[2];
    1247. 

  1247.       if (wcrtomb (smallbuf, L'\x100', &s) != 2)
    1248. 

  1248. 	FAIL ();
    1249. 

  1249.       CHK_FAIL_END
    1250. 

  1250. #endif
    1251. 

  1251. 

  1252.       wchar_t wenough[10];
    1253. 

  1253.       memset (&s, '\0', sizeof (s));
    1254. 

  1254.       const char *cp = "A";
    1255. 

  1255.       if (mbsrtowcs (wenough, &cp, 10, &s) != 1
    1256. 

  1256. 	  || wcscmp (wenough, L"A") != 0)
    1257. 

  1257. 	FAIL ();
    1258. 

  1258. 

  1259.       cp = "BC";
    1260. 

  1260.       if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2
    1261. 

  1261. 	  || wcscmp (wenough, L"BC") != 0)
    1262. 

  1262. 	FAIL ();
    1263. 

  1263. 

  1264. #if __USE_FORTIFY_LEVEL >= 1
    1265. 

  1265.       CHK_FAIL_START
    1266. 

  1266.       wchar_t wsmallbuf[2];
    1267. 

  1267.       cp = "ABC";
    1268. 

  1268.       mbsrtowcs (wsmallbuf, &cp, 10, &s);
    1269. 

  1269.       CHK_FAIL_END
    1270. 

  1270. #endif
    1271. 

  1271. 

  1272.       cp = "A";
    1273. 

  1273.       if (mbstowcs (wenough, cp, 10) != 1
    1274. 

  1274. 	  || wcscmp (wenough, L"A") != 0)
    1275. 

  1275. 	FAIL ();
    1276. 

  1276. 

  1277.       cp = "DEF";
    1278. 

  1278.       if (mbstowcs (wenough, cp, l0 + 10) != 3
    1279. 

  1279. 	  || wcscmp (wenough, L"DEF") != 0)
    1280. 

  1280. 	FAIL ();
    1281. 

  1281. 

  1282. #if __USE_FORTIFY_LEVEL >= 1
    1283. 

  1283.       CHK_FAIL_START
    1284. 

  1284.       wchar_t wsmallbuf[2];
    1285. 

  1285.       cp = "ABC";
    1286. 

  1286.       mbstowcs (wsmallbuf, cp, 10);
    1287. 

  1287.       CHK_FAIL_END
    1288. 

  1288. #endif
    1289. 

  1289. 

  1290.       memset (&s, '\0', sizeof (s));
    1291. 

  1291.       cp = "ABC";
    1292. 

  1292.       wcscpy (wenough, L"DEF");
    1293. 

  1293.       if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1
    1294. 

  1294. 	  || wcscmp (wenough, L"AEF") != 0)
    1295. 

  1295. 	FAIL ();
    1296. 

  1296. 

  1297.       cp = "IJ";
    1298. 

  1298.       if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1
    1299. 

  1299. 	  || wcscmp (wenough, L"IEF") != 0)
    1300. 

  1300. 	FAIL ();
    1301. 

  1301. 

  1302. #if __USE_FORTIFY_LEVEL >= 1
    1303. 

  1303.       CHK_FAIL_START
    1304. 

  1304.       wchar_t wsmallbuf[2];
    1305. 

  1305.       cp = "ABC";
    1306. 

  1306.       mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s);
    1307. 

  1307.       CHK_FAIL_END
    1308. 

  1308. #endif
    1309. 

  1309. 

  1310.       memset (&s, '\0', sizeof (s));
    1311. 

  1311.       const wchar_t *wcp = L"A";
    1312. 

  1312.       if (wcsrtombs (enough, &wcp, 10, &s) != 1
    1313. 

  1313. 	  || strcmp (enough, "A") != 0)
    1314. 

  1314. 	FAIL ();
    1315. 

  1315. 

  1316.       wcp = L"BC";
    1317. 

  1317.       if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2
    1318. 

  1318. 	  || strcmp (enough, "BC") != 0)
    1319. 

  1319. 	FAIL ();
    1320. 

  1320. 

  1321. #if __USE_FORTIFY_LEVEL >= 1
    1322. 

  1322.       CHK_FAIL_START
    1323. 

  1323.       char smallbuf[2];
    1324. 

  1324.       wcp = L"ABC";
    1325. 

  1325.       wcsrtombs (smallbuf, &wcp, 10, &s);
    1326. 

  1326.       CHK_FAIL_END
    1327. 

  1327. #endif
    1328. 

  1328. 

  1329.       memset (enough, 'Z', sizeof (enough));
    1330. 

  1330.       wcp = L"EF";
    1331. 

  1331.       if (wcstombs (enough, wcp, 10) != 2
    1332. 

  1332. 	  || strcmp (enough, "EF") != 0)
    1333. 

  1333. 	FAIL ();
    1334. 

  1334. 

  1335.       wcp = L"G";
    1336. 

  1336.       if (wcstombs (enough, wcp, l0 + 10) != 1
    1337. 

  1337. 	  || strcmp (enough, "G") != 0)
    1338. 

  1338. 	FAIL ();
    1339. 

  1339. 

  1340. #if __USE_FORTIFY_LEVEL >= 1
    1341. 

  1341.       CHK_FAIL_START
    1342. 

  1342.       char smallbuf[2];
    1343. 

  1343.       wcp = L"ABC";
    1344. 

  1344.       wcstombs (smallbuf, wcp, 10);
    1345. 

  1345.       CHK_FAIL_END
    1346. 

  1346. #endif
    1347. 

  1347. 

  1348.       memset (&s, '\0', sizeof (s));
    1349. 

  1349.       wcp = L"AB";
    1350. 

  1350.       if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1
    1351. 

  1351. 	  || strcmp (enough, "A") != 0)
    1352. 

  1352. 	FAIL ();
    1353. 

  1353. 

  1354.       wcp = L"BCD";
    1355. 

  1355.       if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1
    1356. 

  1356. 	  || strcmp (enough, "B") != 0)
    1357. 

  1357. 	FAIL ();
    1358. 

  1358. 

  1359. #if __USE_FORTIFY_LEVEL >= 1
    1360. 

  1360.       CHK_FAIL_START
    1361. 

  1361.       char smallbuf[2];
    1362. 

  1362.       wcp = L"ABC";
    1363. 

  1363.       wcsnrtombs (smallbuf, &wcp, 3, 10, &s);
    1364. 

  1364.       CHK_FAIL_END
    1365. 

  1365. #endif
    1366. 

  1366.     }
    1367. 

  1367.   else
    1368. 

  1368.     {
    1369. 

  1369.       puts ("cannot set locale");
    1370. 

  1370.       ret = 1;
    1371. 

  1371.     }
    1372. 

  1372. #endif /* __OPTION_POSIX_C_LANG_WIDE_CHAR */
    1373. 

  1373. 

  1374.   fd = posix_openpt (O_RDWR);
    1375. 

  1375.   if (fd != -1)
    1376. 

  1376.     {
    1377. 

  1377.       char enough[1000];
    1378. 

  1378.       if (ptsname_r (fd, enough, sizeof (enough)) != 0)
    1379. 

  1379. 	FAIL ();
    1380. 

  1380. 

  1381. #if __USE_FORTIFY_LEVEL >= 1
    1382. 

  1382.       CHK_FAIL_START
    1383. 

  1383.       char smallbuf[2];
    1384. 

  1384.       if (ptsname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
    1385. 

  1385. 	FAIL ();
    1386. 

  1386.       CHK_FAIL_END
    1387. 

  1387. #endif
    1388. 

  1388.       close (fd);
    1389. 

  1389.     }
    1390. 

  1390. 

  1391. #if PATH_MAX > 0
    1392. 

  1392.   confstr (_CS_GNU_LIBC_VERSION, largebuf, sizeof (largebuf));
    1393. 

  1393. # if __USE_FORTIFY_LEVEL >= 1
    1394. 

  1394.   CHK_FAIL_START
    1395. 

  1395.   char smallbuf[1];
    1396. 

  1396.   confstr (_CS_GNU_LIBC_VERSION, smallbuf, sizeof (largebuf));
    1397. 

  1397.   CHK_FAIL_END
    1398. 

  1398. # endif
    1399. 

  1399. #endif
    1400. 

  1400. 

  1401.   gid_t grpslarge[5];
    1402. 

  1402.   int ngr = getgroups (5, grpslarge);
    1403. 

  1403.   asm volatile ("" : : "r" (ngr));
    1404. 

  1404. #if __USE_FORTIFY_LEVEL >= 1
    1405. 

  1405.   CHK_FAIL_START
    1406. 

  1406.   char smallbuf[1];
    1407. 

  1407.   ngr = getgroups (5, (gid_t *) smallbuf);
    1408. 

  1408.   asm volatile ("" : : "r" (ngr));
    1409. 

  1409.   CHK_FAIL_END
    1410. 

  1410. #endif
    1411. 

  1411. 

  1412.   fd = open (_PATH_TTY, O_RDONLY);
    1413. 

  1413.   if (fd != -1)
    1414. 

  1414.     {
    1415. 

  1415.       char enough[1000];
    1416. 

  1416.       if (ttyname_r (fd, enough, sizeof (enough)) != 0)
    1417. 

  1417. 	FAIL ();
    1418. 

  1418. 

  1419. #if __USE_FORTIFY_LEVEL >= 1
    1420. 

  1420.       CHK_FAIL_START
    1421. 

  1421.       char smallbuf[2];
    1422. 

  1422.       if (ttyname_r (fd, smallbuf, sizeof (smallbuf) + 1) == 0)
    1423. 

  1423. 	FAIL ();
    1424. 

  1424.       CHK_FAIL_END
    1425. 

  1425. #endif
    1426. 

  1426.       close (fd);
    1427. 

  1427.     }
    1428. 

  1428. 

  1429.   char hostnamelarge[1000];
    1430. 

  1430.   gethostname (hostnamelarge, sizeof (hostnamelarge));
    1431. 

  1431. #if __USE_FORTIFY_LEVEL >= 1
    1432. 

  1432.   CHK_FAIL_START
    1433. 

  1433.   char smallbuf[1];
    1434. 

  1434.   gethostname (smallbuf, sizeof (hostnamelarge));
    1435. 

  1435.   CHK_FAIL_END
    1436. 

  1436. #endif
    1437. 

  1437. 

  1438.   char loginlarge[1000];
    1439. 

  1439.   getlogin_r (loginlarge, sizeof (hostnamelarge));
    1440. 

  1440. #if __USE_FORTIFY_LEVEL >= 1
    1441. 

  1441.   CHK_FAIL_START
    1442. 

  1442.   char smallbuf[1];
    1443. 

  1443.   getlogin_r (smallbuf, sizeof (loginlarge));
    1444. 

  1444.   CHK_FAIL_END
    1445. 

  1445. #endif
    1446. 

  1446. 

  1447.   char domainnamelarge[1000];
    1448. 

  1448.   int res = getdomainname (domainnamelarge, sizeof (domainnamelarge));
    1449. 

  1449.   asm volatile ("" : : "r" (res));
    1450. 

  1450. #if __USE_FORTIFY_LEVEL >= 1
    1451. 

  1451.   CHK_FAIL_START
    1452. 

  1452.   char smallbuf[1];
    1453. 

  1453.   res = getdomainname (smallbuf, sizeof (domainnamelarge));
    1454. 

  1454.   asm volatile ("" : : "r" (res));
    1455. 

  1455.   CHK_FAIL_END
    1456. 

  1456. #endif
    1457. 

  1457. 

  1458.   return ret;
    1459. 

  1459. }
    1460. 

  1460.