[thirdparty/glibc.git] / posix / bits / unistd.h

/* Checking macros for unistd functions.
   Copyright (C) 2005-2021 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#ifndef _UNISTD_H
# error "Never include <bits/unistd.h> directly; use <unistd.h> instead."
#endif

extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
			   size_t __buflen)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf,
					  size_t __nbytes), read)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT (__read_chk_warn,
			   (int __fd, void *__buf, size_t __nbytes,
			    size_t __buflen), __read_chk)
     __wur __warnattr ("read called with bigger length than size of "
		       "the destination buffer");

__fortify_function __wur ssize_t
read (int __fd, void *__buf, size_t __nbytes)
{
  if (__glibc_objsize0 (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
	return __read_chk (__fd, __buf, __nbytes, __glibc_objsize0 (__buf));

      if (__nbytes > __glibc_objsize0 (__buf))
	return __read_chk_warn (__fd, __buf, __nbytes,
				__glibc_objsize0 (__buf));
    }
  return __read_alias (__fd, __buf, __nbytes);
}

#ifdef __USE_UNIX98
extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
			    __off_t __offset, size_t __bufsize)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
			      __off64_t __offset, size_t __bufsize)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT (__pread_alias,
			   (int __fd, void *__buf, size_t __nbytes,
			    __off_t __offset), pread)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT (__pread64_alias,
			   (int __fd, void *__buf, size_t __nbytes,
			    __off64_t __offset), pread64)
  __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT (__pread_chk_warn,
			   (int __fd, void *__buf, size_t __nbytes,
			    __off_t __offset, size_t __bufsize), __pread_chk)
     __wur __warnattr ("pread called with bigger length than size of "
		       "the destination buffer");
extern ssize_t __REDIRECT (__pread64_chk_warn,
			   (int __fd, void *__buf, size_t __nbytes,
			    __off64_t __offset, size_t __bufsize),
			    __pread64_chk)
     __wur __warnattr ("pread64 called with bigger length than size of "
		       "the destination buffer");

# ifndef __USE_FILE_OFFSET64
__fortify_function __wur ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
{
  if (__glibc_objsize0 (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
	return __pread_chk (__fd, __buf, __nbytes, __offset,
			    __glibc_objsize0 (__buf));

      if ( __nbytes > __glibc_objsize0 (__buf))
	return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
				 __glibc_objsize0 (__buf));
    }
  return __pread_alias (__fd, __buf, __nbytes, __offset);
}
# else
__fortify_function __wur ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__glibc_objsize0 (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
	return __pread64_chk (__fd, __buf, __nbytes, __offset,
			      __glibc_objsize0 (__buf));

      if ( __nbytes > __glibc_objsize0 (__buf))
	return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
				   __glibc_objsize0 (__buf));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}
# endif

# ifdef __USE_LARGEFILE64
__fortify_function __wur ssize_t
pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__glibc_objsize0 (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
	return __pread64_chk (__fd, __buf, __nbytes, __offset,
			      __glibc_objsize0 (__buf));

      if ( __nbytes > __glibc_objsize0 (__buf))
	return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
				   __glibc_objsize0 (__buf));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}
# endif
#endif

#if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K
extern ssize_t __readlink_chk (const char *__restrict __path,
			       char *__restrict __buf, size_t __len,
			       size_t __buflen)
     __THROW __nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT_NTH (__readlink_alias,
			       (const char *__restrict __path,
				char *__restrict __buf, size_t __len), readlink)
     __nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3));
extern ssize_t __REDIRECT_NTH (__readlink_chk_warn,
			       (const char *__restrict __path,
				char *__restrict __buf, size_t __len,
				size_t __buflen), __readlink_chk)
     __nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length "
					  "than size of destination buffer");

__fortify_function __nonnull ((1, 2)) __wur ssize_t
__NTH (readlink (const char *__restrict __path, char *__restrict __buf,
		 size_t __len))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
	return __readlink_chk (__path, __buf, __len, __glibc_objsize (__buf));

      if ( __len > __glibc_objsize (__buf))
	return __readlink_chk_warn (__path, __buf, __len,
				    __glibc_objsize (__buf));
    }
  return __readlink_alias (__path, __buf, __len);
}
#endif

#ifdef __USE_ATFILE
extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
				 char *__restrict __buf, size_t __len,
				 size_t __buflen)
     __THROW __nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4));
extern ssize_t __REDIRECT_NTH (__readlinkat_alias,
			       (int __fd, const char *__restrict __path,
				char *__restrict __buf, size_t __len),
			       readlinkat)
     __nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4));
extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn,
			       (int __fd, const char *__restrict __path,
				char *__restrict __buf, size_t __len,
				size_t __buflen), __readlinkat_chk)
     __nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger "
					  "length than size of destination "
					  "buffer");

__fortify_function __nonnull ((2, 3)) __wur ssize_t
__NTH (readlinkat (int __fd, const char *__restrict __path,
		   char *__restrict __buf, size_t __len))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
	return __readlinkat_chk (__fd, __path, __buf, __len,
				 __glibc_objsize (__buf));

      if (__len > __glibc_objsize (__buf))
	return __readlinkat_chk_warn (__fd, __path, __buf, __len,
				      __glibc_objsize (__buf));
    }
  return __readlinkat_alias (__fd, __path, __buf, __len);
}
#endif

extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
     __THROW __wur __attr_access ((__write_only__, 1, 2));
extern char *__REDIRECT_NTH (__getcwd_alias,
			     (char *__buf, size_t __size), getcwd)
  __wur __attr_access ((__write_only__, 1, 2));
extern char *__REDIRECT_NTH (__getcwd_chk_warn,
			     (char *__buf, size_t __size, size_t __buflen),
			     __getcwd_chk)
     __wur __warnattr ("getcwd caller with bigger length than size of "
		       "destination buffer");

__fortify_function __wur char *
__NTH (getcwd (char *__buf, size_t __size))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size))
	return __getcwd_chk (__buf, __size, __glibc_objsize (__buf));

      if (__size > __glibc_objsize (__buf))
	return __getcwd_chk_warn (__buf, __size, __glibc_objsize (__buf));
    }
  return __getcwd_alias (__buf, __size);
}

#if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
extern char *__getwd_chk (char *__buf, size_t buflen)
     __THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2));
extern char *__REDIRECT_NTH (__getwd_warn, (char *__buf), getwd)
     __nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd "
				       "doesn't specify buffer size");

__fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char *
__NTH (getwd (char *__buf))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    return __getwd_chk (__buf, __glibc_objsize (__buf));
  return __getwd_warn (__buf);
}
#endif

extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
			     size_t __buflen) __THROW
  __attr_access ((__write_only__, 2, 3));
extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf,
						size_t __len), confstr)
   __attr_access ((__write_only__, 2, 3));
extern size_t __REDIRECT_NTH (__confstr_chk_warn,
			      (int __name, char *__buf, size_t __len,
			       size_t __buflen), __confstr_chk)
     __warnattr ("confstr called with bigger length than size of destination "
		 "buffer");

__fortify_function size_t
__NTH (confstr (int __name, char *__buf, size_t __len))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
	return __confstr_chk (__name, __buf, __len, __glibc_objsize (__buf));

      if (__glibc_objsize (__buf) < __len)
	return __confstr_chk_warn (__name, __buf, __len,
				   __glibc_objsize (__buf));
    }
  return __confstr_alias (__name, __buf, __len);
}


extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
  __THROW __wur __attr_access ((__write_only__, 2, 1));
extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]),
			   getgroups) __wur __attr_access ((__write_only__, 2, 1));
extern int __REDIRECT_NTH (__getgroups_chk_warn,
			   (int __size, __gid_t __list[], size_t __listlen),
			   __getgroups_chk)
     __wur __warnattr ("getgroups called with bigger group count than what "
		       "can fit into destination buffer");

__fortify_function int
__NTH (getgroups (int __size, __gid_t __list[]))
{
  if (__glibc_objsize (__list) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size) || __size < 0)
	return __getgroups_chk (__size, __list, __glibc_objsize (__list));

      if (__size * sizeof (__gid_t) > __glibc_objsize (__list))
	return __getgroups_chk_warn (__size, __list, __glibc_objsize (__list));
    }
  return __getgroups_alias (__size, __list);
}


extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
			    size_t __nreal) __THROW __nonnull ((2))
   __attr_access ((__write_only__, 2, 3));
extern int __REDIRECT_NTH (__ttyname_r_alias, (int __fd, char *__buf,
					       size_t __buflen), ttyname_r)
     __nonnull ((2));
extern int __REDIRECT_NTH (__ttyname_r_chk_warn,
			   (int __fd, char *__buf, size_t __buflen,
			    size_t __nreal), __ttyname_r_chk)
     __nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than "
				 "size of destination buffer");

__fortify_function int
__NTH (ttyname_r (int __fd, char *__buf, size_t __buflen))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
	return __ttyname_r_chk (__fd, __buf, __buflen,
				__glibc_objsize (__buf));

      if (__buflen > __glibc_objsize (__buf))
	return __ttyname_r_chk_warn (__fd, __buf, __buflen,
				     __glibc_objsize (__buf));
    }
  return __ttyname_r_alias (__fd, __buf, __buflen);
}


#ifdef __USE_POSIX199506
extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
     __nonnull ((1)) __attr_access ((__write_only__, 1, 2));
extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen),
		       getlogin_r) __nonnull ((1));
extern int __REDIRECT (__getlogin_r_chk_warn,
		       (char *__buf, size_t __buflen, size_t __nreal),
		       __getlogin_r_chk)
     __nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than "
				 "size of destination buffer");

__fortify_function int
getlogin_r (char *__buf, size_t __buflen)
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
	return __getlogin_r_chk (__buf, __buflen, __glibc_objsize (__buf));

      if (__buflen > __glibc_objsize (__buf))
	return __getlogin_r_chk_warn (__buf, __buflen,
				      __glibc_objsize (__buf));
    }
  return __getlogin_r_alias (__buf, __buflen);
}
#endif


#if defined __USE_MISC || defined __USE_UNIX98
extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
     __THROW __nonnull ((1)) __attr_access ((__write_only__, 1, 2));
extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen),
			   gethostname)
  __nonnull ((1)) __attr_access ((__write_only__, 1, 2));
extern int __REDIRECT_NTH (__gethostname_chk_warn,
			   (char *__buf, size_t __buflen, size_t __nreal),
			   __gethostname_chk)
     __nonnull ((1)) __warnattr ("gethostname called with bigger buflen than "
				 "size of destination buffer");

__fortify_function int
__NTH (gethostname (char *__buf, size_t __buflen))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
	return __gethostname_chk (__buf, __buflen, __glibc_objsize (__buf));

      if (__buflen > __glibc_objsize (__buf))
	return __gethostname_chk_warn (__buf, __buflen,
				       __glibc_objsize (__buf));
    }
  return __gethostname_alias (__buf, __buflen);
}
#endif


#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_UNIX98)
extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
     __THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2));
extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf,
						   size_t __buflen),
			   getdomainname) __nonnull ((1))
  __wur __attr_access ((__write_only__, 1, 2));
extern int __REDIRECT_NTH (__getdomainname_chk_warn,
			   (char *__buf, size_t __buflen, size_t __nreal),
			   __getdomainname_chk)
     __nonnull ((1)) __wur __warnattr ("getdomainname called with bigger "
				       "buflen than size of destination "
				       "buffer");

__fortify_function int
__NTH (getdomainname (char *__buf, size_t __buflen))
{
  if (__glibc_objsize (__buf) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
	return __getdomainname_chk (__buf, __buflen, __glibc_objsize (__buf));

      if (__buflen > __glibc_objsize (__buf))
	return __getdomainname_chk_warn (__buf, __buflen,
					 __glibc_objsize (__buf));
    }
  return __getdomainname_alias (__buf, __buflen);
}
#endif
Commit	Line	Data
553cc5f9	1	/* Checking macros for unistd functions.
2b778ceb	2	Copyright (C) 2005-2021 Free Software Foundation, Inc.
553cc5f9 UD	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
59ba27a6	16	License along with the GNU C Library; if not, see
5a82c748	17	<https://www.gnu.org/licenses/>. */
553cc5f9 UD	18
	19	#ifndef _UNISTD_H
	20	# error "Never include <bits/unistd.h> directly; use <unistd.h> instead."
	21	#endif
	22
	23	extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
