AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-04 10:50:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix name space violation in fortify wrappers (bug 32052)

Browse Source 
Rename the identifier sz to __sz everywhere.

Fixes: a643f60c53 ("Make sure that the fortified function conditionals are constant")
(cherry picked from commit 39ca997ab3)
(redone from scratch because of many conflicts)
This commit is contained in:
Andreas Schwab 2024-08-05 10:55:51 +02:00 committed by Florian Weimer
parent aca9c7d5de
commit 6e642a47fa
5 changed files with 64 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
NEWS
View File

@ -68,6 +68,7 @@ The following bugs are resolved with this release:
[31890] resolv: Allow short error responses to match any DNS query
[31965] rseq extension mechanism does not work as intended
[31968] mremap implementation in C does not handle arguments correctly
[32052] Name space violation in fortify wrappers
Version 2.37

40
libio/bits/stdio2.h
View File

@ -208,12 +208,12 @@ extern char *__REDIRECT (__fgets_chk_warn,
__fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) char *
fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
{
size_t sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz))
size_t __sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz))
return __fgets_alias (__s, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (char), sz))
return __fgets_chk_warn (__s, sz, __n, __stream);
return __fgets_chk (__s, sz, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (char), __sz))
return __fgets_chk_warn (__s, __sz, __n, __stream);
return __fgets_chk (__s, __sz, __n, __stream);
}
extern size_t __REDIRECT (__fread_alias,
@ -232,12 +232,12 @@ __fortify_function __wur size_t
fread (void *__restrict __ptr, size_t __size, size_t __n,
FILE *__restrict __stream)
{
size_t sz = __glibc_objsize0 (__ptr);
if (__glibc_safe_or_unknown_len (__n, __size, sz))
size_t __sz = __glibc_objsize0 (__ptr);
if (__glibc_safe_or_unknown_len (__n, __size, __sz))
return __fread_alias (__ptr, __size, __n, __stream);
if (__glibc_unsafe_len (__n, __size, sz))
return __fread_chk_warn (__ptr, sz, __size, __n, __stream);
return __fread_chk (__ptr, sz, __size, __n, __stream);
if (__glibc_unsafe_len (__n, __size, __sz))
return __fread_chk_warn (__ptr, __sz, __size, __n, __stream);
return __fread_chk (__ptr, __sz, __size, __n, __stream);
}
#ifdef __USE_GNU
@ -254,12 +254,12 @@ extern char *__REDIRECT (__fgets_unlocked_chk_warn,
__fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) char *
fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
{
size_t sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz))
size_t __sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz))
return __fgets_unlocked_alias (__s, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (char), sz))
return __fgets_unlocked_chk_warn (__s, sz, __n, __stream);
return __fgets_unlocked_chk (__s, sz, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (char), __sz))
return __fgets_unlocked_chk_warn (__s, __sz, __n, __stream);
return __fgets_unlocked_chk (__s, __sz, __n, __stream);
}
#endif
@ -281,8 +281,8 @@ __fortify_function __wur size_t
fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
FILE *__restrict __stream)
{
size_t sz = __glibc_objsize0 (__ptr);
if (__glibc_safe_or_unknown_len (__n, __size, sz))
size_t __sz = __glibc_objsize0 (__ptr);
if (__glibc_safe_or_unknown_len (__n, __size, __sz))
{
# ifdef __USE_EXTERN_INLINES
if (__builtin_constant_p (__size)
@ -307,9 +307,9 @@ fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
# endif
return __fread_unlocked_alias (__ptr, __size, __n, __stream);
}
if (__glibc_unsafe_len (__n, __size, sz))
return __fread_unlocked_chk_warn (__ptr, sz, __size, __n, __stream);
return __fread_unlocked_chk (__ptr, sz, __size, __n, __stream);
if (__glibc_unsafe_len (__n, __size, __sz))
return __fread_unlocked_chk_warn (__ptr, __sz, __size, __n, __stream);
return __fread_unlocked_chk (__ptr, __sz, __size, __n, __stream);
}
#endif

20
socket/bits/socket2.h
View File

@ -33,12 +33,12 @@ extern ssize_t __REDIRECT (__recv_chk_warn,
__fortify_function ssize_t
recv (int __fd, void *__buf, size_t __n, int __flags)
{
size_t sz = __glibc_objsize0 (__buf);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz))
size_t __sz = __glibc_objsize0 (__buf);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz))
return __recv_alias (__fd, __buf, __n, __flags);
if (__glibc_unsafe_len (__n, sizeof (char), sz))
return __recv_chk_warn (__fd, __buf, __n, sz, __flags);
return __recv_chk (__fd, __buf, __n, sz, __flags);
if (__glibc_unsafe_len (__n, sizeof (char), __sz))
return __recv_chk_warn (__fd, __buf, __n, __sz, __flags);
return __recv_chk (__fd, __buf, __n, __sz, __flags);
}
extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n,
@ -61,11 +61,11 @@ __fortify_function ssize_t
recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
__SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len)
{
size_t sz = __glibc_objsize0 (__buf);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz))
size_t __sz = __glibc_objsize0 (__buf);
if (__glibc_safe_or_unknown_len (__n, sizeof (char), __sz))
return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
if (__glibc_unsafe_len (__n, sizeof (char), sz))
return __recvfrom_chk_warn (__fd, __buf, __n, sz, __flags, __addr,
if (__glibc_unsafe_len (__n, sizeof (char), __sz))
return __recvfrom_chk_warn (__fd, __buf, __n, __sz, __flags, __addr,
__addr_len);
return __recvfrom_chk (__fd, __buf, __n, sz, __flags, __addr, __addr_len);
return __recvfrom_chk (__fd, __buf, __n, __sz, __flags, __addr, __addr_len);
}

