1/* Checking macros for wchar functions.
2 Copyright (C) 2005-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19#ifndef _WCHAR_H
20# error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
21#endif
22
23
24extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
25 const wchar_t *__restrict __s2, size_t __n,
26 size_t __ns1) __THROW;
27extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
28 (wchar_t *__restrict __s1,
29 const wchar_t *__restrict __s2, size_t __n),
30 wmemcpy);
31extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn,
32 (wchar_t *__restrict __s1,
33 const wchar_t *__restrict __s2, size_t __n,
34 size_t __ns1), __wmemcpy_chk)
35 __warnattr ("wmemcpy called with length bigger than size of destination "
36 "buffer");
37
38__fortify_function wchar_t *
39__NTH (wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2,
40 size_t __n))
41{
42 if (__glibc_objsize0 (__s1) != (size_t) -1)
43 {
44 if (!__builtin_constant_p (__n))
45 return __wmemcpy_chk (__s1, __s2, __n,
46 __glibc_objsize0 (__s1) / sizeof (wchar_t));
47
48 if (__n > __glibc_objsize0 (__s1) / sizeof (wchar_t))
49 return __wmemcpy_chk_warn (__s1, __s2, __n,
50 __glibc_objsize0 (__s1) / sizeof (wchar_t));
51 }
52 return __wmemcpy_alias (__s1, __s2, __n);
53}
54
55
56extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2,
57 size_t __n, size_t __ns1) __THROW;
58extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
59 const wchar_t *__s2,
60 size_t __n), wmemmove);
61extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn,
62 (wchar_t *__s1, const wchar_t *__s2,
63 size_t __n, size_t __ns1), __wmemmove_chk)
64 __warnattr ("wmemmove called with length bigger than size of destination "
65 "buffer");
66
67__fortify_function wchar_t *
68__NTH (wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n))
69{
70 if (__glibc_objsize0 (__s1) != (size_t) -1)
71 {
72 if (!__builtin_constant_p (__n))
73 return __wmemmove_chk (__s1, __s2, __n,
74 __glibc_objsize0 (__s1) / sizeof (wchar_t));
75
76 if (__n > __glibc_objsize0 (__s1) / sizeof (wchar_t))
77 return __wmemmove_chk_warn (__s1, __s2, __n,
78 (__glibc_objsize0 (__s1)
79 / sizeof (wchar_t)));
80 }
81 return __wmemmove_alias (__s1, __s2, __n);
82}
83
84
85#ifdef __USE_GNU
86extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
87 const wchar_t *__restrict __s2, size_t __n,
88 size_t __ns1) __THROW;
89extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
90 (wchar_t *__restrict __s1,
91 const wchar_t *__restrict __s2,
92 size_t __n), wmempcpy);
93extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn,
94 (wchar_t *__restrict __s1,
95 const wchar_t *__restrict __s2, size_t __n,
96 size_t __ns1), __wmempcpy_chk)
97 __warnattr ("wmempcpy called with length bigger than size of destination "
98 "buffer");
99
100__fortify_function wchar_t *
101__NTH (wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2,
102 size_t __n))
103{
104 if (__glibc_objsize0 (__s1) != (size_t) -1)
105 {
106 if (!__builtin_constant_p (__n))
107 return __wmempcpy_chk (__s1, __s2, __n,
108 __glibc_objsize0 (__s1) / sizeof (wchar_t));
109
110 if (__n > __glibc_objsize0 (__s1) / sizeof (wchar_t))
111 return __wmempcpy_chk_warn (__s1, __s2, __n,
112 (__glibc_objsize0 (__s1)
113 / sizeof (wchar_t)));
114 }
115 return __wmempcpy_alias (__s1, __s2, __n);
116}
117#endif
118
119
120extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
121 size_t __ns) __THROW;
122extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
123 size_t __n), wmemset);
124extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn,
125 (wchar_t *__s, wchar_t __c, size_t __n,
126 size_t __ns), __wmemset_chk)
127 __warnattr ("wmemset called with length bigger than size of destination "
128 "buffer");
129
130__fortify_function wchar_t *
131__NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n))
132{
133 if (__glibc_objsize0 (__s) != (size_t) -1)
134 {
135 if (!__builtin_constant_p (__n))
136 return __wmemset_chk (__s, __c, __n,
137 __glibc_objsize0 (__s) / sizeof (wchar_t));
138
139 if (__n > __glibc_objsize0 (__s) / sizeof (wchar_t))
140 return __wmemset_chk_warn (__s, __c, __n,
141 __glibc_objsize0 (__s) / sizeof (wchar_t));
142 }
143 return __wmemset_alias (__s, __c, __n);
144}
145
146
147extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
148 const wchar_t *__restrict __src,
149 size_t __n) __THROW;
150extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
151 (wchar_t *__restrict __dest,
152 const wchar_t *__restrict __src), wcscpy);
153
154__fortify_function wchar_t *
155__NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
156{
157 if (__glibc_objsize (__dest) != (size_t) -1)
158 return __wcscpy_chk (__dest, __src,
159 __glibc_objsize (__dest) / sizeof (wchar_t));
160 return __wcscpy_alias (__dest, __src);
161}
162
163
164extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
165 const wchar_t *__restrict __src,
166 size_t __destlen) __THROW;
167extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias,
168 (wchar_t *__restrict __dest,
169 const wchar_t *__restrict __src), wcpcpy);
170
171__fortify_function wchar_t *
172__NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
173{
174 if (__glibc_objsize (__dest) != (size_t) -1)
175 return __wcpcpy_chk (__dest, __src,
176 __glibc_objsize (__dest) / sizeof (wchar_t));
177 return __wcpcpy_alias (__dest, __src);
178}
179
180
181extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
182 const wchar_t *__restrict __src, size_t __n,
183 size_t __destlen) __THROW;
184extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
185 (wchar_t *__restrict __dest,
186 const wchar_t *__restrict __src,
187 size_t __n), wcsncpy);
188extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn,
189 (wchar_t *__restrict __dest,
190 const wchar_t *__restrict __src,
191 size_t __n, size_t __destlen), __wcsncpy_chk)
192 __warnattr ("wcsncpy called with length bigger than size of destination "
193 "buffer");
194
195__fortify_function wchar_t *
196__NTH (wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src,
197 size_t __n))
198{
199 if (__glibc_objsize (__dest) != (size_t) -1)
200 {
201 if (!__builtin_constant_p (__n))
202 return __wcsncpy_chk (__dest, __src, __n,
203 __glibc_objsize (__dest) / sizeof (wchar_t));
204 if (__n > __glibc_objsize (__dest) / sizeof (wchar_t))
205 return __wcsncpy_chk_warn (__dest, __src, __n,
206 (__glibc_objsize (__dest)
207 / sizeof (wchar_t)));
208 }
209 return __wcsncpy_alias (__dest, __src, __n);
210}
211
212
213extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
214 const wchar_t *__restrict __src, size_t __n,
215 size_t __destlen) __THROW;
216extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
217 (wchar_t *__restrict __dest,
218 const wchar_t *__restrict __src,
219 size_t __n), wcpncpy);
220extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn,
221 (wchar_t *__restrict __dest,
222 const wchar_t *__restrict __src,
223 size_t __n, size_t __destlen), __wcpncpy_chk)
224 __warnattr ("wcpncpy called with length bigger than size of destination "
225 "buffer");
226
227__fortify_function wchar_t *
228__NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src,
229 size_t __n))
230{
231 if (__glibc_objsize (__dest) != (size_t) -1)
232 {
233 if (!__builtin_constant_p (__n))
234 return __wcpncpy_chk (__dest, __src, __n,
235 __glibc_objsize (__dest) / sizeof (wchar_t));
236 if (__n > __glibc_objsize (__dest) / sizeof (wchar_t))
237 return __wcpncpy_chk_warn (__dest, __src, __n,
238 (__glibc_objsize (__dest)
239 / sizeof (wchar_t)));
240 }
241 return __wcpncpy_alias (__dest, __src, __n);
242}
243
244
245extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
246 const wchar_t *__restrict __src,
247 size_t __destlen) __THROW;
248extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
249 (wchar_t *__restrict __dest,
250 const wchar_t *__restrict __src), wcscat);
251
252__fortify_function wchar_t *
253__NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
254{
255 if (__glibc_objsize (__dest) != (size_t) -1)
256 return __wcscat_chk (__dest, __src,
257 __glibc_objsize (__dest) / sizeof (wchar_t));
258 return __wcscat_alias (__dest, __src);
259}
260
261
262extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
263 const wchar_t *__restrict __src,
264 size_t __n, size_t __destlen) __THROW;
265extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
266 (wchar_t *__restrict __dest,
267 const wchar_t *__restrict __src,
268 size_t __n), wcsncat);
269
270__fortify_function wchar_t *
271__NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src,
272 size_t __n))
273{
274 if (__glibc_objsize (__dest) != (size_t) -1)
275 return __wcsncat_chk (__dest, __src, __n,
276 __glibc_objsize (__dest) / sizeof (wchar_t));
277 return __wcsncat_alias (__dest, __src, __n);
278}
279
280
281extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
282 int __flag, size_t __s_len,
283 const wchar_t *__restrict __format, ...)
284 __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
285
286extern int __REDIRECT_NTH_LDBL (__swprintf_alias,
287 (wchar_t *__restrict __s, size_t __n,
288 const wchar_t *__restrict __fmt, ...),
289 swprintf);
290
291#ifdef __va_arg_pack
292__fortify_function int
293__NTH (swprintf (wchar_t *__restrict __s, size_t __n,
294 const wchar_t *__restrict __fmt, ...))
295{
296 if (__glibc_objsize (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
297 return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
298 __glibc_objsize (__s) / sizeof (wchar_t),
299 __fmt, __va_arg_pack ());
300 return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
301}
302#elif !defined __cplusplus
303/* XXX We might want to have support in gcc for swprintf. */
304# define swprintf(s, n, ...) \
305 (__glibc_objsize (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1 \
306 ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, \
307 __glibc_objsize (s) / sizeof (wchar_t), __VA_ARGS__) \
308 : swprintf (s, n, __VA_ARGS__))
309#endif
310
311extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
312 int __flag, size_t __s_len,
313 const wchar_t *__restrict __format,
314 __gnuc_va_list __arg)
315 __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
316
317extern int __REDIRECT_NTH_LDBL (__vswprintf_alias,
318 (wchar_t *__restrict __s, size_t __n,
319 const wchar_t *__restrict __fmt,
320 __gnuc_va_list __ap), vswprintf);
321
322__fortify_function int
323__NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
324 const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
325{
326 if (__glibc_objsize (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
327 return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
328 __glibc_objsize (__s) / sizeof (wchar_t), __fmt,
329 __ap);
330 return __vswprintf_alias (__s, __n, __fmt, __ap);
331}
332
333
334#if __USE_FORTIFY_LEVEL > 1
335
336extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
337 const wchar_t *__restrict __format, ...);
338extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format,
339 ...);
340extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
341 const wchar_t *__restrict __format,
342 __gnuc_va_list __ap);
343extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format,
344 __gnuc_va_list __ap);
345
346# ifdef __va_arg_pack
347__fortify_function int
348wprintf (const wchar_t *__restrict __fmt, ...)
349{
350 return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
351}
352
353__fortify_function int
354fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...)
355{
356 return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
357 __va_arg_pack ());
358}
359# elif !defined __cplusplus
360# define wprintf(...) \
361 __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
362# define fwprintf(stream, ...) \
363 __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
364# endif
365
366__fortify_function int
367vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
368{
369 return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
370}
371
372__fortify_function int
373vfwprintf (__FILE *__restrict __stream,
374 const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
375{
376 return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
377}
378
379#endif
380
381extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
382 __FILE *__restrict __stream) __wur;
383extern wchar_t *__REDIRECT (__fgetws_alias,
384 (wchar_t *__restrict __s, int __n,
385 __FILE *__restrict __stream), fgetws) __wur;
386extern wchar_t *__REDIRECT (__fgetws_chk_warn,
387 (wchar_t *__restrict __s, size_t __size, int __n,
388 __FILE *__restrict __stream), __fgetws_chk)
389 __wur __warnattr ("fgetws called with bigger size than length "
390 "of destination buffer");
391
392__fortify_function __wur wchar_t *
393fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
394{
395 if (__glibc_objsize (__s) != (size_t) -1)
396 {
397 if (!__builtin_constant_p (__n) || __n <= 0)
398 return __fgetws_chk (__s, __glibc_objsize (__s) / sizeof (wchar_t),
399 __n, __stream);
400
401 if ((size_t) __n > __glibc_objsize (__s) / sizeof (wchar_t))
402 return __fgetws_chk_warn (__s,
403 __glibc_objsize (__s) / sizeof (wchar_t),
404 __n, __stream);
405 }
406 return __fgetws_alias (__s, __n, __stream);
407}
408
409#ifdef __USE_GNU
410extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
411 int __n, __FILE *__restrict __stream)
412 __wur;
413extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
414 (wchar_t *__restrict __s, int __n,
415 __FILE *__restrict __stream), fgetws_unlocked)
416 __wur;
417extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
418 (wchar_t *__restrict __s, size_t __size, int __n,
419 __FILE *__restrict __stream),
420 __fgetws_unlocked_chk)
421 __wur __warnattr ("fgetws_unlocked called with bigger size than length "
422 "of destination buffer");
423
424__fortify_function __wur wchar_t *
425fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
426{
427 if (__glibc_objsize (__s) != (size_t) -1)
428 {
429 if (!__builtin_constant_p (__n) || __n <= 0)
430 return __fgetws_unlocked_chk (__s,
431 __glibc_objsize (__s) / sizeof (wchar_t),
432 __n, __stream);
433
434 if ((size_t) __n > __glibc_objsize (__s) / sizeof (wchar_t))
435 return __fgetws_unlocked_chk_warn (__s,
436 (__glibc_objsize (__s)
437 / sizeof (wchar_t)),
438 __n, __stream);
439 }
440 return __fgetws_unlocked_alias (__s, __n, __stream);
441}
442#endif
443
444
445extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
446 mbstate_t *__restrict __p,
447 size_t __buflen) __THROW __wur;
448extern size_t __REDIRECT_NTH (__wcrtomb_alias,
449 (char *__restrict __s, wchar_t __wchar,
450 mbstate_t *__restrict __ps), wcrtomb) __wur;
451
452__fortify_function __wur size_t
453__NTH (wcrtomb (char *__restrict __s, wchar_t __wchar,
454 mbstate_t *__restrict __ps))
455{
456 /* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
457 But this would only disturb the namespace. So we define our own
458 version here. */
459#define __WCHAR_MB_LEN_MAX 16
460#if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
461# error "Assumed value of MB_LEN_MAX wrong"
462#endif
463 if (__glibc_objsize (__s) != (size_t) -1
464 && __WCHAR_MB_LEN_MAX > __glibc_objsize (__s))
465 return __wcrtomb_chk (__s, __wchar, __ps, __glibc_objsize (__s));
466 return __wcrtomb_alias (__s, __wchar, __ps);
467}
468
469
470extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
471 const char **__restrict __src,
472 size_t __len, mbstate_t *__restrict __ps,
473 size_t __dstlen) __THROW;
474extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
475 (wchar_t *__restrict __dst,
476 const char **__restrict __src,
477 size_t __len, mbstate_t *__restrict __ps),
478 mbsrtowcs);
479extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn,
480 (wchar_t *__restrict __dst,
481 const char **__restrict __src,
482 size_t __len, mbstate_t *__restrict __ps,
483 size_t __dstlen), __mbsrtowcs_chk)
484 __warnattr ("mbsrtowcs called with dst buffer smaller than len "
485 "* sizeof (wchar_t)");
486
487__fortify_function size_t
488__NTH (mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src,
489 size_t __len, mbstate_t *__restrict __ps))
490{
491 if (__glibc_objsize (__dst) != (size_t) -1)
492 {
493 if (!__builtin_constant_p (__len))
494 return __mbsrtowcs_chk (__dst, __src, __len, __ps,
495 __glibc_objsize (__dst) / sizeof (wchar_t));
496
497 if (__len > __glibc_objsize (__dst) / sizeof (wchar_t))
498 return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
499 (__glibc_objsize (__dst)
500 / sizeof (wchar_t)));
501 }
502 return __mbsrtowcs_alias (__dst, __src, __len, __ps);
503}
504
505
506extern size_t __wcsrtombs_chk (char *__restrict __dst,
507 const wchar_t **__restrict __src,
508 size_t __len, mbstate_t *__restrict __ps,
509 size_t __dstlen) __THROW;
510extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
511 (char *__restrict __dst,
512 const wchar_t **__restrict __src,
513 size_t __len, mbstate_t *__restrict __ps),
514 wcsrtombs);
515extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn,
516 (char *__restrict __dst,
517 const wchar_t **__restrict __src,
518 size_t __len, mbstate_t *__restrict __ps,
519 size_t __dstlen), __wcsrtombs_chk)
520 __warnattr ("wcsrtombs called with dst buffer smaller than len");
521
522__fortify_function size_t
523__NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src,
524 size_t __len, mbstate_t *__restrict __ps))
525{
526 if (__glibc_objsize (__dst) != (size_t) -1)
527 {
528 if (!__builtin_constant_p (__len))
529 return __wcsrtombs_chk (__dst, __src, __len, __ps,
530 __glibc_objsize (__dst));
531
532 if (__len > __glibc_objsize (__dst))
533 return __wcsrtombs_chk_warn (__dst, __src, __len, __ps,
534 __glibc_objsize (__dst));
535 }
536 return __wcsrtombs_alias (__dst, __src, __len, __ps);
537}
538
539
540#ifdef __USE_GNU
541extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
542 const char **__restrict __src, size_t __nmc,
543 size_t __len, mbstate_t *__restrict __ps,
544 size_t __dstlen) __THROW;
545extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
546 (wchar_t *__restrict __dst,
547 const char **__restrict __src, size_t __nmc,
548 size_t __len, mbstate_t *__restrict __ps),
549 mbsnrtowcs);
550extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn,
551 (wchar_t *__restrict __dst,
552 const char **__restrict __src, size_t __nmc,
553 size_t __len, mbstate_t *__restrict __ps,
554 size_t __dstlen), __mbsnrtowcs_chk)
555 __warnattr ("mbsnrtowcs called with dst buffer smaller than len "
556 "* sizeof (wchar_t)");
557
558__fortify_function size_t
559__NTH (mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src,
560 size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
561{
562 if (__glibc_objsize (__dst) != (size_t) -1)
563 {
564 if (!__builtin_constant_p (__len))
565 return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
566 __glibc_objsize (__dst) / sizeof (wchar_t));
567
568 if (__len > __glibc_objsize (__dst) / sizeof (wchar_t))
569 return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
570 (__glibc_objsize (__dst)
571 / sizeof (wchar_t)));
572 }
573 return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
574}
575
576
577extern size_t __wcsnrtombs_chk (char *__restrict __dst,
578 const wchar_t **__restrict __src,
579 size_t __nwc, size_t __len,
580 mbstate_t *__restrict __ps, size_t __dstlen)
581 __THROW;
582extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
583 (char *__restrict __dst,
584 const wchar_t **__restrict __src,
585 size_t __nwc, size_t __len,
586 mbstate_t *__restrict __ps), wcsnrtombs);
587extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn,
588 (char *__restrict __dst,
589 const wchar_t **__restrict __src,
590 size_t __nwc, size_t __len,
591 mbstate_t *__restrict __ps,
592 size_t __dstlen), __wcsnrtombs_chk)
593 __warnattr ("wcsnrtombs called with dst buffer smaller than len");
594
595__fortify_function size_t
596__NTH (wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src,
597 size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
598{
599 if (__glibc_objsize (__dst) != (size_t) -1)
600 {
601 if (!__builtin_constant_p (__len))
602 return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
603 __glibc_objsize (__dst));
604
605 if (__len > __glibc_objsize (__dst))
606 return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
607 __glibc_objsize (__dst));
608 }
609 return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
610}
611#endif
612