06febd8c MS	24	size_t __buflen)
06febd8c MS	25	__wur __attr_access ((__write_only__, 2, 3));
60bd9f7c	26	extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf,
06febd8c MS	27	size_t __nbytes), read)
06febd8c MS	28	__wur __attr_access ((__write_only__, 2, 3));
d6cd6bf4 UD	29	extern ssize_t __REDIRECT (__read_chk_warn,
	30	(int __fd, void *__buf, size_t __nbytes,
	31	size_t __buflen), __read_chk)
	32	__wur __warnattr ("read called with bigger length than size of "
	33	"the destination buffer");
60bd9f7c	34
5ac3ea17	35	__fortify_function __wur ssize_t
60bd9f7c UD	36	read (int __fd, void *__buf, size_t __nbytes)
60bd9f7c UD	37	{
f9de8bfe	38	if (__glibc_objsize0 (__buf) != (size_t) -1)
d6cd6bf4 UD	39	{
d6cd6bf4 UD	40	if (!__builtin_constant_p (__nbytes))
f9de8bfe	41	return __read_chk (__fd, __buf, __nbytes, __glibc_objsize0 (__buf));
d6cd6bf4	42
f9de8bfe SP	43	if (__nbytes > __glibc_objsize0 (__buf))
	44	return __read_chk_warn (__fd, __buf, __nbytes,
	45	__glibc_objsize0 (__buf));
d6cd6bf4	46	}
60bd9f7c UD	47	return __read_alias (__fd, __buf, __nbytes);
60bd9f7c UD	48	}
553cc5f9 UD	49
	50	#ifdef __USE_UNIX98
	51	extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
