/* This software is Copyright 1996 by Craig Metz, All Rights Reserved. */
#define getservbyname_r __getservbyname_r
+#define gethostbyname_r __gethostbyname_r
+#define gethostbyname2_r __gethostbyname2_r
+#define gethostbyaddr_r __gethostbyaddr_r
#if 0
+#define uname __uname
#define stpcpy __stpcpy
/* strdupa is using these */
#define memcpy __memcpy
{ PF_UNSPEC, NULL }
};
-int
-getaddrinfo (const char *name, const char *service,
+int attribute_hidden
+__getaddrinfo (const char *name, const char *service,
const struct addrinfo *hints, struct addrinfo **pai)
{
int i = 0, j = 0, last_i = 0;
return last_i ? -(last_i & GAIH_EAI) : EAI_NONAME;
}
+strong_alias(__getaddrinfo,getaddrinfo)
void
freeaddrinfo (struct addrinfo *ai)
}
}
-void setprotoent(int f)
+void attribute_hidden __setprotoent(int f)
{
LOCK;
if (protof == NULL)
proto_stayopen |= f;
UNLOCK;
}
+strong_alias(__setprotoent,setprotoent)
-void endprotoent(void)
+void attribute_hidden __endprotoent(void)
{
LOCK;
if (protof) {
proto_stayopen = 0;
UNLOCK;
}
+strong_alias(__endprotoent,endprotoent)
-int getprotoent_r(struct protoent *result_buf,
+int attribute_hidden __getprotoent_r(struct protoent *result_buf,
char *buf, size_t buflen,
struct protoent **result)
{
UNLOCK;
return 0;
}
+strong_alias(__getprotoent_r,getprotoent_r)
struct protoent * getprotoent(void)
{
struct protoent *result;
__initbuf();
- getprotoent_r(&proto, static_aliases, SBUFSIZE, &result);
+ __getprotoent_r(&proto, static_aliases, SBUFSIZE, &result);
return result;
}
-int getprotobyname_r(const char *name,
+int attribute_hidden __getprotobyname_r(const char *name,
struct protoent *result_buf,
char *buf, size_t buflen,
struct protoent **result)
int ret;
LOCK;
- setprotoent(proto_stayopen);
- while (!(ret=getprotoent_r(result_buf, buf, buflen, result))) {
+ __setprotoent(proto_stayopen);
+ while (!(ret=__getprotoent_r(result_buf, buf, buflen, result))) {
if (__strcmp(result_buf->p_name, name) == 0)
break;
for (cp = result_buf->p_aliases; *cp != 0; cp++)
}
found:
if (!proto_stayopen)
- endprotoent();
+ __endprotoent();
UNLOCK;
return *result?0:ret;
}
+strong_alias(__getprotobyname_r,getprotobyname_r)
struct protoent * getprotobyname(const char *name)
struct protoent *result;
__initbuf();
- getprotobyname_r(name, &proto, static_aliases, SBUFSIZE, &result);
+ __getprotobyname_r(name, &proto, static_aliases, SBUFSIZE, &result);
return result;
}
-int getprotobynumber_r (int proto_num,
+int attribute_hidden __getprotobynumber_r (int proto_num,
struct protoent *result_buf,
char *buf, size_t buflen,
struct protoent **result)
int ret;
LOCK;
- setprotoent(proto_stayopen);
- while (!(ret=getprotoent_r(result_buf, buf, buflen, result)))
+ __setprotoent(proto_stayopen);
+ while (!(ret=__getprotoent_r(result_buf, buf, buflen, result)))
if (result_buf->p_proto == proto_num)
break;
if (!proto_stayopen)
- endprotoent();
+ __endprotoent();
UNLOCK;
return *result?0:ret;
}
+strong_alias(__getprotobynumber_r,getprotobynumber_r)
struct protoent * getprotobynumber(int proto_num)
{
struct protoent *result;
__initbuf();
- getprotobynumber_r(proto_num, &proto, static_aliases,
+ __getprotobynumber_r(proto_num, &proto, static_aliases,
SBUFSIZE, &result);
return result;
}
#define geteuid __geteuid
#define getuid __getuid
+#define gethostbyname __gethostbyname
+#define gethostname __gethostname
#define __FORCE_GLIBC
#include <features.h>
#define strstr __strstr
#define random __random
#define getservbyport __getservbyport
+#define getdomainname __getdomainname
+#define uname __uname
#define __FORCE_GLIBC
#include <features.h>
#include <sys/utsname.h>
#include <sys/un.h>
+extern int __gethostbyname_r (__const char *__restrict __name,
+ struct hostent *__restrict __result_buf,
+ char *__restrict __buf, size_t __buflen,
+ struct hostent **__restrict __result,
+ int *__restrict __h_errnop) attribute_hidden;
+
+extern struct hostent *__gethostbyaddr (__const void *__addr, __socklen_t __len,
+ int __type) attribute_hidden;
#define MAX_RECURSE 5
#define REPLY_TIMEOUT 10
#define MAX_RETRIES 3
#ifdef L_gethostbyname
-struct hostent *gethostbyname(const char *name)
+struct hostent attribute_hidden *__gethostbyname(const char *name)
{
static struct hostent h;
static char buf[sizeof(struct in_addr) +
sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
struct hostent *hp;
- gethostbyname_r(name, &h, buf, sizeof(buf), &hp, &h_errno);
+ __gethostbyname_r(name, &h, buf, sizeof(buf), &hp, &h_errno);
return hp;
}
+strong_alias(__gethostbyname,gethostbyname)
#endif
#ifdef L_gethostbyname2
+#ifndef __UCLIBC_HAS_IPV6__
+extern struct hostent *__gethostbyname (__const char *__name) attribute_hidden;
+#else
+extern int __gethostbyname2_r (__const char *__restrict __name, int __af,
+ struct hostent *__restrict __result_buf,
+ char *__restrict __buf, size_t __buflen,
+ struct hostent **__restrict __result,
+ int *__restrict __h_errnop) attribute_hidden;
+#endif
+
struct hostent *gethostbyname2(const char *name, int family)
{
#ifndef __UCLIBC_HAS_IPV6__
- return family == AF_INET ? gethostbyname(name) : (struct hostent*)0;
+ return family == AF_INET ? __gethostbyname(name) : (struct hostent*)0;
#else /* __UCLIBC_HAS_IPV6__ */
static struct hostent h;
static char buf[sizeof(struct in6_addr) +
sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
struct hostent *hp;
- gethostbyname2_r(name, family, &h, buf, sizeof(buf), &hp, &h_errno);
+ __gethostbyname2_r(name, family, &h, buf, sizeof(buf), &hp, &h_errno);
return hp;
#endif /* __UCLIBC_HAS_IPV6__ */
#endif
#ifdef L_gethostbyaddr
-struct hostent *gethostbyaddr (const void *addr, socklen_t len, int type)
+extern int __gethostbyaddr_r (__const void *__restrict __addr, __socklen_t __len,
+ int __type,
+ struct hostent *__restrict __result_buf,
+ char *__restrict __buf, size_t __buflen,
+ struct hostent **__restrict __result,
+ int *__restrict __h_errnop) attribute_hidden;
+
+struct hostent attribute_hidden *__gethostbyaddr (const void *addr, socklen_t len, int type)
{
static struct hostent h;
static char buf[
sizeof(char *)*(ALIAS_DIM) + 384/*namebuffer*/ + 32/* margin */];
struct hostent *hp;
- gethostbyaddr_r(addr, len, type, &h, buf, sizeof(buf), &hp, &h_errno);
+ __gethostbyaddr_r(addr, len, type, &h, buf, sizeof(buf), &hp, &h_errno);
return hp;
}
+strong_alias(__gethostbyaddr,gethostbyaddr)
#endif
# define min(x,y) (((x) > (y)) ? (y) : (x))
#endif /* min */
-int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
+int attribute_hidden __getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
socklen_t hostlen, char *serv, socklen_t servlen,
unsigned int flags)
{
if (!(flags & NI_NUMERICHOST)) {
#ifdef __UCLIBC_HAS_IPV6__
if (sa->sa_family == AF_INET6)
- h = gethostbyaddr ((const void *)
+ h = __gethostbyaddr ((const void *)
&(((const struct sockaddr_in6 *) sa)->sin6_addr),
sizeof(struct in6_addr), AF_INET6);
else
#endif /* __UCLIBC_HAS_IPV6__ */
- h = gethostbyaddr ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
+ h = __gethostbyaddr ((const void *) &(((const struct sockaddr_in *)sa)->sin_addr),
sizeof(struct in_addr), AF_INET);
if (h) {
errno = serrno;
return 0;
}
+strong_alias(__getnameinfo,getnameinfo)
#endif
#ifdef L_gethostbyname_r
-int gethostbyname_r(const char * name,
+int attribute_hidden __gethostbyname_r(const char * name,
struct hostent * result_buf,
char * buf, size_t buflen,
struct hostent ** result,
*h_errnop = NETDB_SUCCESS;
return NETDB_SUCCESS;
}
+strong_alias(__gethostbyname_r,gethostbyname_r)
#endif
#ifdef L_gethostbyname2_r
-int gethostbyname2_r(const char *name, int family,
+int attribute_hidden __gethostbyname2_r(const char *name, int family,
struct hostent * result_buf,
char * buf, size_t buflen,
struct hostent ** result,
int * h_errnop)
{
#ifndef __UCLIBC_HAS_IPV6__
- return family == (AF_INET)? gethostbyname_r(name, result_buf,
+ return family == (AF_INET)? __gethostbyname_r(name, result_buf,
buf, buflen, result, h_errnop) : HOST_NOT_FOUND;
#else /* __UCLIBC_HAS_IPV6__ */
struct in6_addr *in;
char ** __nameserverXX;
if (family == AF_INET)
- return gethostbyname_r(name, result_buf, buf, buflen, result, h_errnop);
+ return __gethostbyname_r(name, result_buf, buf, buflen, result, h_errnop);
if (family != AF_INET6)
return EINVAL;
return NETDB_SUCCESS;
#endif /* __UCLIBC_HAS_IPV6__ */
}
+strong_alias(__gethostbyname2_r,gethostbyname2_r)
#endif
#ifdef L_gethostbyaddr_r
-int gethostbyaddr_r (const void *addr, socklen_t len, int type,
+int attribute_hidden __gethostbyaddr_r (const void *addr, socklen_t len, int type,
struct hostent * result_buf,
char * buf, size_t buflen,
struct hostent ** result,
*h_errnop = NETDB_SUCCESS;
return NETDB_SUCCESS;
}
+strong_alias(__gethostbyaddr_r,gethostbyaddr_r)
#endif
#ifdef L_res_comp
#define sysconf __sysconf
#define getegid __getegid
#define geteuid __geteuid
+#define getgroups __getgroups
+#define gethostname __gethostname
#define xdrmem_create __xdrmem_create
#define xdr_authunix_parms __xdr_authunix_parms
#define xdr_opaque_auth __xdr_opaque_auth
#define clnttcp_create __clnttcp_create
#define clntudp_create __clntudp_create
#define clntunix_create __clntunix_create
+#define getprotobyname_r __getprotobyname_r
+#define gethostbyname_r __gethostbyname_r
#define __FORCE_GLIBC
#include <features.h>
#define xdr_replymsg __xdr_replymsg
#define xdr_opaque_auth __xdr_opaque_auth
#define svc_getreq __svc_getreq
+#define _seterr_reply __seterr_reply
#define __FORCE_GLIBC
#include <features.h>
*/
#define clntudp_create __clntudp_create
+#define gethostbyname_r __gethostbyname_r
#define __FORCE_GLIBC
#include <features.h>
#define xdr_opaque_auth __xdr_opaque_auth
#define xdrmem_create __xdrmem_create
#define pmap_getport __pmap_getport
+#define _seterr_reply __seterr_reply
#define __FORCE_GLIBC
#include <features.h>
#define xdr_callhdr __xdr_callhdr
#define xdr_replymsg __xdr_replymsg
#define xdr_opaque_auth __xdr_opaque_auth
-
#define pmap_getport __pmap_getport
+#define _seterr_reply __seterr_reply
#define __FORCE_GLIBC
#include <features.h>
#define xdrmem_create __xdrmem_create
#define getegid __getegid
#define geteuid __geteuid
+#define _seterr_reply __seterr_reply
#define __FORCE_GLIBC
#include <features.h>
*/
#define pmap_getport __pmap_getport
+#define gethostbyname_r __gethostbyname_r
#define __FORCE_GLIBC
#include <features.h>
#define sysconf __sysconf
#define getline __getline
#define geteuid __geteuid
+#define seteuid __seteuid
+#define getpwnam_r __getpwnam_r
+#define gethostbyname __gethostbyname
+#define gethostbyname_r __gethostbyname_r
#define __FORCE_GLIBC
#include <features.h>
* SUCH DAMAGE.
*/
+#define getnameinfo __getnameinfo
+#define getaddrinfo __getaddrinfo
+#define getsockname __getsockname
+
#define __FORCE_GLIBC
#include <features.h>
#include <sys/types.h>
/*
* given a reply message, fills in the error
*/
-void
-_seterr_reply (struct rpc_msg *msg,
+void attribute_hidden
+__seterr_reply (struct rpc_msg *msg,
struct rpc_err *error)
{
/* optimized for normal, SUCCESSful case */
break;
}
}
+strong_alias(__seterr_reply,_seterr_reply)
#define getuid __getuid
#define getegid __getegid
#define geteuid __geteuid
+#define gethostname __gethostname
#define __FORCE_GLIBC
#include <features.h>
#define xdr_callmsg __xdr_callmsg
#define xdr_replymsg __xdr_replymsg
#define xprt_register __xprt_register
+#define getsockname __getsockname
#define __FORCE_GLIBC
#define _GNU_SOURCE
#define xdrmem_create __xdrmem_create
#define xdr_callmsg __xdr_callmsg
#define xdr_replymsg __xdr_replymsg
+#define getsockname __getsockname
#define __FORCE_GLIBC
#define _GNU_SOURCE
#define xprt_register __xprt_register
#define getegid __getegid
#define geteuid __geteuid
+#define getsockname __getsockname
#define __FORCE_GLIBC
#include <features.h>
#ifdef L_getsockname
#ifdef __NR_getsockname
-_syscall3(int, getsockname, int, sockfd, struct sockaddr *, addr, socklen_t *,paddrlen);
+#define __NR___getsockname __NR_getsockname
+attribute_hidden _syscall3(int, __getsockname, int, sockfd, struct sockaddr *, addr, socklen_t *,paddrlen);
+strong_alias(__getsockname,getsockname)
#elif defined(__NR_socketcall)
-int getsockname(int sockfd, struct sockaddr *addr, socklen_t * paddrlen)
+int attribute_hidden __getsockname(int sockfd, struct sockaddr *addr, socklen_t * paddrlen)
{
unsigned long args[3];
args[2] = (unsigned long) paddrlen;
return __socketcall(SYS_GETSOCKNAME, args);
}
+strong_alias(__getsockname,getsockname)
#endif
#endif
#define tsearch __tsearch
#define tdestroy __tdestroy
#define fchdir __fchdir
+#define getcwd __getcwd
#define _GNU_SOURCE
#include <features.h>
#define UNLOCK __pthread_mutex_unlock(&mylock)
/* Reentrant version of getmntent. */
-struct mntent *getmntent_r (FILE *filep,
+struct mntent attribute_hidden *__getmntent_r (FILE *filep,
struct mntent *mnt, char *buff, int bufsize)
{
char *cp, *ptrptr;
return mnt;
}
+strong_alias(__getmntent_r,getmntent_r)
struct mntent *getmntent(FILE * filep)
{
abort();
}
- tmp = getmntent_r(filep, &mnt, buff, BUFSIZ);
+ tmp = __getmntent_r(filep, &mnt, buff, BUFSIZ);
UNLOCK;
return(tmp);
}
return strstr(mnt->mnt_opts, opt);
}
-FILE *setmntent(const char *name, const char *mode)
+FILE attribute_hidden *__setmntent(const char *name, const char *mode)
{
return fopen(name, mode);
}
+strong_alias(__setmntent,setmntent)
-int endmntent(FILE * filep)
+int attribute_hidden __endmntent(FILE * filep)
{
if (filep != NULL)
fclose(filep);
return 1;
}
+strong_alias(__endmntent,endmntent)
#ifdef __UCLIBC_HAS_WCHAR__
#define RE_ENABLE_I18N
#define wcscoll __wcscoll
+#define wcrtomb __wcrtomb
#define mbrtowc __mbrtowc
#define iswctype __iswctype
#define iswlower __iswlower
/* for some reason this does not work */
#define memcpy __memcpy
#define mbrtowc __mbrtowc
+#define wcrtomb __wcrtomb
#define wcscoll __wcscoll
#define iswctype __iswctype
#define iswalnum __iswalnum
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+extern FILE *__setmntent (__const char *__file, __const char *__mode) __THROW attribute_hidden;
+extern struct mntent *__getmntent_r (FILE *__restrict __stream,
+ struct mntent *__restrict __result,
+ char *__restrict __buffer,
+ int __bufsize) __THROW attribute_hidden;
+extern int __endmntent (FILE *__stream) __THROW attribute_hidden;
+
/* Now fill in the fields we have information for. */
buf->f_bsize = fsbuf.f_bsize;
/* Linux does not support f_frsize, so set it to the full block size. */
struct mntent mntbuf;
FILE *mtab;
- mtab = setmntent ("/proc/mounts", "r");
+ mtab = __setmntent ("/proc/mounts", "r");
if (mtab == NULL)
- mtab = setmntent (_PATH_MOUNTED, "r");
+ mtab = __setmntent (_PATH_MOUNTED, "r");
if (mtab != NULL)
{
char tmpbuf[1024];
- while (getmntent_r (mtab, &mntbuf, tmpbuf, sizeof (tmpbuf)))
+ while (__getmntent_r (mtab, &mntbuf, tmpbuf, sizeof (tmpbuf)))
{
struct stat fsst;
}
/* Close the file. */
- endmntent (mtab);
+ __endmntent (mtab);
}
__set_errno (save_errno);
#include <locale.h>
#include <bits/uClibc_uintmaxtostr.h>
+extern void __tzset (void) __THROW attribute_hidden;
+
#ifdef __UCLIBC_HAS_XLOCALE__
#include <xlocale.h>
extern int __strncasecmp_l (__const char *__s1, __const char *__s2,
{
TZLOCK;
- tzset();
+ __tzset();
__time_localtime_tzi(timer, result, _time_tzinfo);
unsigned char mod;
unsigned char code;
- tzset(); /* We'll, let's get this out of the way. */
+ __tzset(); /* We'll, let's get this out of the way. */
lvl = 0;
p = format;
#endif /* __UCLIBC_HAS_TZ_FILE__ */
-void tzset(void)
+void attribute_hidden __tzset(void)
{
register const char *e;
register char *s;
#endif
TZUNLOCK;
}
-
+strong_alias(__tzset,tzset)
#endif
/**********************************************************************/
/* #ifdef L_utime */
TZLOCK;
- tzset();
+ __tzset();
t = _time_mktime_tzi(timeptr, store_on_success, _time_tzinfo);
static const char default_file_name[] = _PATH_UTMP;
static const char *static_ut_name = (const char *) default_file_name;
-
-
-static struct utmp *__getutent(int utmp_fd)
-
-{
- if (utmp_fd == -1) {
- setutent();
- }
- if (utmp_fd == -1) {
- return NULL;
- }
-
- LOCK;
- if (__read(utmp_fd, (char *) &static_utmp, sizeof(struct utmp)) != sizeof(struct utmp))
- {
- return NULL;
- }
-
- UNLOCK;
- return &static_utmp;
-}
-
-void setutent(void)
+void attribute_hidden __setutent(void)
{
int ret;
UNLOCK;
return;
}
+strong_alias(__setutent,setutent)
+
+static struct utmp *__getutent(int utmp_fd)
+{
+ if (utmp_fd == -1) {
+ __setutent();
+ }
+ if (utmp_fd == -1) {
+ return NULL;
+ }
+
+ LOCK;
+ if (__read(utmp_fd, (char *) &static_utmp, sizeof(struct utmp)) != sizeof(struct utmp))
+ {
+ return NULL;
+ }
+
+ UNLOCK;
+ return &static_utmp;
+}
void endutent(void)
{
return NULL;
}
-extern struct utmp *__getutid (__const struct utmp *__id) attribute_hidden;
-
struct utmp *pututline (const struct utmp *utmp_entry)
{
LOCK;
UNLOCK;
return 0;
}
-
#define wcslen __wcslen
#define wcsrtombs __wcsrtombs
#define mbrtowc __mbrtowc
+#define wcrtomb __wcrtomb
#define _GNU_SOURCE
#include <stdio.h>
#define waitpid __waitpid
#define kill __kill
#define getuid __getuid
+#define getpwnam_r __getpwnam_r
+#define getpwuid_r __getpwuid_r
#define execve __execve
#define dup2 __dup2
*
*/
+#define setgroups __setgroups
+
#define _GNU_SOURCE
#include <features.h>
#include <stdio.h>
#include <pthread.h>
#endif
+extern int __getspnam_r (__const char *__name, struct spwd *__result_buf,
+ char *__buffer, size_t __buflen,
+ struct spwd **__result) attribute_hidden;
+
+extern int __getpwuid_r (__uid_t __uid,
+ struct passwd *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct passwd **__restrict __result) attribute_hidden;
+
/**********************************************************************/
/* Sizes for staticly allocated buffers. */
/**********************************************************************/
#ifdef L_fgetpwent_r
-int fgetpwent_r(FILE *__restrict stream, struct passwd *__restrict resultbuf,
+int attribute_hidden __fgetpwent_r(FILE *__restrict stream, struct passwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct passwd **__restrict result)
{
return rv;
}
+strong_alias(__fgetpwent_r,fgetpwent_r)
#endif
/**********************************************************************/
#ifdef L_fgetgrent_r
-int fgetgrent_r(FILE *__restrict stream, struct group *__restrict resultbuf,
+int attribute_hidden __fgetgrent_r(FILE *__restrict stream, struct group *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct group **__restrict result)
{
return rv;
}
+strong_alias(__fgetgrent_r,fgetgrent_r)
#endif
/**********************************************************************/
#ifdef L_fgetspent_r
-int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
+int attribute_hidden __fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct spwd **__restrict result)
{
return rv;
}
+strong_alias(__fgetspent_r,fgetspent_r)
#endif
/**********************************************************************/
/**********************************************************************/
#ifdef L_fgetpwent
+extern int __fgetpwent_r (FILE *__restrict __stream,
+ struct passwd *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct passwd **__restrict __result) attribute_hidden;
+
struct passwd *fgetpwent(FILE *stream)
{
static char buffer[PWD_BUFFER_SIZE];
static struct passwd resultbuf;
struct passwd *result;
- fgetpwent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
+ __fgetpwent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
/**********************************************************************/
#ifdef L_fgetgrent
+extern int __fgetgrent_r (FILE *__restrict __stream,
+ struct group *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct group **__restrict __result) attribute_hidden;
+
struct group *fgetgrent(FILE *stream)
{
static char buffer[GRP_BUFFER_SIZE];
static struct group resultbuf;
struct group *result;
- fgetgrent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
+ __fgetgrent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
/**********************************************************************/
#ifdef L_fgetspent
+extern int __fgetspent_r (FILE *__stream, struct spwd *__result_buf,
+ char *__buffer, size_t __buflen,
+ struct spwd **__result) attribute_hidden;
+
struct spwd *fgetspent(FILE *stream)
{
static char buffer[PWD_BUFFER_SIZE];
static struct spwd resultbuf;
struct spwd *result;
- fgetspent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
+ __fgetspent_r(stream, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
/**********************************************************************/
#ifdef L_sgetspent_r
-int sgetspent_r(const char *string, struct spwd *result_buf,
+int attribute_hidden __sgetspent_r(const char *string, struct spwd *result_buf,
char *buffer, size_t buflen, struct spwd **result)
{
int rv = ERANGE;
DONE:
return rv;
}
+strong_alias(__sgetspent_r,sgetspent_r)
#endif
/**********************************************************************/
#endif
#ifdef L_getpwnam_r
-#define GETXXKEY_R_FUNC getpwnam_r
+#define GETXXKEY_R_FUNC_HIDDEN __getpwnam_r
+#define GETXXKEY_R_FUNC getpwnam_r
#define GETXXKEY_R_PARSER __parsepwent
-#define GETXXKEY_R_ENTTYPE struct passwd
+#define GETXXKEY_R_ENTTYPE struct passwd
#define GETXXKEY_R_TEST(ENT) (!__strcmp((ENT)->pw_name, key))
#define DO_GETXXKEY_R_KEYTYPE const char *__restrict
#define DO_GETXXKEY_R_PATHNAME _PATH_PASSWD
#endif
#ifdef L_getgrnam_r
-#define GETXXKEY_R_FUNC getgrnam_r
+#define GETXXKEY_R_FUNC_HIDDEN __getgrnam_r
+#define GETXXKEY_R_FUNC getgrnam_r
#define GETXXKEY_R_PARSER __parsegrent
-#define GETXXKEY_R_ENTTYPE struct group
+#define GETXXKEY_R_ENTTYPE struct group
#define GETXXKEY_R_TEST(ENT) (!__strcmp((ENT)->gr_name, key))
#define DO_GETXXKEY_R_KEYTYPE const char *__restrict
#define DO_GETXXKEY_R_PATHNAME _PATH_GROUP
#endif
#ifdef L_getspnam_r
-#define GETXXKEY_R_FUNC getspnam_r
+#define GETXXKEY_R_FUNC_HIDDEN __getspnam_r
+#define GETXXKEY_R_FUNC getspnam_r
#define GETXXKEY_R_PARSER __parsespent
-#define GETXXKEY_R_ENTTYPE struct spwd
+#define GETXXKEY_R_ENTTYPE struct spwd
#define GETXXKEY_R_TEST(ENT) (!__strcmp((ENT)->sp_namp, key))
#define DO_GETXXKEY_R_KEYTYPE const char *__restrict
#define DO_GETXXKEY_R_PATHNAME _PATH_SHADOW
#endif
#ifdef L_getpwuid_r
-#define GETXXKEY_R_FUNC getpwuid_r
+#define GETXXKEY_R_FUNC_HIDDEN __getpwuid_r
+#define GETXXKEY_R_FUNC getpwuid_r
#define GETXXKEY_R_PARSER __parsepwent
-#define GETXXKEY_R_ENTTYPE struct passwd
+#define GETXXKEY_R_ENTTYPE struct passwd
#define GETXXKEY_R_TEST(ENT) ((ENT)->pw_uid == key)
#define DO_GETXXKEY_R_KEYTYPE uid_t
#define DO_GETXXKEY_R_PATHNAME _PATH_PASSWD
#endif
#ifdef L_getgrgid_r
-#define GETXXKEY_R_FUNC getgrgid_r
+#define GETXXKEY_R_FUNC_HIDDEN __getgrgid_r
+#define GETXXKEY_R_FUNC getgrgid_r
#define GETXXKEY_R_PARSER __parsegrent
-#define GETXXKEY_R_ENTTYPE struct group
+#define GETXXKEY_R_ENTTYPE struct group
#define GETXXKEY_R_TEST(ENT) ((ENT)->gr_gid == key)
#define DO_GETXXKEY_R_KEYTYPE gid_t
#define DO_GETXXKEY_R_PATHNAME _PATH_GROUP
static struct passwd resultbuf;
struct passwd *result;
- getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result);
+ __getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
/**********************************************************************/
#ifdef L_getgrgid
+extern int __getgrgid_r (__gid_t __gid, struct group *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct group **__restrict __result) attribute_hidden;
+
struct group *getgrgid(gid_t gid)
{
static char buffer[GRP_BUFFER_SIZE];
static struct group resultbuf;
struct group *result;
- getgrgid_r(gid, &resultbuf, buffer, sizeof(buffer), &result);
+ __getgrgid_r(gid, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
char pwd_buff[PWD_BUFFER_SIZE];
*result = NULL;
- if (!(rv = getpwuid_r(uid, &password, pwd_buff, sizeof(pwd_buff), &pp))) {
- rv = getspnam_r(password.pw_name, resultbuf, buffer, buflen, result);
+ if (!(rv = __getpwuid_r(uid, &password, pwd_buff, sizeof(pwd_buff), &pp))) {
+ rv = __getspnam_r(password.pw_name, resultbuf, buffer, buflen, result);
}
return rv;
/**********************************************************************/
#ifdef L_getpwnam
+extern int __getpwnam_r (__const char *__restrict __name,
+ struct passwd *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct passwd **__restrict __result) attribute_hidden;
+
struct passwd *getpwnam(const char *name)
{
static char buffer[PWD_BUFFER_SIZE];
static struct passwd resultbuf;
struct passwd *result;
- getpwnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
+ __getpwnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
/**********************************************************************/
#ifdef L_getgrnam
+extern int __getgrnam_r (__const char *__restrict __name,
+ struct group *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct group **__restrict __result) attribute_hidden;
+
struct group *getgrnam(const char *name)
{
static char buffer[GRP_BUFFER_SIZE];
static struct group resultbuf;
struct group *result;
- getgrnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
+ __getgrnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
static struct spwd resultbuf;
struct spwd *result;
- getspnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
+ __getspnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
return result;
}
if (!buf) {
__set_errno(EINVAL);
- } else if (!getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result)) {
+ } else if (!__getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result)) {
if (sprintf(buf, "%s:%s:%lu:%lu:%s:%s:%s\n",
resultbuf.pw_name, resultbuf.pw_passwd,
(unsigned long)(resultbuf.pw_uid),
}
-int getpwent_r(struct passwd *__restrict resultbuf,
+int attribute_hidden __getpwent_r(struct passwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct passwd **__restrict result)
{
return rv;
}
+strong_alias(__getpwent_r,getpwent_r)
#endif
/**********************************************************************/
UNLOCK;
}
-int getgrent_r(struct group *__restrict resultbuf,
+int attribute_hidden __getgrent_r(struct group *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct group **__restrict result)
{
return rv;
}
+strong_alias(__getgrent_r,getgrent_r)
#endif
/**********************************************************************/
UNLOCK;
}
-int getspent_r(struct spwd *resultbuf, char *buffer,
+int attribute_hidden __getspent_r(struct spwd *resultbuf, char *buffer,
size_t buflen, struct spwd **result)
{
int rv;
return rv;
}
+strong_alias(__getspent_r,getspent_r)
#endif
/**********************************************************************/
#ifdef L_getpwent
+
+extern int __getpwent_r (struct passwd *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct passwd **__restrict __result) attribute_hidden;
struct passwd *getpwent(void)
{
static struct passwd pwd;
struct passwd *result;
- getpwent_r(&pwd, line_buff, sizeof(line_buff), &result);
+ __getpwent_r(&pwd, line_buff, sizeof(line_buff), &result);
return result;
}
/**********************************************************************/
#ifdef L_getgrent
+extern int __getgrent_r (struct group *__restrict __resultbuf,
+ char *__restrict __buffer, size_t __buflen,
+ struct group **__restrict __result) attribute_hidden;
+
struct group *getgrent(void)
{
static char line_buff[GRP_BUFFER_SIZE];
static struct group gr;
struct group *result;
- getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
+ __getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
return result;
}
/**********************************************************************/
#ifdef L_getspent
+extern int __getspent_r (struct spwd *__result_buf, char *__buffer,
+ size_t __buflen, struct spwd **__result) attribute_hidden;
+
struct spwd *getspent(void)
{
static char line_buff[PWD_BUFFER_SIZE];
static struct spwd spwd;
struct spwd *result;
- getspent_r(&spwd, line_buff, sizeof(line_buff), &result);
+ __getspent_r(&spwd, line_buff, sizeof(line_buff), &result);
return result;
}
/**********************************************************************/
#ifdef L_sgetspent
+extern int __sgetspent_r (__const char *__string, struct spwd *__result_buf,
+ char *__buffer, size_t __buflen,
+ struct spwd **__result) attribute_hidden;
+
struct spwd *sgetspent(const char *string)
{
static char line_buff[PWD_BUFFER_SIZE];
static struct spwd spwd;
struct spwd *result;
- sgetspent_r(string, &spwd, line_buff, sizeof(line_buff), &result);
+ __sgetspent_r(string, &spwd, line_buff, sizeof(line_buff), &result);
return result;
}
/**********************************************************************/
#ifdef GETXXKEY_R_FUNC
-int GETXXKEY_R_FUNC(DO_GETXXKEY_R_KEYTYPE key,
+int attribute_hidden GETXXKEY_R_FUNC_HIDDEN(DO_GETXXKEY_R_KEYTYPE key,
GETXXKEY_R_ENTTYPE *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
GETXXKEY_R_ENTTYPE **__restrict result)
return rv;
}
+strong_alias(GETXXKEY_R_FUNC_HIDDEN,GETXXKEY_R_FUNC)
#endif
/**********************************************************************/
+#undef GETXXKEY_R_FUNC_HIDDEN
#undef GETXXKEY_R_FUNC
#undef GETXXKEY_R_PARSER
#undef GETXXKEY_R_ENTTYPE
#define mbsrtowcs __mbsrtowcs
#define mbrtowc __mbrtowc
#define ungetc __ungetc
+#define ungetwc __ungetwc
#define iswspace __iswspace
+#define wcrtomb __wcrtomb
#define _ISOC99_SOURCE /* for LLONG_MAX primarily... */
#define _GNU_SOURCE
* as reset stream->__ungot_width[1] for use by _stdio_adjpos().
*/
-wint_t ungetwc(wint_t c, register FILE *stream)
+wint_t attribute_hidden __ungetwc(wint_t c, register FILE *stream)
{
__STDIO_AUTO_THREADLOCK_VAR;
return c;
}
+strong_alias(__ungetwc,ungetwc)
#define wcsrtombs __wcsrtombs
#define mbsrtowcs __mbsrtowcs
#define btowc __btowc
+#define wcrtomb __wcrtomb
#define _ISOC99_SOURCE /* for ULLONG primarily... */
#define _GNU_SOURCE
/* Store at most BUFLEN characters of the pathname of the slave pseudo
terminal associated with the master FD is open on in BUF.
Return 0 on success, otherwise an error number. */
-int ptsname_r (int fd, char *buf, size_t buflen)
+int attribute_hidden __ptsname_r (int fd, char *buf, size_t buflen)
{
int save_errno = errno;
#if !defined __UNIX98PTY_ONLY__
errno = save_errno;
return 0;
}
+strong_alias(__ptsname_r,ptsname_r)
/* Return the pathname of the pseudo terminal slave assoicated with
the master FD is open on, or NULL on errors.
{
static char buffer[sizeof (_PATH_DEVPTS) + 20];
- return ptsname_r (fd, buffer, sizeof (buffer)) != 0 ? NULL : buffer;
+ return __ptsname_r (fd, buffer, sizeof (buffer)) != 0 ? NULL : buffer;
}
*/
#define readlink __readlink
+#define getcwd __getcwd
#ifdef HAVE_CONFIG_H
#include <config.h>
#define mbrlen __mbrlen
#define iswspace __iswspace
#define iswspace_l __iswspace_l
+#define wcrtomb __wcrtomb
#define _ISOC99_SOURCE /* for ULLONG primarily... */
#define _GNU_SOURCE
#define vfork fork
#endif
-extern int ptsname_r (int fd, char *buf, size_t buflen);
+extern int __ptsname_r (int fd, char *buf, size_t buflen) attribute_hidden;
/* Return the result of ptsname_r in the buffer pointed to by PTS,
which should be of length BUF_LEN. If it is too long to fit in
if (buf_len)
{
- rv = ptsname_r (fd, buf, buf_len);
+ rv = __ptsname_r (fd, buf, buf_len);
if (rv != 0 || memchr (buf, '\0', buf_len))
/* We either got an error, or we succeeded and the
#endif
-char *getcwd(char *buf, size_t size)
+char attribute_hidden *__getcwd(char *buf, size_t size)
{
int ret;
char *path;
free (path);
return NULL;
}
-
+strong_alias(__getcwd,getcwd)
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#define getcwd __getcwd
+
#include <features.h>
#include <unistd.h>
#include <sys/stat.h>
+#define uname __uname
+
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/utsname.h>
-int
-getdomainname(char *name, size_t len)
+int attribute_hidden
+__getdomainname(char *name, size_t len)
{
struct utsname uts;
__strcpy(name, uts.domainname);
return 0;
}
+strong_alias(__getdomainname,getdomainname)
static inline _syscall2(int, __syscall_getgroups,
int, size, __kernel_gid_t *, list);
-int getgroups(int n, gid_t * groups)
+int attribute_hidden __getgroups(int n, gid_t * groups)
{
if (unlikely(n < 0)) {
__set_errno(EINVAL);
return ngids;
}
}
+strong_alias(__getgroups,getgroups)
+#define uname __uname
+
#include <string.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <errno.h>
-int
-gethostname(char *name, size_t len)
+int attribute_hidden
+__gethostname(char *name, size_t len)
{
struct utsname uts;
__strcpy(name, uts.nodename);
return 0;
}
+strong_alias(__gethostname,gethostname)
/* The return value of __syscall_getpriority is biased by this value
* to avoid returning negative values. */
#define PZERO 20
-int getpriority(enum __priority_which which, id_t who)
+int attribute_hidden __getpriority(enum __priority_which which, id_t who)
{
int res;
res = PZERO - res;
return res;
}
+strong_alias(__getpriority,getpriority)
#define __NR___syscall_getsid __NR_getsid
static inline _syscall1(__kernel_pid_t, __syscall_getsid, __kernel_pid_t, pid);
-pid_t getsid(pid_t pid)
+pid_t attribute_hidden __getsid(pid_t pid)
{
return (__syscall_getsid(pid));
}
+strong_alias(__getsid,getsid)
* GNU Library General Public License (LGPL) version 2 or later.
*/
+#define getpriority __getpriority
+#define setpriority __setpriority
+
#include "syscalls.h"
#include <unistd.h>
#include <sys/resource.h>
+#define setresgid __setresgid
+#define setregid __setregid
+
#define _GNU_SOURCE
#include <unistd.h>
#include <stdio.h>
+#define setresuid __setresuid
+#define setreuid __setreuid
+
#define _GNU_SOURCE
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/syscall.h>
-int seteuid(uid_t uid)
+int attribute_hidden __seteuid(uid_t uid)
{
int result;
return result;
}
+strong_alias(__seteuid,seteuid)
static inline _syscall2(int, __syscall_setgroups,
size_t, size, const __kernel_gid_t *, list);
-int setgroups(size_t n, const gid_t * groups)
+int attribute_hidden __setgroups(size_t n, const gid_t * groups)
{
if (n > (size_t) sysconf(_SC_NGROUPS_MAX)) {
__set_errno(EINVAL);
return (__syscall_setgroups(n, kernel_groups));
}
}
+strong_alias(__setgroups,setgroups)
static inline _syscall2(int, __syscall_setpgid,
__kernel_pid_t, pid, __kernel_pid_t, pgid);
-int setpgid(pid_t pid, pid_t pgid)
+int attribute_hidden __setpgid(pid_t pid, pid_t pgid)
{
return (__syscall_setpgid(pid, pgid));
}
+strong_alias(__setpgid,setpgid)
+#define setpgid __setpgid
+
#include <syscall.h>
#include <unistd.h>
#include "syscalls.h"
#include <sys/resource.h>
-_syscall3(int, setpriority, __priority_which_t, which, id_t, who, int, prio);
+#define __NR___setpriority __NR_setpriority
+attribute_hidden _syscall3(int, __setpriority, __priority_which_t, which, id_t, who, int, prio);
+strong_alias(__setpriority,setpriority)
static inline _syscall2(int, __syscall_setregid,
__kernel_gid_t, rgid, __kernel_gid_t, egid);
-int setregid(gid_t rgid, gid_t egid)
+int attribute_hidden __setregid(gid_t rgid, gid_t egid)
{
if (((rgid + 1) > (gid_t) ((__kernel_gid_t) - 1U))
|| ((egid + 1) > (gid_t) ((__kernel_gid_t) - 1U))) {
}
return (__syscall_setregid(rgid, egid));
}
+strong_alias(__setregid,setregid)
static inline _syscall3(int, __syscall_setresgid,
__kernel_gid_t, rgid, __kernel_gid_t, egid, __kernel_gid_t, sgid);
-int setresgid(gid_t rgid, gid_t egid, gid_t sgid)
+int attribute_hidden __setresgid(gid_t rgid, gid_t egid, gid_t sgid)
{
if (((rgid + 1) > (gid_t) ((__kernel_gid_t) - 1U))
|| ((egid + 1) > (gid_t) ((__kernel_gid_t) - 1U))
}
return (__syscall_setresgid(rgid, egid, sgid));
}
+strong_alias(__setresgid,setresgid)
#endif
static inline _syscall3(int, __syscall_setresuid,
__kernel_uid_t, rgid, __kernel_uid_t, egid, __kernel_uid_t, sgid);
-int setresuid(uid_t ruid, uid_t euid, uid_t suid)
+int attribute_hidden __setresuid(uid_t ruid, uid_t euid, uid_t suid)
{
if (((ruid + 1) > (uid_t) ((__kernel_uid_t) - 1U))
|| ((euid + 1) > (uid_t) ((__kernel_uid_t) - 1U))
}
return (__syscall_setresuid(ruid, euid, suid));
}
+strong_alias(__setresuid,setresuid)
#endif
static inline _syscall2(int, __syscall_setreuid,
__kernel_uid_t, ruid, __kernel_uid_t, euid);
-int setreuid(uid_t ruid, uid_t euid)
+int attribute_hidden __setreuid(uid_t ruid, uid_t euid)
{
if (((ruid + 1) > (uid_t) ((__kernel_uid_t) - 1U))
|| ((euid + 1) > (uid_t) ((__kernel_uid_t) - 1U))) {
}
return (__syscall_setreuid(ruid, euid));
}
+strong_alias(__setreuid,setreuid)
#include "syscalls.h"
#include <unistd.h>
-_syscall0(pid_t, setsid);
+#define __NR___setsid __NR_setsid
+attribute_hidden _syscall0(pid_t, __setsid);
+strong_alias(__setsid,setsid)
#include "syscalls.h"
#include <sys/utsname.h>
-_syscall1(int, uname, struct utsname *, buf);
+#define __NR___uname __NR_uname
+attribute_hidden _syscall1(int, __uname, struct utsname *, buf);
+strong_alias(__uname,uname)
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#define tcsetattr __tcsetattr
+#define tcgetattr __tcgetattr
+
#include <stdarg.h>
#include <termios.h>
#include <unistd.h>
#include "kernel_termios.h"
/* Put the state of FD into *TERMIOS_P. */
-int tcgetattr (int fd, struct termios *termios_p)
+int attribute_hidden __tcgetattr (int fd, struct termios *termios_p)
{
struct __kernel_termios k_termios;
int retval;
return retval;
}
-
+strong_alias(__tcgetattr,tcgetattr)
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#define getsid __getsid
+#define tcgetpgrp __tcgetpgrp
+
#include <errno.h>
#include <termios.h>
#include <sys/ioctl.h>
/* Set the state of FD to *TERMIOS_P. */
-int tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
+int attribute_hidden __tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
{
struct __kernel_termios k_termios;
unsigned long int cmd;
return retval;
}
+strong_alias(__tcsetattr,tcsetattr)
much more current.
*/
+#define tcgetattr __tcgetattr
+
#include <errno.h>
#include <stddef.h>
#include <sys/ioctl.h>
#ifdef L_tcgetpgrp
/* Return the foreground process group ID of FD. */
-pid_t tcgetpgrp ( int fd)
+pid_t attribute_hidden __tcgetpgrp ( int fd)
{
int pgrp;
return (pid_t) -1;
return (pid_t) pgrp;
}
+strong_alias(__tcgetpgrp,tcgetpgrp)
#endif
/* This is a gross hack around a kernel bug. If the cfsetispeed functions is
#ifdef L_cfsetospeed
/* Set the output baud rate stored in *TERMIOS_P to SPEED. */
-int cfsetospeed (struct termios *termios_p, speed_t speed)
+int attribute_hidden __cfsetospeed (struct termios *termios_p, speed_t speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > B460800))
return 0;
}
+strong_alias(__cfsetospeed,cfsetospeed)
#endif
#ifdef L_cfsetispeed
* Although for Linux there is no difference between input and output
* speed, the numerical 0 is a special case for the input baud rate. It
* should set the input baud rate to the output baud rate. */
-int cfsetispeed ( struct termios *termios_p, speed_t speed)
+int attribute_hidden __cfsetispeed ( struct termios *termios_p, speed_t speed)
{
if ((speed & ~CBAUD) != 0
&& (speed < B57600 || speed > B460800))
return 0;
}
+strong_alias(__cfsetispeed,cfsetispeed)
#endif
#ifdef L_cfsetspeed
+
+extern int __cfsetospeed (struct termios *__termios_p, speed_t __speed) __THROW attribute_hidden;
+extern int __cfsetispeed (struct termios *__termios_p, speed_t __speed) __THROW attribute_hidden;
+
struct speed_struct
{
speed_t value;
for (cnt = 0; cnt < sizeof (speeds) / sizeof (speeds[0]); ++cnt)
if (speed == speeds[cnt].internal)
{
- cfsetispeed (termios_p, speed);
- cfsetospeed (termios_p, speed);
+ __cfsetispeed (termios_p, speed);
+ __cfsetospeed (termios_p, speed);
return 0;
}
else if (speed == speeds[cnt].value)
{
- cfsetispeed (termios_p, speeds[cnt].internal);
- cfsetospeed (termios_p, speeds[cnt].internal);
+ __cfsetispeed (termios_p, speeds[cnt].internal);
+ __cfsetospeed (termios_p, speeds[cnt].internal);
return 0;
}
*/
#define TTYNAME_BUFLEN 32
-char *ttyname(int fd)
-{
- static char name[TTYNAME_BUFLEN];
-
- return ttyname_r(fd, name, TTYNAME_BUFLEN) ? NULL : name;
-}
-
static const char dirlist[] =
/* 12345670123 */
"\010/dev/vc/\0" /* Try /dev/vc first (be devfs compatible) */
"\011/dev/pts/\0" /* and try /dev/pts next */
"\005/dev/\0"; /* and try walking through /dev last */
-int ttyname_r(int fd, char *ubuf, size_t ubuflen)
+int attribute_hidden __ttyname_r(int fd, char *ubuf, size_t ubuflen)
{
struct dirent *d;
struct stat st;
return rv;
}
+strong_alias(__ttyname_r,ttyname_r)
+
+char *ttyname(int fd)
+{
+ static char name[TTYNAME_BUFLEN];
+
+ return __ttyname_r(fd, name, TTYNAME_BUFLEN) ? NULL : name;
+}
*/
#define dup2 __dup2
+#define setsid __setsid
#include <stdio.h>
#include <features.h>
Boston, MA 02111-1307, USA. */
#define setvbuf __setvbuf
+#define tcsetattr __tcsetattr
+#define tcgetattr __tcgetattr
#include <stdio.h>
#include <string.h>
OSDN Git Service