10
stdlib/bits/stdlib.h
View File

@ -36,16 +36,16 @@ extern char *__REDIRECT_NTH (__realpath_chk_warn,
__fortify_function __wur char *
__NTH (realpath (const char *__restrict __name, char *__restrict __resolved))
{
size_t sz = __glibc_objsize (__resolved);
size_t __sz = __glibc_objsize (__resolved);
if (sz == (size_t) -1)
if (__sz == (size_t) -1)
return __realpath_alias (__name, __resolved);
#if defined _LIBC_LIMITS_H_ && defined PATH_MAX
if (__glibc_unsafe_len (PATH_MAX, sizeof (char), sz))
return __realpath_chk_warn (__name, __resolved, sz);
if (__glibc_unsafe_len (PATH_MAX, sizeof (char), __sz))
return __realpath_chk_warn (__name, __resolved, __sz);
#endif
return __realpath_chk (__name, __resolved, sz);
return __realpath_chk (__name, __resolved, __sz);
}

56
wcsmbs/bits/wchar2.h
View File

@ -107,9 +107,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
__fortify_function wchar_t *
__NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
{
size_t sz = __glibc_objsize (__dest);
if (sz != (size_t) -1)
return __wcscpy_chk (__dest, __src, sz / sizeof (wchar_t));
size_t __sz = __glibc_objsize (__dest);
if (__sz != (size_t) -1)
return __wcscpy_chk (__dest, __src, __sz / sizeof (wchar_t));
return __wcscpy_alias (__dest, __src);
}
@ -121,9 +121,9 @@ extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias,
__fortify_function wchar_t *
__NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
{
size_t sz = __glibc_objsize (__dest);
if (sz != (size_t) -1)
return __wcpcpy_chk (__dest, __src, sz / sizeof (wchar_t));
size_t __sz = __glibc_objsize (__dest);
if (__sz != (size_t) -1)
return __wcpcpy_chk (__dest, __src, __sz / sizeof (wchar_t));
return __wcpcpy_alias (__dest, __src);
}
@ -177,9 +177,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
__fortify_function wchar_t *
__NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src))
{
size_t sz = __glibc_objsize (__dest);
if (sz != (size_t) -1)
return __wcscat_chk (__dest, __src, sz / sizeof (wchar_t));
size_t __sz = __glibc_objsize (__dest);
if (__sz != (size_t) -1)
return __wcscat_chk (__dest, __src, __sz / sizeof (wchar_t));
return __wcscat_alias (__dest, __src);
}
@ -193,9 +193,9 @@ __fortify_function wchar_t *
__NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src,
size_t __n))
{
size_t sz = __glibc_objsize (__dest);
if (sz != (size_t) -1)
return __wcsncat_chk (__dest, __src, __n, sz / sizeof (wchar_t));
size_t __sz = __glibc_objsize (__dest);
if (__sz != (size_t) -1)
return __wcsncat_chk (__dest, __src, __n, __sz / sizeof (wchar_t));
return __wcsncat_alias (__dest, __src, __n);
}
@ -211,10 +211,10 @@ __fortify_function int
__NTH (swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __fmt, ...))
{
size_t sz = __glibc_objsize (__s);
if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
size_t __sz = __glibc_objsize (__s);
if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
sz / sizeof (wchar_t), __fmt, __va_arg_pack ());
__sz / sizeof (wchar_t), __fmt, __va_arg_pack ());
return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
}
#elif !defined __cplusplus
@ -236,10 +236,10 @@ __fortify_function int
__NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
{
size_t sz = __glibc_objsize (__s);
if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
size_t __sz = __glibc_objsize (__s);
if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
sz / sizeof (wchar_t), __fmt, __ap);
__sz / sizeof (wchar_t), __fmt, __ap);
return __vswprintf_alias (__s, __n, __fmt, __ap);
}
@ -293,12 +293,12 @@ extern wchar_t *__REDIRECT (__fgetws_chk_warn,
__fortify_function __wur wchar_t *
fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
size_t sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz))
size_t __sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
return __fgetws_alias (__s, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz))
return __fgetws_chk_warn (__s, sz / sizeof (wchar_t), __n, __stream);
return __fgetws_chk (__s, sz / sizeof (wchar_t), __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
return __fgetws_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream);
return __fgetws_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
}
#ifdef __USE_GNU
@ -316,13 +316,13 @@ extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
__fortify_function __wur wchar_t *
fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
size_t sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz))
size_t __sz = __glibc_objsize (__s);
if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
return __fgetws_unlocked_alias (__s, __n, __stream);
if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz))
return __fgetws_unlocked_chk_warn (__s, sz / sizeof (wchar_t), __n,
if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
return __fgetws_unlocked_chk_warn (__s, __sz / sizeof (wchar_t), __n,
__stream);
return __fgetws_unlocked_chk (__s, sz / sizeof (wchar_t), __n, __stream);
return __fgetws_unlocked_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
}
#endif