06febd8c MS	52	__off_t __offset, size_t __bufsize)
06febd8c MS	53	__wur __attr_access ((__write_only__, 2, 3));
553cc5f9	54	extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
06febd8c MS	55	__off64_t __offset, size_t __bufsize)
06febd8c MS	56	__wur __attr_access ((__write_only__, 2, 3));
60bd9f7c UD	57	extern ssize_t __REDIRECT (__pread_alias,
60bd9f7c UD	58	(int __fd, void *__buf, size_t __nbytes,
06febd8c MS	59	__off_t __offset), pread)
06febd8c MS	60	__wur __attr_access ((__write_only__, 2, 3));
60bd9f7c UD	61	extern ssize_t __REDIRECT (__pread64_alias,
60bd9f7c UD	62	(int __fd, void *__buf, size_t __nbytes,
06febd8c MS	63	__off64_t __offset), pread64)
06febd8c MS	64	__wur __attr_access ((__write_only__, 2, 3));
d6cd6bf4 UD	65	extern ssize_t __REDIRECT (__pread_chk_warn,
	66	(int __fd, void *__buf, size_t __nbytes,
	67	__off_t __offset, size_t __bufsize), __pread_chk)
	68	__wur __warnattr ("pread called with bigger length than size of "
	69	"the destination buffer");
	70	extern ssize_t __REDIRECT (__pread64_chk_warn,
	71	(int __fd, void *__buf, size_t __nbytes,
	72	__off64_t __offset, size_t __bufsize),
	73	__pread64_chk)
	74	__wur __warnattr ("pread64 called with bigger length than size of "
	75	"the destination buffer");
88764ae2	76
553cc5f9	77	# ifndef __USE_FILE_OFFSET64
5ac3ea17	78	__fortify_function __wur ssize_t
60bd9f7c UD	79	pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
60bd9f7c UD	80	{
f9de8bfe	81	if (__glibc_objsize0 (__buf) != (size_t) -1)
d6cd6bf4 UD	82	{
d6cd6bf4 UD	83	if (!__builtin_constant_p (__nbytes))
f9de8bfe SP	84	return __pread_chk (__fd, __buf, __nbytes, __offset,
f9de8bfe SP	85	__glibc_objsize0 (__buf));
d6cd6bf4	86
f9de8bfe	87	if ( __nbytes > __glibc_objsize0 (__buf))
d6cd6bf4	88	return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
f9de8bfe	89	__glibc_objsize0 (__buf));
d6cd6bf4	90	}
60bd9f7c UD	91	return __pread_alias (__fd, __buf, __nbytes, __offset);
60bd9f7c UD	92	}
553cc5f9	93	# else
5ac3ea17	94	__fortify_function __wur ssize_t
65fb0d21	95	pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
60bd9f7c	96	{
f9de8bfe	97	if (__glibc_objsize0 (__buf) != (size_t) -1)
d6cd6bf4 UD	98	{
d6cd6bf4 UD	99	if (!__builtin_constant_p (__nbytes))
f9de8bfe SP	100	return __pread64_chk (__fd, __buf, __nbytes, __offset,
f9de8bfe SP	101	__glibc_objsize0 (__buf));
d6cd6bf4	102
f9de8bfe	103	if ( __nbytes > __glibc_objsize0 (__buf))
d6cd6bf4	104	return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
f9de8bfe	105	__glibc_objsize0 (__buf));
d6cd6bf4 UD	106	}
d6cd6bf4 UD	107
60bd9f7c UD	108	return __pread64_alias (__fd, __buf, __nbytes, __offset);
60bd9f7c UD	109	}
553cc5f9 UD	110	# endif
	111
	112	# ifdef __USE_LARGEFILE64
5ac3ea17	113	__fortify_function __wur ssize_t
60bd9f7c UD	114	pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
60bd9f7c UD	115	{
f9de8bfe	116	if (__glibc_objsize0 (__buf) != (size_t) -1)
d6cd6bf4 UD	117	{
d6cd6bf4 UD	118	if (!__builtin_constant_p (__nbytes))
f9de8bfe SP	119	return __pread64_chk (__fd, __buf, __nbytes, __offset,
f9de8bfe SP	120	__glibc_objsize0 (__buf));
d6cd6bf4	121
f9de8bfe	122	if ( __nbytes > __glibc_objsize0 (__buf))
d6cd6bf4	123	return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
f9de8bfe	124	__glibc_objsize0 (__buf));
d6cd6bf4 UD	125	}
d6cd6bf4 UD	126
60bd9f7c UD	127	return __pread64_alias (__fd, __buf, __nbytes, __offset);
60bd9f7c UD	128	}
553cc5f9 UD	129	# endif
	130	#endif
	131
acd7f096	132	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_XOPEN2K
a784e502	133	extern ssize_t __readlink_chk (const char *__restrict __path,
6738b3c0 UD	134	char *__restrict __buf, size_t __len,
6738b3c0 UD	135	size_t __buflen)
06febd8c	136	__THROW __nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3));
6738b3c0	137	extern ssize_t __REDIRECT_NTH (__readlink_alias,
a784e502	138	(const char *__restrict __path,
6738b3c0	139	char *__restrict __buf, size_t __len), readlink)
06febd8c	140	__nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3));
d6cd6bf4	141	extern ssize_t __REDIRECT_NTH (__readlink_chk_warn,
a784e502	142	(const char *__restrict __path,
d6cd6bf4 UD	143	char *__restrict __buf, size_t __len,
	144	size_t __buflen), __readlink_chk)
	145	__nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length "
	146	"than size of destination buffer");
88764ae2	147
5ac3ea17	148	__fortify_function __nonnull ((1, 2)) __wur ssize_t
a784e502	149	__NTH (readlink (const char __restrict __path, char __restrict __buf,
60bd9f7c UD	150	size_t __len))
60bd9f7c UD	151	{
f9de8bfe	152	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	153	{
d6cd6bf4 UD	154	if (!__builtin_constant_p (__len))
f9de8bfe	155	return __readlink_chk (__path, __buf, __len, __glibc_objsize (__buf));
d6cd6bf4	156
f9de8bfe SP	157	if ( __len > __glibc_objsize (__buf))
	158	return __readlink_chk_warn (__path, __buf, __len,
	159	__glibc_objsize (__buf));
d6cd6bf4	160	}
60bd9f7c UD	161	return __readlink_alias (__path, __buf, __len);
60bd9f7c UD	162	}
553cc5f9 UD	163	#endif
553cc5f9 UD	164
a346370d	165	#ifdef __USE_ATFILE
a784e502	166	extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
a346370d UD	167	char *__restrict __buf, size_t __len,
a346370d UD	168	size_t __buflen)
06febd8c	169	__THROW __nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4));
a346370d	170	extern ssize_t __REDIRECT_NTH (__readlinkat_alias,
a784e502	171	(int __fd, const char *__restrict __path,
a346370d UD	172	char *__restrict __buf, size_t __len),
a346370d UD	173	readlinkat)
06febd8c	174	__nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4));
d6cd6bf4	175	extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn,
a784e502	176	(int __fd, const char *__restrict __path,
d6cd6bf4 UD	177	char *__restrict __buf, size_t __len,
	178	size_t __buflen), __readlinkat_chk)
	179	__nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger "
	180	"length than size of destination "
	181	"buffer");
a346370d	182
5ac3ea17	183	__fortify_function __nonnull ((2, 3)) __wur ssize_t
a784e502	184	__NTH (readlinkat (int __fd, const char *__restrict __path,
a346370d UD	185	char *__restrict __buf, size_t __len))
a346370d UD	186	{
f9de8bfe	187	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	188	{
d6cd6bf4 UD	189	if (!__builtin_constant_p (__len))
f9de8bfe SP	190	return __readlinkat_chk (__fd, __path, __buf, __len,
f9de8bfe SP	191	__glibc_objsize (__buf));
d6cd6bf4	192
f9de8bfe	193	if (__len > __glibc_objsize (__buf))
d6cd6bf4	194	return __readlinkat_chk_warn (__fd, __path, __buf, __len,
f9de8bfe	195	__glibc_objsize (__buf));
d6cd6bf4	196	}
a346370d UD	197	return __readlinkat_alias (__fd, __path, __buf, __len);
	198	}
	199	#endif
	200
553cc5f9	201	extern char __getcwd_chk (char __buf, size_t __size, size_t __buflen)
06febd8c	202	__THROW __wur __attr_access ((__write_only__, 1, 2));
60bd9f7c	203	extern char *__REDIRECT_NTH (__getcwd_alias,
06febd8c MS	204	(char *__buf, size_t __size), getcwd)
06febd8c MS	205	__wur __attr_access ((__write_only__, 1, 2));
d6cd6bf4 UD	206	extern char *__REDIRECT_NTH (__getcwd_chk_warn,
	207	(char *__buf, size_t __size, size_t __buflen),
	208	__getcwd_chk)
	209	__wur __warnattr ("getcwd caller with bigger length than size of "
	210	"destination buffer");
88764ae2	211
5ac3ea17	212	__fortify_function __wur char *
60bd9f7c UD	213	__NTH (getcwd (char *__buf, size_t __size))
60bd9f7c UD	214	{
f9de8bfe	215	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	216	{
d6cd6bf4 UD	217	if (!__builtin_constant_p (__size))
f9de8bfe	218	return __getcwd_chk (__buf, __size, __glibc_objsize (__buf));
d6cd6bf4	219
f9de8bfe SP	220	if (__size > __glibc_objsize (__buf))
f9de8bfe SP	221	return __getcwd_chk_warn (__buf, __size, __glibc_objsize (__buf));
d6cd6bf4	222	}
60bd9f7c UD	223	return __getcwd_alias (__buf, __size);
60bd9f7c UD	224	}
553cc5f9	225
498afc54	226	#if defined __USE_MISC \|\| defined __USE_XOPEN_EXTENDED
553cc5f9	227	extern char __getwd_chk (char __buf, size_t buflen)
06febd8c	228	__THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2));
d6cd6bf4 UD	229	extern char __REDIRECT_NTH (__getwd_warn, (char __buf), getwd)
	230	__nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd "
	231	"doesn't specify buffer size");
88764ae2	232
5ac3ea17	233	__fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char *
60bd9f7c UD	234	__NTH (getwd (char *__buf))
60bd9f7c UD	235	{
f9de8bfe SP	236	if (__glibc_objsize (__buf) != (size_t) -1)
f9de8bfe SP	237	return __getwd_chk (__buf, __glibc_objsize (__buf));
d6cd6bf4	238	return __getwd_warn (__buf);
60bd9f7c	239	}
553cc5f9	240	#endif
9f3731cf UD	241
9f3731cf UD	242	extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
06febd8c MS	243	size_t __buflen) __THROW
06febd8c MS	244	__attr_access ((__write_only__, 2, 3));
9f3731cf	245	extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf,
06febd8c MS	246	size_t __len), confstr)
06febd8c MS	247	__attr_access ((__write_only__, 2, 3));
d6cd6bf4 UD	248	extern size_t __REDIRECT_NTH (__confstr_chk_warn,
	249	(int __name, char *__buf, size_t __len,
	250	size_t __buflen), __confstr_chk)
	251	__warnattr ("confstr called with bigger length than size of destination "
	252	"buffer");
9f3731cf	253
5ac3ea17	254	__fortify_function size_t
dc4bb1c2	255	__NTH (confstr (int __name, char *__buf, size_t __len))
9f3731cf	256	{
f9de8bfe	257	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	258	{
d6cd6bf4 UD	259	if (!__builtin_constant_p (__len))
f9de8bfe	260	return __confstr_chk (__name, __buf, __len, __glibc_objsize (__buf));
d6cd6bf4	261
f9de8bfe SP	262	if (__glibc_objsize (__buf) < __len)
	263	return __confstr_chk_warn (__name, __buf, __len,
	264	__glibc_objsize (__buf));
d6cd6bf4	265	}
9f3731cf UD	266	return __confstr_alias (__name, __buf, __len);
	267	}
	268
	269
d6cd6bf4	270	extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
06febd8c	271	__THROW __wur __attr_access ((__write_only__, 2, 1));
9f3731cf	272	extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]),
06febd8c	273	getgroups) __wur __attr_access ((__write_only__, 2, 1));
d6cd6bf4 UD	274	extern int __REDIRECT_NTH (__getgroups_chk_warn,
	275	(int __size, __gid_t __list[], size_t __listlen),
	276	__getgroups_chk)
	277	__wur __warnattr ("getgroups called with bigger group count than what "
	278	"can fit into destination buffer");
9f3731cf	279
5ac3ea17	280	__fortify_function int
dc4bb1c2	281	__NTH (getgroups (int __size, __gid_t __list[]))
9f3731cf	282	{
f9de8bfe	283	if (__glibc_objsize (__list) != (size_t) -1)
d6cd6bf4	284	{
4bed549a	285	if (!__builtin_constant_p (__size) \|\| __size < 0)
f9de8bfe	286	return __getgroups_chk (__size, __list, __glibc_objsize (__list));
d6cd6bf4	287
f9de8bfe SP	288	if (__size * sizeof (__gid_t) > __glibc_objsize (__list))
f9de8bfe SP	289	return __getgroups_chk_warn (__size, __list, __glibc_objsize (__list));
d6cd6bf4	290	}
9f3731cf UD	291	return __getgroups_alias (__size, __list);
	292	}
	293
	294
	295	extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
06febd8c MS	296	size_t __nreal) __THROW __nonnull ((2))
06febd8c MS	297	__attr_access ((__write_only__, 2, 3));
9f3731cf UD	298	extern int __REDIRECT_NTH (__ttyname_r_alias, (int __fd, char *__buf,
	299	size_t __buflen), ttyname_r)
	300	__nonnull ((2));
d6cd6bf4 UD	301	extern int __REDIRECT_NTH (__ttyname_r_chk_warn,
	302	(int __fd, char *__buf, size_t __buflen,
	303	size_t __nreal), __ttyname_r_chk)
	304	__nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than "
	305	"size of destination buffer");
9f3731cf	306
5ac3ea17	307	__fortify_function int
dc4bb1c2	308	__NTH (ttyname_r (int __fd, char *__buf, size_t __buflen))
9f3731cf	309	{
f9de8bfe	310	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	311	{
d6cd6bf4 UD	312	if (!__builtin_constant_p (__buflen))
f9de8bfe SP	313	return __ttyname_r_chk (__fd, __buf, __buflen,
f9de8bfe SP	314	__glibc_objsize (__buf));
d6cd6bf4	315
f9de8bfe SP	316	if (__buflen > __glibc_objsize (__buf))
	317	return __ttyname_r_chk_warn (__fd, __buf, __buflen,
	318	__glibc_objsize (__buf));
d6cd6bf4	319	}
9f3731cf UD	320	return __ttyname_r_alias (__fd, __buf, __buflen);
	321	}
	322
	323
c0307377	324	#ifdef __USE_POSIX199506
9f3731cf	325	extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
06febd8c	326	__nonnull ((1)) __attr_access ((__write_only__, 1, 2));
9f3731cf UD	327	extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen),
9f3731cf UD	328	getlogin_r) __nonnull ((1));
d6cd6bf4 UD	329	extern int __REDIRECT (__getlogin_r_chk_warn,
	330	(char *__buf, size_t __buflen, size_t __nreal),
	331	__getlogin_r_chk)
	332	__nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than "
	333	"size of destination buffer");
9f3731cf	334
5ac3ea17	335	__fortify_function int
9f3731cf UD	336	getlogin_r (char *__buf, size_t __buflen)
9f3731cf UD	337	{
f9de8bfe	338	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	339	{
d6cd6bf4 UD	340	if (!__builtin_constant_p (__buflen))
f9de8bfe	341	return __getlogin_r_chk (__buf, __buflen, __glibc_objsize (__buf));
d6cd6bf4	342
f9de8bfe SP	343	if (__buflen > __glibc_objsize (__buf))
	344	return __getlogin_r_chk_warn (__buf, __buflen,
	345	__glibc_objsize (__buf));
d6cd6bf4	346	}
9f3731cf UD	347	return __getlogin_r_alias (__buf, __buflen);
	348	}
	349	#endif
	350
	351
498afc54	352	#if defined __USE_MISC \|\| defined __USE_UNIX98
9f3731cf	353	extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
06febd8c	354	__THROW __nonnull ((1)) __attr_access ((__write_only__, 1, 2));
9f3731cf	355	extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen),
06febd8c MS	356	gethostname)
06febd8c MS	357	__nonnull ((1)) __attr_access ((__write_only__, 1, 2));
d6cd6bf4 UD	358	extern int __REDIRECT_NTH (__gethostname_chk_warn,
	359	(char *__buf, size_t __buflen, size_t __nreal),
	360	__gethostname_chk)
	361	__nonnull ((1)) __warnattr ("gethostname called with bigger buflen than "
	362	"size of destination buffer");
9f3731cf	363
5ac3ea17	364	__fortify_function int
dc4bb1c2	365	__NTH (gethostname (char *__buf, size_t __buflen))
9f3731cf	366	{
f9de8bfe	367	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	368	{
d6cd6bf4 UD	369	if (!__builtin_constant_p (__buflen))
f9de8bfe	370	return __gethostname_chk (__buf, __buflen, __glibc_objsize (__buf));
d6cd6bf4	371
f9de8bfe SP	372	if (__buflen > __glibc_objsize (__buf))
	373	return __gethostname_chk_warn (__buf, __buflen,
	374	__glibc_objsize (__buf));
d6cd6bf4	375	}
9f3731cf UD	376	return __gethostname_alias (__buf, __buflen);
	377	}
	378	#endif
	379
	380
498afc54	381	#if defined __USE_MISC \|\| (defined __USE_XOPEN && !defined __USE_UNIX98)
9f3731cf	382	extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
06febd8c	383	__THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2));
9f3731cf UD	384	extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf,
9f3731cf UD	385	size_t __buflen),
06febd8c MS	386	getdomainname) __nonnull ((1))
06febd8c MS	387	__wur __attr_access ((__write_only__, 1, 2));
d6cd6bf4 UD	388	extern int __REDIRECT_NTH (__getdomainname_chk_warn,
	389	(char *__buf, size_t __buflen, size_t __nreal),
	390	__getdomainname_chk)
	391	__nonnull ((1)) __wur __warnattr ("getdomainname called with bigger "
	392	"buflen than size of destination "
	393	"buffer");
9f3731cf	394
5ac3ea17	395	__fortify_function int
dc4bb1c2	396	__NTH (getdomainname (char *__buf, size_t __buflen))
9f3731cf	397	{
f9de8bfe	398	if (__glibc_objsize (__buf) != (size_t) -1)
d6cd6bf4 UD	399	{
d6cd6bf4 UD	400	if (!__builtin_constant_p (__buflen))
f9de8bfe	401	return __getdomainname_chk (__buf, __buflen, __glibc_objsize (__buf));
d6cd6bf4	402
f9de8bfe SP	403	if (__buflen > __glibc_objsize (__buf))
	404	return __getdomainname_chk_warn (__buf, __buflen,
	405	__glibc_objsize (__buf));
d6cd6bf4	406	}
9f3731cf UD	407	return __getdomainname_alias (__buf, __buflen);
	408	}
	409	#endif