Hide mostly used functions

include/libc-internal.h

@@ -116,4 +116,68 @@
 /* --- this is added to integrate linuxthreads */
 #define __USE_UNIX98            1
 
+#ifndef __ASSEMBLER__
+# ifdef IS_IN_libc
+
+#  include <bits/types.h>
+
+#  ifndef __ssize_t_defined
+typedef __ssize_t ssize_t;
+#   define __ssize_t_defined
+#  endif
+
+#  define __need_size_t
+#  include <stddef.h>
+
+#  include <bits/sigset.h>
+
+/* prototypes for internal use, please keep these in sync w/ updated headers */
+/* #include <fcntl.h> */
+extern int __open(__const char *__file, int __oflag, ...) attribute_hidden;
+
+/* #include <string.h> */
+extern int __memcmp (__const void *__s1, __const void *__s2, size_t __n) attribute_hidden;
+extern void *__memcpy (void *__restrict __dest,
+		     __const void *__restrict __src, size_t __n) attribute_hidden;
+extern void *__memmove (void *__dest, __const void *__src, size_t __n) attribute_hidden;
+extern void *__memset (void *__s, int __c, size_t __n) attribute_hidden;
+extern char *__strcpy (char *__restrict __dest, __const char *__restrict __src) attribute_hidden;
+extern size_t __strlen (__const char *__s) attribute_hidden;
+extern int __strcmp (__const char *__s1, __const char *__s2) attribute_hidden;
+extern char *__strcat (char *__restrict __dest, __const char *__restrict __src) attribute_hidden;
+extern char *__strncpy (char *__restrict __dest,
+		      __const char *__restrict __src, size_t __n) attribute_hidden;
+extern char *__strchr (__const char *__s, int __c) attribute_hidden;
+extern int __strncmp (__const char *__s1, __const char *__s2, size_t __n) attribute_hidden;
+extern char *__strdup (__const char *__s) attribute_hidden;
+
+/* #include <unistd.h> */
+extern ssize_t __read(int __fd, void *__buf, size_t __nbytes) attribute_hidden;
+extern ssize_t __write(int __fd, __const void *__buf, size_t __n) attribute_hidden;
+extern int __close(int __fd) attribute_hidden;
+
+/* #include <signal.h> */
+extern int __sigprocmask (int __how, __const __sigset_t *__restrict __set,
+			__sigset_t *__restrict __oset) attribute_hidden;
+
+/* #include <sys/time.h> */
+#  if 0 /* undoable here */
+#   define __need_timeval
+#   include <bits/time.h>
+extern int __gettimeofday(struct timeval *__restrict __tv, *__restrict __timezone__ptr_t __tz) attribute_hidden;
+#  else
+#   define gettimeofday __gettimeofday
+#  endif
+
+# elif IS_IN_libpthread
+
+#  define gettimeofday __libc_gettimeofday
+
+# else
+
+#  define open __libc_open
+
+# endif
+#endif
+
 #endif /* _LIBC_INTERNAL_H */

libc/inet/addr.c

@@ -146,7 +146,7 @@ char *inet_ntoa(struct in_addr in)
  * Formulate an Internet address from network + host.  Used in
  * building addresses stored in the ifnet structure.
  */
-struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host)
+struct in_addr attribute_hidden __inet_makeaddr(in_addr_t net, in_addr_t host)
 {
 	in_addr_t addr;
 
@@ -161,6 +161,7 @@ struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host)
 	addr = htonl(addr);
 	return (*(struct in_addr *)&addr);
 }
+strong_alias(__inet_makeaddr,inet_makeaddr)
 
 #endif
 

libc/inet/getaddrinfo.c

@@ -44,7 +44,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /* This software is Copyright 1996 by Craig Metz, All Rights Reserved.  */
 
+/* strdupa is using these */
+#if 0
 #define memcpy __memcpy
+#define strlen __strlen
+#endif
 
 #define _GNU_SOURCE
 #define __FORCE_GLIBC
@@ -151,7 +155,7 @@ static int addrconfig (sa_family_t af)
 	ret = (errno == EMFILE) ? 1 : 0;
     else
     {
-	close(s);
+	__close(s);
 	ret = 1;
     }
     __set_errno (saved_errno);
@@ -175,10 +179,10 @@ gaih_local (const char *name, const struct gaih_service *service,
 
     if (name != NULL)
     {
-	if (strcmp(name, "localhost") &&
-	    strcmp(name, "local") &&
-	    strcmp(name, "unix") &&
-	    strcmp(name, utsname.nodename))
+	if (__strcmp(name, "localhost") &&
+	    __strcmp(name, "local") &&
+	    __strcmp(name, "unix") &&
+	    __strcmp(name, utsname.nodename))
 	    return GAIH_OKIFUNSPEC | -EAI_NONAME;
     }
 
@@ -205,7 +209,7 @@ gaih_local (const char *name, const struct gaih_service *service,
 
     *pai = malloc (sizeof (struct addrinfo) + sizeof (struct sockaddr_un)
 		   + ((req->ai_flags & AI_CANONNAME)
-		      ? (strlen(utsname.nodename) + 1): 0));
+		      ? (__strlen(utsname.nodename) + 1): 0));
     if (*pai == NULL)
 	return -EAI_MEMORY;
 
@@ -223,22 +227,22 @@ gaih_local (const char *name, const struct gaih_service *service,
 #endif /* SALEN */
 
     ((struct sockaddr_un *)(*pai)->ai_addr)->sun_family = AF_LOCAL;
-    memset(((struct sockaddr_un *)(*pai)->ai_addr)->sun_path, 0, UNIX_PATH_MAX);
+    __memset(((struct sockaddr_un *)(*pai)->ai_addr)->sun_path, 0, UNIX_PATH_MAX);
 
     if (service)
     {
 	struct sockaddr_un *sunp = (struct sockaddr_un *) (*pai)->ai_addr;
 
-	if (strchr (service->name, '/') != NULL)
+	if (__strchr (service->name, '/') != NULL)
 	{
-	    if (strlen (service->name) >= sizeof (sunp->sun_path))
+	    if (__strlen (service->name) >= sizeof (sunp->sun_path))
 		return GAIH_OKIFUNSPEC | -EAI_SERVICE;
 
-	    strcpy (sunp->sun_path, service->name);
+	    __strcpy (sunp->sun_path, service->name);
 	}
 	else
 	{
-	    if (strlen (P_tmpdir "/") + 1 + strlen (service->name) >=
+	    if (__strlen (P_tmpdir "/") + 1 + __strlen (service->name) >=
 		sizeof (sunp->sun_path))
 		return GAIH_OKIFUNSPEC | -EAI_SERVICE;
 
@@ -260,7 +264,7 @@ gaih_local (const char *name, const struct gaih_service *service,
     }
 
     if (req->ai_flags & AI_CANONNAME)
-	(*pai)->ai_canonname = strcpy ((char *) *pai + sizeof (struct addrinfo)
+	(*pai)->ai_canonname = __strcpy ((char *) *pai + sizeof (struct addrinfo)
 				       + sizeof (struct sockaddr_un),
 				       utsname.nodename);
     else
@@ -340,7 +344,7 @@ gaih_inet_serv (const char *servicename, const struct gaih_typeproto *tp,
 	    }								\
 	    (*pat)->next = NULL;					\
 		(*pat)->family = _family;				\
-		memcpy ((*pat)->addr, h->h_addr_list[i],		\
+		__memcpy ((*pat)->addr, h->h_addr_list[i],		\
 			sizeof(_type));					\
 		pat = &((*pat)->next);					\
 	}								\
@@ -491,7 +495,7 @@ gaih_inet (const char *name, const struct gaih_service *service,
 	    char *namebuf = strdupa (name);
 	    char *scope_delim;
 
-	    scope_delim = strchr (namebuf, SCOPE_DELIMITER);
+	    scope_delim = __strchr (namebuf, SCOPE_DELIMITER);
 	    if (scope_delim != NULL)
 		*scope_delim = '\0';
 
@@ -574,12 +578,12 @@ gaih_inet (const char *name, const struct gaih_service *service,
     {
 	struct gaih_addrtuple *atr;
 	atr = at = alloca (sizeof (struct gaih_addrtuple));
-	memset (at, '\0', sizeof (struct gaih_addrtuple));
+	__memset (at, '\0', sizeof (struct gaih_addrtuple));
 
 	if (req->ai_family == 0)
 	{
 	    at->next = alloca (sizeof (struct gaih_addrtuple));
-	    memset (at->next, '\0', sizeof (struct gaih_addrtuple));
+	    __memset (at->next, '\0', sizeof (struct gaih_addrtuple));
 	}
 
 #if __UCLIBC_HAS_IPV6__
@@ -588,7 +592,7 @@ gaih_inet (const char *name, const struct gaih_service *service,
 	    extern const struct in6_addr __in6addr_loopback;
 	    at->family = AF_INET6;
 	    if ((req->ai_flags & AI_PASSIVE) == 0)
-		memcpy (at->addr, &__in6addr_loopback, sizeof (struct in6_addr));
+		__memcpy (at->addr, &__in6addr_loopback, sizeof (struct in6_addr));
 	    atr = at->next;
 	}
 #endif
@@ -660,7 +664,7 @@ gaih_inet (const char *name, const struct gaih_service *service,
 		if (c == NULL)
 		    return GAIH_OKIFUNSPEC | -EAI_NONAME;
 
-		namelen = strlen (c) + 1;
+		namelen = __strlen (c) + 1;
 	    }
 	    else
 		namelen = 0;
@@ -704,7 +708,7 @@ gaih_inet (const char *name, const struct gaih_service *service,
 		    sin6p->sin6_flowinfo = 0;
 		    if (at2->family == AF_INET6)
 		    {
-			memcpy (&sin6p->sin6_addr,
+			__memcpy (&sin6p->sin6_addr,
 				at2->addr, sizeof (struct in6_addr));
 		    }
 		    else
@@ -712,7 +716,7 @@ gaih_inet (const char *name, const struct gaih_service *service,
 			sin6p->sin6_addr.s6_addr32[0] = 0;
 			sin6p->sin6_addr.s6_addr32[1] = 0;
 			sin6p->sin6_addr.s6_addr32[2] = htonl(0x0000ffff);
-			memcpy(&sin6p->sin6_addr.s6_addr32[3], 
+			__memcpy(&sin6p->sin6_addr.s6_addr32[3], 
 			       at2->addr, sizeof (sin6p->sin6_addr.s6_addr32[3]));
 		    }
 		    sin6p->sin6_port = st2->port;
@@ -724,17 +728,17 @@ gaih_inet (const char *name, const struct gaih_service *service,
 		    struct sockaddr_in *sinp =
 			(struct sockaddr_in *) (*pai)->ai_addr;
 
-		    memcpy (&sinp->sin_addr,
+		    __memcpy (&sinp->sin_addr,
 			    at2->addr, sizeof (struct in_addr));
 		    sinp->sin_port = st2->port;
-		    memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
+		    __memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
 		}
 
 		if (c)
 		{
 		    (*pai)->ai_canonname = ((void *) (*pai) +
 					    sizeof (struct addrinfo) + socklen);
-		    strcpy ((*pai)->ai_canonname, c);
+		    __strcpy ((*pai)->ai_canonname, c);
 		}
 		else
 		    (*pai)->ai_canonname = NULL;

libc/inet/getnetbynm.c

@@ -30,10 +30,10 @@ getnetbyname(const char *name)
 
 	setnetent(_net_stayopen);
 	while ((p = getnetent())) {
-		if (strcmp(p->n_name, name) == 0)
+		if (__strcmp(p->n_name, name) == 0)
 			break;
 		for (cp = p->n_aliases; *cp != 0; cp++)
-			if (strcmp(*cp, name) == 0)
+			if (__strcmp(*cp, name) == 0)
 				goto found;
 	}
 found:

libc/inet/getproto.c

@@ -213,10 +213,10 @@ int getprotobyname_r(const char *name,
     LOCK;
     setprotoent(proto_stayopen);
     while (!(ret=getprotoent_r(result_buf, buf, buflen, result))) {
-	if (strcmp(result_buf->p_name, name) == 0)
+	if (__strcmp(result_buf->p_name, name) == 0)
 	    break;
 	for (cp = result_buf->p_aliases; *cp != 0; cp++)
-	    if (strcmp(*cp, name) == 0)
+	    if (__strcmp(*cp, name) == 0)
 		goto found;
     }
 found:

libc/inet/getservice.c

@@ -239,14 +239,14 @@ int getservbyname_r(const char *name, const char *proto,
     LOCK;
     setservent(serv_stayopen);
     while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
-	if (strcmp(name, result_buf->s_name) == 0)
+	if (__strcmp(name, result_buf->s_name) == 0)
 	    goto gotname;
 	for (cp = result_buf->s_aliases; *cp; cp++)
-	    if (strcmp(name, *cp) == 0)
+	    if (__strcmp(name, *cp) == 0)
 		goto gotname;
 	continue;
 gotname:
-	if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
+	if (proto == 0 || __strcmp(result_buf->s_proto, proto) == 0)
 	    break;
     }
     if (!serv_stayopen)
@@ -266,7 +266,7 @@ int getservbyport_r(int port, const char *proto,
     while (!(ret=getservent_r(result_buf, buf, buflen, result))) {
 	if (result_buf->s_port != port)
 	    continue;
-	if (proto == 0 || strcmp(result_buf->s_proto, proto) == 0)
+	if (proto == 0 || __strcmp(result_buf->s_proto, proto) == 0)
 	    break;
     }
     if (!serv_stayopen)

libc/inet/hostid.c

@@ -18,10 +18,10 @@ int sethostid(long int new_id)
 	int ret;
 
 	if (geteuid() || getuid()) return __set_errno(EPERM);
-	if ((fd=open(HOSTID,O_CREAT|O_WRONLY,0644))<0) return -1;
-	ret = write(fd,(void *)&new_id,sizeof(new_id)) == sizeof(new_id)
+	if ((fd=__open(HOSTID,O_CREAT|O_WRONLY,0644))<0) return -1;
+	ret = __write(fd,(void *)&new_id,sizeof(new_id)) == sizeof(new_id)
 		? 0 : -1;
-	close (fd);
+	__close (fd);
 	return ret;
 }
 
@@ -34,12 +34,12 @@ long int gethostid(void)
 	 * It is not an error if we cannot read this file. It is not even an
 	 * error if we cannot read all the bytes, we just carry on trying...
 	 */
-	if ((fd=open(HOSTID,O_RDONLY))>=0 && read(fd,(void *)&id,sizeof(id)))
+	if ((fd=__open(HOSTID,O_RDONLY))>=0 && __read(fd,(void *)&id,sizeof(id)))
 	{
-		close (fd);
+		__close (fd);
 		return id;
 	}
-	if (fd >= 0) close (fd);
+	if (fd >= 0) __close (fd);
 
 	/* Try some methods of returning a unique 32 bit id. Clearly IP
 	 * numbers, if on the internet, will have a unique address. If they
@@ -65,7 +65,7 @@ long int gethostid(void)
 		 */
 			return 0;
 		else {
-			memcpy((char *) &in, (char *) hp->h_addr, hp->h_length);
+			__memcpy((char *) &in, (char *) hp->h_addr, hp->h_length);
 
 			/* Just so it doesn't look exactly like the IP addr */
 			return(in.s_addr<<16|in.s_addr>>16);

libc/inet/if_nametoindex.c

@@ -51,15 +51,15 @@ unsigned int if_nametoindex(const char* ifname)
     fd = __opensock();
     if (fd < 0)
 	return 0;
-    strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
+    __strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
     if (ioctl(fd,SIOCGIFINDEX,&ifr) < 0) {
 	int saved_errno = errno;
-	close(fd);
+	__close(fd);
 	if (saved_errno == EINVAL)
 	    __set_errno(ENOSYS);
 	return 0;
     }
-    close(fd);
+    __close(fd);
     return ifr.ifr_ifindex;
 
 #endif /* SIOCGIFINDEX */
@@ -103,7 +103,7 @@ struct if_nameindex * if_nameindex (void)
     do {
 	ifc.ifc_buf = realloc(ifc.ifc_buf, ifc.ifc_len = rq_len);
 	if (ifc.ifc_buf == NULL || ioctl(fd, SIOCGIFCONF, &ifc) < 0) {
-	    close(fd);
+	    __close(fd);
 	    return NULL;
 	}
 	rq_len *= 2;
@@ -113,21 +113,21 @@ struct if_nameindex * if_nameindex (void)
 
     idx = malloc ((nifs + 1) * sizeof(struct if_nameindex));
     if (idx == NULL) {
-	close(fd);
+	__close(fd);
 	__set_errno(ENOBUFS);
 	return NULL;
     }
 
     for (i = 0; i < nifs; ++i) {
 	struct ifreq *ifr = &ifc.ifc_req[i];
-	idx[i].if_name = strdup (ifr->ifr_name);
+	idx[i].if_name = __strdup (ifr->ifr_name);
 	if (idx[i].if_name == NULL || ioctl(fd,SIOCGIFINDEX,ifr) < 0) {
 	    int saved_errno = errno;
 	    unsigned int j;
 	    for (j =  0; j < i; ++j)
 		free (idx[j].if_name);
 	    free(idx);
-	    close(fd);
+	    __close(fd);
 	    if (saved_errno == EINVAL)
 		saved_errno = ENOSYS;
 	    else if (saved_errno == ENOMEM)
@@ -141,7 +141,7 @@ struct if_nameindex * if_nameindex (void)
     idx[i].if_index = 0;
     idx[i].if_name = NULL;
 
-    close(fd);
+    __close(fd);
     return idx;
 #endif
 }
@@ -161,13 +161,13 @@ char * if_indextoname (unsigned int ifindex, char *ifname)
   ifr.ifr_ifindex = ifindex;
   if (ioctl (fd, SIOCGIFNAME, &ifr) < 0) {
       saved_errno = errno;
-      close (fd);
+      __close (fd);
       __set_errno (saved_errno);
       return NULL;
   }
-  close (fd);
+  __close (fd);
 
-  return strncpy (ifname, ifr.ifr_name, IFNAMSIZ);
+  return __strncpy (ifname, ifr.ifr_name, IFNAMSIZ);
 #else
     struct if_nameindex *idx;
     struct if_nameindex *p;
@@ -177,7 +177,7 @@ char * if_indextoname (unsigned int ifindex, char *ifname)
     if (idx != NULL) {
 	for (p = idx; p->if_index || p->if_name; ++p) {
 	    if (p->if_index == ifindex) {
-		result = strncpy (ifname, p->if_name, IFNAMSIZ);
+		result = __strncpy (ifname, p->if_name, IFNAMSIZ);
 		break;
 	    }
 	}

libc/inet/ntop.c

@@ -15,8 +15,6 @@
  * SOFTWARE.
  */
 
-#define memmove __memmove
-
 #define __FORCE_GLIBC
 #include <features.h>
 #include <sys/param.h>
@@ -78,12 +76,12 @@ inet_ntop4(const u_char *src, char *dst, size_t size)
 	}
 	tmp[i - 1] = '\0';
 
-	if (strlen (tmp) > size) {
+	if (__strlen (tmp) > size) {
 		__set_errno (ENOSPC);
 		return (NULL);
 	}
 
-	return strcpy(dst, tmp);
+	return __strcpy(dst, tmp);
 }
 
 
@@ -116,7 +114,7 @@ inet_ntop6(const u_char *src, char *dst, size_t size)
 	 *	Copy the input (bytewise) array into a wordwise array.
 	 *	Find the longest run of 0x00's in src[] for :: shorthanding.
 	 */
-	memset(words, '\0', sizeof words);
+	__memset(words, '\0', sizeof words);
 	for (i = 0; i < 16; i += 2)
 		words[i / 2] = (src[i] << 8) | src[i + 1];
 	best.base = -1;
@@ -162,7 +160,7 @@ inet_ntop6(const u_char *src, char *dst, size_t size)
 		    (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
 			if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp)))
 				return (NULL);
-			tp += strlen(tp);
+			tp += __strlen(tp);
 			break;
 		}
 		tp += sprintf(tp, "%x", words[i]);
@@ -179,7 +177,7 @@ inet_ntop6(const u_char *src, char *dst, size_t size)
 		__set_errno (ENOSPC);
 		return (NULL);
 	}
-	return strcpy(dst, tmp);
+	return __strcpy(dst, tmp);
 }
 #endif /* __UCLIBC_HAS_IPV6__ */
 
@@ -226,7 +224,7 @@ inet_pton4(const char *src, u_char *dst)
 	}
 	if (octets < 4)
 		return (0);
-	memcpy(dst, tmp, 4);
+	__memcpy(dst, tmp, 4);
 	return (1);
 }
 
@@ -263,7 +261,7 @@ inet_pton6(const char *src, u_char *dst)
 	u_int val;
 
 
-	tp = memset(tmp, '\0', 16);
+	tp = __memset(tmp, '\0', 16);
 	endp = tp + 16;
 	colonp = NULL;
 	/* Leading :: requires some special handling. */
@@ -276,7 +274,7 @@ inet_pton6(const char *src, u_char *dst)
 	while ((ch = tolower (*src++)) != '\0') {
 		const char *pch;
 
-		pch = strchr(xdigits, ch);
+		pch = __strchr(xdigits, ch);
 		if (pch != NULL) {
 			val <<= 4;
 			val |= (pch - xdigits);
@@ -335,7 +333,7 @@ inet_pton6(const char *src, u_char *dst)
 	}
 	if (tp != endp)
 		return (0);
-	memcpy(dst, tmp, 16);
+	__memcpy(dst, tmp, 16);
 	return (1);
 }
 

libc/inet/resolv.c

@@ -133,7 +133,6 @@
  *
  */
 
-#define memmove __memmove
 #define strnlen __strnlen
 #define strncat __strncat
 #define strstr __strstr
@@ -342,14 +341,14 @@ int attribute_hidden __encode_dotted(const char *dotted, unsigned char *dest, in
 	int used = 0;
 
 	while (dotted && *dotted) {
-		char *c = strchr(dotted, '.');
-		int l = c ? c - dotted : strlen(dotted);
+		char *c = __strchr(dotted, '.');
+		int l = c ? c - dotted : __strlen(dotted);
 
 		if (l >= (maxlen - used - 1))
 			return -1;
 
 		dest[used++] = l;
-		memcpy(dest + used, dotted, l);
+		__memcpy(dest + used, dotted, l);
 		used += l;
 
 		if (c)
@@ -397,7 +396,7 @@ int attribute_hidden __decode_dotted(const unsigned char *data, int offset,
 		if ((used + l + 1) >= maxlen)
 			return -1;
 
-		memcpy(dest + used, data + offset, l);
+		__memcpy(dest + used, data + offset, l);
 		offset += l;
 		used += l;
 		if (measure)
@@ -482,7 +481,7 @@ int __decode_question(unsigned char *message, int offset,
 
 	offset += i;
 
-	q->dotted = strdup(temp);
+	q->dotted = __strdup(temp);
 	q->qtype = (message[offset + 0] << 8) | message[offset + 1];
 	q->qclass = (message[offset + 2] << 8) | message[offset + 3];
 
@@ -528,7 +527,7 @@ int attribute_hidden __encode_answer(struct resolv_answer *a, unsigned char *des
 	*dest++ = (a->ttl & 0x000000ff) >> 0;
 	*dest++ = (a->rdlength & 0xff00) >> 8;
 	*dest++ = (a->rdlength & 0x00ff) >> 0;
-	memcpy(dest, a->rdata, a->rdlength);
+	__memcpy(dest, a->rdata, a->rdlength);
 
 	return i + RRFIXEDSZ + a->rdlength;
 }
@@ -547,7 +546,7 @@ int attribute_hidden __decode_answer(unsigned char *message, int offset,
 
 	message += offset + i;
 
-	a->dotted = strdup(temp);
+	a->dotted = __strdup(temp);
 	a->atype = (message[0] << 8) | message[1];
 	message += 2;
 	a->aclass = (message[0] << 8) | message[1];
@@ -638,7 +637,7 @@ int __form_query(int id, const char *name, int type, unsigned char *packet,
 	struct resolv_question q;
 	int i, j;
 
-	memset(&h, 0, sizeof(h));
+	__memset(&h, 0, sizeof(h));
 	h.id = id;
 	h.qdcount = 1;
 
@@ -714,11 +713,11 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 
 	while (retries < MAX_RETRIES) {
 		if (fd != -1)
-			close(fd);
+			__close(fd);
 
-		memset(packet, 0, PACKETSZ);
+		__memset(packet, 0, PACKETSZ);
 
-		memset(&h, 0, sizeof(h));
+		__memset(&h, 0, sizeof(h));
 
 		++local_id;
 		local_id &= 0xffff;
@@ -734,7 +733,7 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 		if (i < 0)
 			goto fail;
 
-		strncpy(lookup,name,MAXDNAME);
+		__strncpy(lookup,name,MAXDNAME);
 		if (variant >= 0) {
                         BIGLOCK;
                         if (variant < __searchdomains) {
@@ -865,7 +864,7 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 			ma.buf = a->buf;
 			ma.buflen = a->buflen;
 			ma.add_count = a->add_count;
-			memcpy(a, &ma, sizeof(ma));
+			__memcpy(a, &ma, sizeof(ma));
 			if (a->atype != T_SIG && (0 == a->buf || (type != T_A && type != T_AAAA)))
 			{
 			    break;
@@ -897,7 +896,7 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 				    ma.rdlength, a->rdlength);
 			    goto again;
 			}
-			memcpy(a->buf + (a->add_count * ma.rdlength), ma.rdata, ma.rdlength);
+			__memcpy(a->buf + (a->add_count * ma.rdlength), ma.rdata, ma.rdlength);
 			++a->add_count;
 		    }
 		}
@@ -905,7 +904,7 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 		DPRINTF("Answer name = |%s|\n", a->dotted);
 		DPRINTF("Answer type = |%d|\n", a->atype);
 
-		close(fd);
+		__close(fd);
 
 		if (outpacket)
 			*outpacket = packet;
@@ -957,7 +956,7 @@ int attribute_hidden __dns_lookup(const char *name, int type, int nscount, char
 
 fail:
 	if (fd != -1)
-	    close(fd);
+	    __close(fd);
 	if (lookup)
 	    free(lookup);
 	if (packet)
@@ -1022,21 +1021,21 @@ int attribute_hidden __open_nameservers()
 					*p++ = '\0';
 			}
 
-			if (strcmp(argv[0], "nameserver") == 0) {
+			if (__strcmp(argv[0], "nameserver") == 0) {
 				for (i = 1; i < argc && __nameservers < MAX_SERVERS; i++) {
-					__nameserver[__nameservers++] = strdup(argv[i]);
+					__nameserver[__nameservers++] = __strdup(argv[i]);
 					DPRINTF("adding nameserver %s\n", argv[i]);
 				}
 			}
 
 			/* domain and search are mutually exclusive, the last one wins */
-			if (strcmp(argv[0],"domain")==0 || strcmp(argv[0],"search")==0) {
+			if (__strcmp(argv[0],"domain")==0 || __strcmp(argv[0],"search")==0) {
 				while (__searchdomains > 0) {
 					free(__searchdomain[--__searchdomains]);
 					__searchdomain[__searchdomains] = NULL;
 				}
 				for (i=1; i < argc && __searchdomains < MAX_SEARCH; i++) {
-					__searchdomain[__searchdomains++] = strdup(argv[i]);
+					__searchdomain[__searchdomains++] = __strdup(argv[i]);
 					DPRINTF("adding search %s\n", argv[i]);
 				}
 			}
@@ -1187,7 +1186,7 @@ int res_query(const char *dname, int class, int type,
 		return(-1);
 	}
 
-	memset((char *) &a, '\0', sizeof(a));
+	__memset((char *) &a, '\0', sizeof(a));
 
 	BIGLOCK;
 	__nameserversXX=__nameservers;
@@ -1204,7 +1203,7 @@ int res_query(const char *dname, int class, int type,
 
 	if (a.atype == type) { /* CNAME*/
 		int len = MIN(anslen, i);
-		memcpy(answer, packet, len);
+		__memcpy(answer, packet, len);
 		if (packet)
 			free(packet);
 		return(len);
@@ -1380,19 +1379,19 @@ int res_querydomain(name, domain, class, type, answer, anslen)
 		 * Check for trailing '.';
 		 * copy without '.' if present.
 		 */
-		n = strlen(name);
+		n = __strlen(name);
 		if (n + 1 > sizeof(nbuf)) {
 			h_errno = NO_RECOVERY;
 			return (-1);
 		}
 		if (n > 0 && name[--n] == '.') {
-			strncpy(nbuf, name, n);
+			__strncpy(nbuf, name, n);
 			nbuf[n] = '\0';
 		} else
 			longname = name;
 	} else {
-		n = strlen(name);
-		d = strlen(domain);
+		n = __strlen(name);
+		d = __strlen(domain);
 		if (n + 1 + d + 1 > sizeof(nbuf)) {
 			h_errno = NO_RECOVERY;
 			return (-1);
@@ -1509,7 +1508,7 @@ int attribute_hidden __read_etc_hosts_r(FILE * fp, const char * name, int type,
 
 	*h_errnop=HOST_NOT_FOUND;
 	while (fgets(buf, buflen, fp)) {
-		if ((cp = strchr(buf, '#')))
+		if ((cp = __strchr(buf, '#')))
 			*cp = '\0';
 		DPRINTF("Looking at: %s\n", buf);
 		aliases = 0;
@@ -1534,7 +1533,7 @@ int attribute_hidden __read_etc_hosts_r(FILE * fp, const char * name, int type,
 			/* Return whatever the next entry happens to be. */
 			break;
 		} else if (action==GET_HOSTS_BYADDR) {
-			if (strcmp(name, alias[0]) != 0)
+			if (__strcmp(name, alias[0]) != 0)
 				continue;
 		} else {
 			/* GET_HOSTS_BYNAME */
@@ -1765,12 +1764,12 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 					    && (getdomainname (domain, sizeof(domain)) == 0)
 					    && (c = strstr (h->h_name, domain))
 					    && (c != h->h_name) && (*(--c) == '.')) {
-						strncpy (host, h->h_name,
+						__strncpy (host, h->h_name,
 							min(hostlen, (size_t) (c - h->h_name)));
 						host[min(hostlen - 1, (size_t) (c - h->h_name))] = '\0';
 						ok = 1;
 					} else {
-						strncpy (host, h->h_name, hostlen);
+						__strncpy (host, h->h_name, hostlen);
 						ok = 1;
 					}
 				 }
@@ -1811,7 +1810,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 								if (if_indextoname (scopeid, scopeptr) == NULL)
 									++ni_numericscope;
 								else
-									scopelen = strlen (scopebuf);
+									scopelen = __strlen (scopebuf);
 							} else {
 								++ni_numericscope;
 							}
@@ -1825,7 +1824,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 
 							if (real_hostlen + scopelen + 1 > hostlen)
 								return EAI_SYSTEM;
-							memcpy (host + real_hostlen, scopebuf, scopelen + 1);
+							__memcpy (host + real_hostlen, scopebuf, scopelen + 1);
 						}
 #endif
 					} else
@@ -1848,7 +1847,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 				struct utsname utsname;
 
 				if (!uname (&utsname)) {
-					strncpy (host, utsname.nodename, hostlen);
+					__strncpy (host, utsname.nodename, hostlen);
 					break;
 				};
 			};
@@ -1858,7 +1857,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 				return EAI_NONAME;
 			}
 
-			strncpy (host, "localhost", hostlen);
+			__strncpy (host, "localhost", hostlen);
 			break;
 
 		default:
@@ -1876,7 +1875,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 				s = getservbyport (((const struct sockaddr_in *) sa)->sin_port,
 				      ((flags & NI_DGRAM) ? "udp" : "tcp"));
 				if (s) {
-					strncpy (serv, s->s_name, servlen);
+					__strncpy (serv, s->s_name, servlen);
 					break;
 				}
 			}
@@ -1885,7 +1884,7 @@ int getnameinfo (const struct sockaddr *sa, socklen_t addrlen, char *host,
 			break;
 
 		case AF_LOCAL:
-			strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
+			__strncpy (serv, ((const struct sockaddr_un *) sa)->sun_path, servlen);
 			break;
 		}
 	}
@@ -1970,7 +1969,7 @@ int gethostbyname_r(const char * name,
 
 	if (buflen<256)
 		return ERANGE;
-	strncpy(buf, name, buflen);
+	__strncpy(buf, name, buflen);
 
 	alias[0] = buf;
 	alias[1] = NULL;
@@ -2014,7 +2013,7 @@ int gethostbyname_r(const char * name,
 	    }
 	    else if(a.add_count > 0)
 	    {
-		memmove(buf - sizeof(struct in_addr*)*2, buf, a.add_count * a.rdlength);
+		__memmove(buf - sizeof(struct in_addr*)*2, buf, a.add_count * a.rdlength);
 		addr_list = (struct in_addr**)(buf + a.add_count * a.rdlength);
 		addr_list[0] = in;
 		for (i = a.add_count-1; i>=0; --i)
@@ -2024,11 +2023,11 @@ int gethostbyname_r(const char * name,
 		buf = (char*)&addr_list[a.add_count + 2];
 	    }
 
-	    strncpy(buf, a.dotted, buflen);
+	    __strncpy(buf, a.dotted, buflen);
 	    free(a.dotted);
 
 	    if (a.atype == T_A) { /* ADDRESS */
-		memcpy(in, a.rdata, sizeof(*in));
+		__memcpy(in, a.rdata, sizeof(*in));
 		result_buf->h_name = buf;
 		result_buf->h_addrtype = AF_INET;
 		result_buf->h_length = sizeof(*in);
@@ -2127,7 +2126,7 @@ int gethostbyname2_r(const char *name, int family,
 
 	if (buflen<256)
 		return ERANGE;
-	strncpy(buf, name, buflen);
+	__strncpy(buf, name, buflen);
 
 	/* First check if this is already an address */
 	if (inet_pton(AF_INET6, name, in)) {
@@ -2140,7 +2139,7 @@ int gethostbyname2_r(const char *name, int family,
 	    return NETDB_SUCCESS;
 	}
 
-	memset((char *) &a, '\0', sizeof(a));
+	__memset((char *) &a, '\0', sizeof(a));
 
 	for (;;) {
 	BIGLOCK;
@@ -2155,7 +2154,7 @@ int gethostbyname2_r(const char *name, int family,
 			return TRY_AGAIN;
 		}
 
-		strncpy(buf, a.dotted, buflen);
+		__strncpy(buf, a.dotted, buflen);
 		free(a.dotted);
 
 		if (a.atype == T_CNAME) {		/* CNAME */
@@ -2173,7 +2172,7 @@ int gethostbyname2_r(const char *name, int family,
 			}
 			continue;
 		} else if (a.atype == T_AAAA) {	/* ADDRESS */
-			memcpy(in, a.rdata, sizeof(*in));
+			__memcpy(in, a.rdata, sizeof(*in));
 			result_buf->h_name = buf;
 			result_buf->h_addrtype = AF_INET6;
 			result_buf->h_length = sizeof(*in);
@@ -2221,7 +2220,7 @@ int gethostbyaddr_r (const void *addr, socklen_t len, int type,
 	if (!addr)
 		return EINVAL;
 
-	memset((char *) &a, '\0', sizeof(a));
+	__memset((char *) &a, '\0', sizeof(a));
 
 	switch (type) {
 		case AF_INET:
@@ -2295,7 +2294,7 @@ int gethostbyaddr_r (const void *addr, socklen_t len, int type,
 	if(type == AF_INET) {
 		unsigned char *tmp_addr = (unsigned char *)addr;
 
-		memcpy(&in->s_addr, addr, len);
+		__memcpy(&in->s_addr, addr, len);
 
 		addr_list[0] = in;
 
@@ -2303,7 +2302,7 @@ int gethostbyaddr_r (const void *addr, socklen_t len, int type,
 			tmp_addr[3], tmp_addr[2], tmp_addr[1], tmp_addr[0]);
 #ifdef __UCLIBC_HAS_IPV6__
 	} else {
-		memcpy(in6->s6_addr, addr, len);
+		__memcpy(in6->s6_addr, addr, len);
 
 		addr_list6[0] = in6;
 		qp = buf;
@@ -2312,7 +2311,7 @@ int gethostbyaddr_r (const void *addr, socklen_t len, int type,
 			qp += sprintf(qp, "%x.%x.", in6->s6_addr[i] & 0xf,
 				(in6->s6_addr[i] >> 4) & 0xf);
     	}
-    	strcpy(qp, "ip6.int");
+    	__strcpy(qp, "ip6.int");
 #endif /* __UCLIBC_HAS_IPV6__ */
 	}
 
@@ -2331,7 +2330,7 @@ int gethostbyaddr_r (const void *addr, socklen_t len, int type,
 			return TRY_AGAIN;
 		}
 
-		strncpy(buf, a.dotted, buflen);
+		__strncpy(buf, a.dotted, buflen);
 		free(a.dotted);
 
 		if (a.atype == T_CNAME) {		/* CNAME */
@@ -2570,7 +2569,7 @@ int attribute_hidden __libc_ns_name_unpack(const u_char *msg, const u_char *eom,
 			}
 			checked += n + 1;
 			*dstp++ = n;
-			memcpy(dstp, srcp, n);
+			__memcpy(dstp, srcp, n);
 			dstp += n;
 			srcp += n;
 			break;

libc/inet/rpc/auth_unix.c

@@ -152,7 +152,7 @@ no_memory:
   au->au_origcred.oa_base = mem_alloc ((u_int) len);
   if (au->au_origcred.oa_base == NULL)
     goto no_memory;
-  memcpy(au->au_origcred.oa_base, mymem, (u_int) len);
+  __memcpy(au->au_origcred.oa_base, mymem, (u_int) len);
 
   /*
    * set auth handle to reflect new cred.

libc/inet/rpc/bindresvport.c

@@ -58,7 +58,7 @@ bindresvport (int sd, struct sockaddr_in *sin)
   if (sin == (struct sockaddr_in *) 0)
     {
       sin = &myaddr;
-      memset (sin, 0, sizeof (*sin));
+      __memset (sin, 0, sizeof (*sin));
       sin->sin_family = AF_INET;
     }
   else if (sin->sin_family != AF_INET)

libc/inet/rpc/clnt_generic.c

@@ -63,11 +63,11 @@ clnt_create (const char *hostname, u_long prog, u_long vers,
   CLIENT *client;
   int herr;
 
-  if (strcmp (proto, "unix") == 0)
+  if (__strcmp (proto, "unix") == 0)
     {
-      memset ((char *)&sun, 0, sizeof (sun));
+      __memset ((char *)&sun, 0, sizeof (sun));
       sun.sun_family = AF_UNIX;
-      strcpy (sun.sun_path, hostname);
+      __strcpy (sun.sun_path, hostname);
       sock = RPC_ANYSOCK;
       client = clntunix_create (&sun, prog, vers, &sock, 0, 0);
       if (client == NULL)
@@ -112,8 +112,8 @@ clnt_create (const char *hostname, u_long prog, u_long vers,
     }
   sin.sin_family = h->h_addrtype;
   sin.sin_port = 0;
-  memset (sin.sin_zero, 0, sizeof (sin.sin_zero));
-  memcpy ((char *) &sin.sin_addr, h->h_addr, h->h_length);
+  __memset (sin.sin_zero, 0, sizeof (sin.sin_zero));
+  __memcpy ((char *) &sin.sin_addr, h->h_addr, h->h_length);
 
   prtbuflen = 1024;
   prttmpbuf = alloca (prtbuflen);

libc/inet/rpc/clnt_perror.c

@@ -91,8 +91,8 @@ clnt_sperror (CLIENT * rpch, const char *msg)
   len = sprintf (str, "%s: ", msg);
   str += len;
 
-  (void) strcpy(str, clnt_sperrno(e.re_status));
-  str += strlen(str);
+  (void) __strcpy(str, clnt_sperrno(e.re_status));
+  str += __strlen(str);
 
   switch (e.re_status)
     {
@@ -126,13 +126,13 @@ clnt_sperror (CLIENT * rpch, const char *msg)
 
     case RPC_AUTHERROR:
       err = auth_errmsg (e.re_why);
-      (void) strcpy(str, _("; why = "));
-      str += strlen(str);
+      (void) __strcpy(str, _("; why = "));
+      str += __strlen(str);
 
       if (err != NULL)
 	{
-	  (void) strcpy(str, err);
-	  str += strlen(str);
+	  (void) __strcpy(str, err);
+	  str += __strlen(str);
 	}
       else
 	{
@@ -316,27 +316,27 @@ clnt_spcreateerror (const char *msg)
   ce = &get_rpc_createerr ();
   len = sprintf (str, "%s: ", msg);
   cp = str + len;
-  (void) strcpy(cp, clnt_sperrno (ce->cf_stat));
-  cp += strlen(cp);
+  (void) __strcpy(cp, clnt_sperrno (ce->cf_stat));
+  cp += __strlen(cp);
 
   switch (ce->cf_stat)
     {
     case RPC_PMAPFAILURE:
-      (void) strcpy(cp, " - ");
-      cp += strlen(cp);
+      (void) __strcpy(cp, " - ");
+      cp += __strlen(cp);
 
-      (void) strcpy(cp, clnt_sperrno (ce->cf_error.re_status));
-      cp += strlen(cp);
+      (void) __strcpy(cp, clnt_sperrno (ce->cf_error.re_status));
+      cp += __strlen(cp);
 
       break;
 
     case RPC_SYSTEMERROR:
-      (void) strcpy(cp, " - ");
-      cp += strlen(cp);
+      (void) __strcpy(cp, " - ");
+      cp += __strlen(cp);
 
       strerror_r (ce->cf_error.re_errno, chrbuf, sizeof chrbuf);
-      (void) strcpy(cp, chrbuf);
-      cp += strlen(cp);
+      (void) __strcpy(cp, chrbuf);
+      cp += __strlen(cp);
       break;
     default:
       break;

libc/inet/rpc/clnt_simple.c

@@ -87,7 +87,7 @@ callrpc (const char *host, u_long prognum, u_long versnum, u_long procnum,
       crp->socket = RPC_ANYSOCK;
     }
   if (crp->valid && crp->oldprognum == prognum && crp->oldversnum == versnum
-      && strcmp (crp->oldhost, host) == 0)
+      && __strcmp (crp->oldhost, host) == 0)
     {
       /* reuse old client */
     }
@@ -100,7 +100,7 @@ callrpc (const char *host, u_long prognum, u_long versnum, u_long procnum,
       crp->valid = 0;
       if (crp->socket != RPC_ANYSOCK)
 	{
-	  (void) close (crp->socket);
+	  (void) __close (crp->socket);
 	  crp->socket = RPC_ANYSOCK;
 	}
       if (crp->client)
@@ -125,7 +125,7 @@ callrpc (const char *host, u_long prognum, u_long versnum, u_long procnum,
 
       timeout.tv_usec = 0;
       timeout.tv_sec = 5;
-      memcpy ((char *) &server_addr.sin_addr, hp->h_addr, hp->h_length);
+      __memcpy ((char *) &server_addr.sin_addr, hp->h_addr, hp->h_length);
       server_addr.sin_family = AF_INET;
       server_addr.sin_port = 0;
       if ((crp->client = clntudp_create (&server_addr, (u_long) prognum,
@@ -134,7 +134,7 @@ callrpc (const char *host, u_long prognum, u_long versnum, u_long procnum,
       crp->valid = 1;
       crp->oldprognum = prognum;
       crp->oldversnum = versnum;
-      (void) strncpy (crp->oldhost, host, 255);
+      (void) __strncpy (crp->oldhost, host, 255);
       crp->oldhost[255] = '\0';
     }
   tottimeout.tv_sec = 25;

libc/inet/rpc/clnt_tcp.c

@@ -175,7 +175,7 @@ clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
 	  ce->cf_stat = RPC_SYSTEMERROR;
 	  ce->cf_error.re_errno = errno;
 	  if (*sockp >= 0)
-	    (void) close (*sockp);
+	    (void) __close (*sockp);
 	  goto fooy;
 	}
       ct->ct_closeit = TRUE;
@@ -211,7 +211,7 @@ clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
     {
       if (ct->ct_closeit)
 	{
-	  (void) close (*sockp);
+	  (void) __close (*sockp);
 	}
       goto fooy;
     }
@@ -464,7 +464,7 @@ clnttcp_destroy (CLIENT *h)
 
   if (ct->ct_closeit)
     {
-      (void) close (ct->ct_sock);
+      (void) __close (ct->ct_sock);
     }
   XDR_DESTROY (&(ct->ct_xdrs));
   mem_free ((caddr_t) ct, sizeof (struct ct_data));
@@ -506,7 +506,7 @@ readtcp (char *ctptr, char *buf, int len)
 	}
       break;
     }
-  switch (len = read (ct->ct_sock, buf, len))
+  switch (len = __read (ct->ct_sock, buf, len))
     {
 
     case 0:
@@ -532,7 +532,7 @@ writetcp (char *ctptr, char *buf, int len)
 
   for (cnt = len; cnt > 0; cnt -= i, buf += i)
     {
-      if ((i = write (ct->ct_sock, buf, cnt)) == -1)
+      if ((i = __write (ct->ct_sock, buf, cnt)) == -1)
 	{
 	  ct->ct_error.re_errno = errno;
 	  ct->ct_error.re_status = RPC_CANTSEND;

libc/inet/rpc/clnt_udp.c

@@ -405,13 +405,13 @@ send_again:
 	  msg.msg_controllen = 256;
 	  ret = recvmsg (cu->cu_sock, &msg, MSG_ERRQUEUE);
 	  if (ret >= 0
-	      && memcmp (cbuf + 256, cu->cu_outbuf, ret) == 0
+	      && __memcmp (cbuf + 256, cu->cu_outbuf, ret) == 0
 	      && (msg.msg_flags & MSG_ERRQUEUE)
 	      && ((msg.msg_namelen == 0
 		   && ret >= 12)
 		  || (msg.msg_namelen == sizeof (err_addr)
 		      && err_addr.sin_family == AF_INET
-		      && memcmp (&err_addr.sin_addr, &cu->cu_raddr.sin_addr,
+		      && __memcmp (&err_addr.sin_addr, &cu->cu_raddr.sin_addr,
 				 sizeof (err_addr.sin_addr)) == 0
 		      && err_addr.sin_port == cu->cu_raddr.sin_port)))
 	    for (cmsg = CMSG_FIRSTHDR (&msg); cmsg;
@@ -606,7 +606,7 @@ clntudp_destroy (CLIENT *cl)
 
   if (cu->cu_closeit)
     {
-      (void) close (cu->cu_sock);
+      (void) __close (cu->cu_sock);
     }
   XDR_DESTROY (&(cu->cu_outxdrs));
   mem_free ((caddr_t) cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));

libc/inet/rpc/clnt_unix.c

@@ -149,7 +149,7 @@ clntunix_create (struct sockaddr_un *raddr, u_long prog, u_long vers,
   if (*sockp < 0)
     {
       *sockp = socket (AF_UNIX, SOCK_STREAM, 0);
-      len = strlen (raddr->sun_path) + sizeof (raddr->sun_family) + 1;
+      len = __strlen (raddr->sun_path) + sizeof (raddr->sun_family) + 1;
       if (*sockp < 0
 	  || connect (*sockp, (struct sockaddr *) raddr, len) < 0)
 	{
@@ -157,7 +157,7 @@ clntunix_create (struct sockaddr_un *raddr, u_long prog, u_long vers,
 	  ce->cf_stat = RPC_SYSTEMERROR;
 	  ce->cf_error.re_errno = errno;
 	  if (*sockp != -1)
-	    close (*sockp);
+	    __close (*sockp);
 	  goto fooy;
 	}
       ct->ct_closeit = TRUE;
@@ -191,7 +191,7 @@ clntunix_create (struct sockaddr_un *raddr, u_long prog, u_long vers,
   if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
     {
       if (ct->ct_closeit)
-	close (*sockp);
+	__close (*sockp);
       goto fooy;
     }
   ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
@@ -437,7 +437,7 @@ clntunix_destroy (CLIENT *h)
 
   if (ct->ct_closeit)
     {
-      (void) close (ct->ct_sock);
+      (void) __close (ct->ct_sock);
     }
   XDR_DESTROY (&(ct->ct_xdrs));
   mem_free ((caddr_t) ct, sizeof (struct ct_data));
@@ -510,7 +510,7 @@ __msgwrite (int sock, void *data, size_t cnt)
   cred.uid = geteuid ();
   cred.gid = getegid ();
 
-  memcpy (CMSG_DATA(cmsg), &cred, sizeof (struct ucred));
+  __memcpy (CMSG_DATA(cmsg), &cred, sizeof (struct ucred));
   cmsg->cmsg_level = SOL_SOCKET;
   cmsg->cmsg_type = SCM_CREDENTIALS;
   cmsg->cmsg_len = sizeof(*cmsg) + sizeof(struct ucred);

libc/inet/rpc/get_myaddress.c

@@ -94,7 +94,7 @@ get_myaddress (struct sockaddr_in *addr)
 	{
 	  *addr = *((struct sockaddr_in *) &ifr->ifr_addr);
 	  addr->sin_port = htons (PMAPPORT);
-	  close (s);
+	  __close (s);
 	  return;
 	}
       ifr++;
@@ -104,5 +104,5 @@ get_myaddress (struct sockaddr_in *addr)
       loopback = 1;
       goto again;
     }
-  close (s);
+  __close (s);
 }

libc/inet/rpc/getrpcent.c

@@ -96,10 +96,10 @@ struct rpcent *getrpcbyname(const char *name)
 
 	setrpcent(0);
 	while ((rpc = getrpcent())) {
-		if (strcmp(rpc->r_name, name) == 0)
+		if (__strcmp(rpc->r_name, name) == 0)
 			return rpc;
 		for (rp = rpc->r_aliases; *rp != NULL; rp++) {
-			if (strcmp(*rp, name) == 0)
+			if (__strcmp(*rp, name) == 0)
 				return rpc;
 		}
 	}
@@ -166,8 +166,8 @@ static char *firstwhite(char *s)
 {
 	char *s1, *s2;
 
-	s1 = strchr(s, ' ');
-	s2 = strchr(s, '\t');
+	s1 = __strchr(s, ' ');
+	s2 = __strchr(s, '\t');
 	if (s1) {
 		if (s2)
 			return (s1 < s2) ? s1 : s2;
@@ -184,12 +184,12 @@ static struct rpcent *interpret(register struct rpcdata *d)
 	register char *cp, **q;
 
 	p = d->line;
-	d->line[strlen(p)-1] = '\n';
+	d->line[__strlen(p)-1] = '\n';
 	if (*p == '#')
 		return __get_next_rpcent(d);
-	cp = strchr(p, '#');
+	cp = __strchr(p, '#');
 	if (cp == NULL) {
-		cp = strchr(p, '\n');
+		cp = __strchr(p, '\n');
 		if (cp == NULL)
 			return __get_next_rpcent(d);
 	}
@@ -200,9 +200,9 @@ static struct rpcent *interpret(register struct rpcdata *d)
 	else
 		return __get_next_rpcent(d);
 #else
-	cp = strchr(p, ' ');
+	cp = __strchr(p, ' ');
 	if (cp == NULL) {
-		cp = strchr(p, '\t');
+		cp = __strchr(p, '\t');
 		if (cp == NULL)
 			return __get_next_rpcent(d);
 	}
@@ -218,11 +218,11 @@ static struct rpcent *interpret(register struct rpcdata *d)
 	if ((cp = firstwhite(cp)))
 		*cp++ = '\0';
 #else
-	cp = strchr(p, ' ');
+	cp = __strchr(p, ' ');
 	if (cp != NULL)
 		*cp++ = '\0';
 	else {
-		cp = strchr(p, '\t');
+		cp = __strchr(p, '\t');
 		if (cp != NULL)
 			*cp++ = '\0';
 	}
@@ -238,11 +238,11 @@ static struct rpcent *interpret(register struct rpcdata *d)
 		if ((cp = firstwhite(cp)))
 			*cp++ = '\0';
 #else
-		cp = strchr(p, ' ');
+		cp = __strchr(p, ' ');
 		if (cp != NULL)
 			*cp++ = '\0';
 		else {
-			cp = strchr(p, '\t');
+			cp = __strchr(p, '\t');
 			if (cp != NULL)
 				*cp++ = '\0';
 		}
@@ -275,8 +275,8 @@ static int __copy_rpcent(struct rpcent *r, struct rpcent *result_buf, char *buff
 		return ENOENT;
 
 	/* copy the struct from the shared mem */
-	memset(result_buf, 0x00, sizeof(*result_buf));
-	memset(buffer, 0x00, buflen);
+	__memset(result_buf, 0x00, sizeof(*result_buf));
+	__memset(buffer, 0x00, buflen);
 
 	result_buf->r_number = r->r_number;
 
@@ -293,21 +293,21 @@ static int __copy_rpcent(struct rpcent *r, struct rpcent *result_buf, char *buff
 	buflen -= s;
 
 	while (i-- > 0) {
-		s = strlen(r->r_aliases[i]) + 1;
+		s = __strlen(r->r_aliases[i]) + 1;
 		if (buflen < s)
 			goto err_out;
 		result_buf->r_aliases[i] = buffer;
 		buffer += s;
 		buflen -= s;
-		memcpy(result_buf->r_aliases[i], r->r_aliases[i], s);
+		__memcpy(result_buf->r_aliases[i], r->r_aliases[i], s);
 	}
 
 	/* copy the name */
-	i = strlen(r->r_name);
+	i = __strlen(r->r_name);
 	if (buflen <= i)
 		goto err_out;
 	result_buf->r_name = buffer;
-	memcpy(result_buf->r_name, r->r_name, i);
+	__memcpy(result_buf->r_name, r->r_name, i);
 
 	/* that was a hoot eh ? */
 	*result = result_buf;

libc/inet/rpc/getrpcport.c

@@ -70,7 +70,7 @@ getrpcport (const char *host, u_long prognum, u_long versnum, u_int proto)
 	buffer = alloca (buflen);
       }
 
-  memcpy ((char *) &addr.sin_addr, hp->h_addr, hp->h_length);
+  __memcpy ((char *) &addr.sin_addr, hp->h_addr, hp->h_length);
   addr.sin_family = AF_INET;
   addr.sin_port = 0;
   return pmap_getport (&addr, prognum, versnum, proto);

libc/inet/rpc/pmap_clnt.c

@@ -90,7 +90,7 @@ __get_myaddress (struct sockaddr_in *addr)
         {
           *addr = *((struct sockaddr_in *) &ifr->ifr_addr);
           addr->sin_port = htons (PMAPPORT);
-          close (s);
+          __close (s);
           return TRUE;
         }
       ifr++;
@@ -100,7 +100,7 @@ __get_myaddress (struct sockaddr_in *addr)
       loopback = 0;
       goto again;
     }
-  close (s);
+  __close (s);
   return FALSE;
 }
 
@@ -139,7 +139,7 @@ pmap_set (u_long program, u_long version, int protocol, u_short port)
       return FALSE;
     }
   CLNT_DESTROY (client);
-  /* (void)close(socket); CLNT_DESTROY closes it */
+  /* (void)__close(socket); CLNT_DESTROY closes it */
   return rslt;
 }
 
@@ -168,6 +168,6 @@ pmap_unset (u_long program, u_long version)
   CLNT_CALL (client, PMAPPROC_UNSET, (xdrproc_t)xdr_pmap, (caddr_t)&parms,
 	     (xdrproc_t)xdr_bool, (caddr_t)&rslt, tottimeout);
   CLNT_DESTROY (client);
-  /* (void)close(socket); CLNT_DESTROY already closed it */
+  /* (void)__close(socket); CLNT_DESTROY already closed it */
   return rslt;
 }

libc/inet/rpc/pmap_getmaps.c

@@ -74,7 +74,7 @@ pmap_getmaps (struct sockaddr_in *address)
 	}
       CLNT_DESTROY (client);
     }
-  /* (void)close(socket); CLNT_DESTROY already closed it */
+  /* (void)__close(socket); CLNT_DESTROY already closed it */
   address->sin_port = 0;
   return head;
 }

libc/inet/rpc/pmap_getport.c

@@ -88,7 +88,7 @@ pmap_getport (address, program, version, protocol)
 	}
       CLNT_DESTROY (client);
     }
-  /* (void)close(socket); CLNT_DESTROY already closed it */
+  /* (void)__close(socket); CLNT_DESTROY already closed it */
   address->sin_port = 0;
   return port;
 }

libc/inet/rpc/pmap_rmt.c

@@ -40,6 +40,7 @@ static char sccsid[] = "@(#)pmap_rmt.c 1.21 87/08/27 Copyr 1984 Sun Micro";
  */
 
 #define authunix_create_default __authunix_create_default
+#define inet_makeaddr __inet_makeaddr
 
 #define __FORCE_GLIBC
 #include <features.h>
@@ -281,7 +282,7 @@ clnt_broadcast (prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
   fd.fd = sock;
   fd.events = POLLIN;
   nets = getbroadcastnets (addrs, sock, inbuf);
-  memset ((char *) &baddr, 0, sizeof (baddr));
+  __memset ((char *) &baddr, 0, sizeof (baddr));
   baddr.sin_family = AF_INET;
   baddr.sin_port = htons (PMAPPORT);
   baddr.sin_addr.s_addr = htonl (INADDR_ANY);
@@ -409,7 +410,7 @@ clnt_broadcast (prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
 	}
     }
 done_broad:
-  (void) close (sock);
+  (void) __close (sock);
   AUTH_DESTROY (unix_auth);
   return stat;
 }

libc/inet/rpc/rcmd.c

@@ -155,7 +155,7 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 		sin.sin_port = rport;
 		if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0) /* __connect */
 			break;
-		(void)close(s); /* __close */
+		(void)__close(s);
 		if (errno == EADDRINUSE) {
 			lport--;
 			continue;
@@ -185,7 +185,7 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 	}
 	lport--;
 	if (fd2p == 0) {
-		write(s, "", 1); /* __write */		    
+		__write(s, "", 1);
 		lport = 0;
 	} else {
 		char num[8];
@@ -196,10 +196,10 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 			goto bad;
 		listen(s2, 1);
 		(void)snprintf(num, sizeof(num), "%d", lport); /* __snprintf */
-		if (write(s, num, strlen(num)+1) != strlen(num)+1) {
+		if (__write(s, num, __strlen(num)+1) != __strlen(num)+1) {
 			(void)fprintf(stderr,
 				      "rcmd: write (setting up stderr): %m\n");
-			(void)close(s2); /* __close */
+			(void)__close(s2);
 			goto bad;
 		}
 		pfd[0].fd = s;
@@ -210,11 +210,11 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 			(void)fprintf(stderr, "rcmd: poll (setting up stderr): %m\n");
 		    else
 			(void)fprintf(stderr, "poll: protocol failure in circuit setup\n");
-			(void)close(s2);
+			(void)__close(s2);
 			goto bad;
 		}
 		s3 = accept(s2, (struct sockaddr *)&from, &len);
-		(void)close(s2);
+		(void)__close(s2);
 		if (s3 < 0) {
 			(void)fprintf(stderr,
 			    "rcmd: accept: %m\n");
@@ -231,17 +231,17 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 			goto bad2;
 		}
 	}
-	(void)write(s, locuser, strlen(locuser)+1);
-	(void)write(s, remuser, strlen(remuser)+1);
-	(void)write(s, cmd, strlen(cmd)+1);
-	if (read(s, &c, 1) != 1) {
+	(void)__write(s, locuser, __strlen(locuser)+1);
+	(void)__write(s, remuser, __strlen(remuser)+1);
+	(void)__write(s, cmd, __strlen(cmd)+1);
+	if (__read(s, &c, 1) != 1) {
 		(void)fprintf(stderr,
 		    "rcmd: %s: %m\n", *ahost);
 		goto bad2;
 	}
 	if (c != 0) {
-		while (read(s, &c, 1) == 1) {
-			(void)write(STDERR_FILENO, &c, 1);
+		while (__read(s, &c, 1) == 1) {
+			(void)__write(STDERR_FILENO, &c, 1);
 			if (c == '\n')
 				break;
 		}
@@ -251,9 +251,9 @@ int rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 	return s;
 bad2:
 	if (lport)
-		(void)close(*fd2p);
+		(void)__close(*fd2p);
 bad:
-	(void)close(s);
+	(void)__close(s);
 	sigsetmask(oldmask);
 	return -1;
 }
@@ -273,12 +273,12 @@ int rresvport(int *alport)
 	if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
 	    return s;
 	if (errno != EADDRINUSE) {
-	    (void)close(s);
+	    (void)__close(s);
 	    return -1;
 	}
 	(*alport)--;
 	if (*alport == IPPORT_RESERVED/2) {
-	    (void)close(s);
+	    (void)__close(s);
 	    __set_errno (EAGAIN);		/* close */
 	    return -1;
 	}
@@ -455,10 +455,10 @@ iruserok2 (raddr, superuser, ruser, luser, rhost)
 			return -1;
 #endif
 
-		dirlen = strlen (pwd->pw_dir);
+		dirlen = __strlen (pwd->pw_dir);
 		pbuf = malloc (dirlen + sizeof "/.rhosts");
-		strcpy (pbuf, pwd->pw_dir);
-		strcat (pbuf, "/.rhosts");
+		__strcpy (pbuf, pwd->pw_dir);
+		__strcat (pbuf, "/.rhosts");
 
 		/* Change effective uid while reading .rhosts.  If root and
 		   reading an NFS mounted file system, can't read files that
@@ -523,18 +523,18 @@ __icheckhost (u_int32_t raddr, char *lhost, const char *rhost)
 
 #ifdef HAVE_NETGROUP
 	/* Check nis netgroup.  */
-	if (strncmp ("+@", lhost, 2) == 0)
+	if (__strncmp ("+@", lhost, 2) == 0)
 		return innetgr (&lhost[2], rhost, NULL, NULL);
 
-	if (strncmp ("-@", lhost, 2) == 0)
+	if (__strncmp ("-@", lhost, 2) == 0)
 		return -innetgr (&lhost[2], rhost, NULL, NULL);
 #endif /* HAVE_NETGROUP */
 
 	/* -host */
-	if (strncmp ("-", lhost,1) == 0) {
+	if (__strncmp ("-", lhost,1) == 0) {
 		negate = -1;
 		lhost++;
-	} else if (strcmp ("+",lhost) == 0) {
+	} else if (__strcmp ("+",lhost) == 0) {
 		return 1;                    /* asking for trouble, but ok.. */
 	}
 
@@ -564,7 +564,7 @@ __icheckhost (u_int32_t raddr, char *lhost, const char *rhost)
 
 	/* Spin through ip addresses. */
 	for (pp = hp->h_addr_list; *pp; ++pp)
-		if (!memcmp (&raddr, *pp, sizeof (u_int32_t)))
+		if (!__memcmp (&raddr, *pp, sizeof (u_int32_t)))
 			return negate;
 
 	/* No match. */
@@ -583,23 +583,23 @@ __icheckuser (const char *luser, const char *ruser)
 
 #ifdef HAVE_NETGROUP
     /* [-+]@netgroup */
-    if (strncmp ("+@", luser, 2) == 0)
+    if (__strncmp ("+@", luser, 2) == 0)
 	return innetgr (&luser[2], NULL, ruser, NULL);
 
-    if (strncmp ("-@", luser,2) == 0)
+    if (__strncmp ("-@", luser,2) == 0)
 	return -innetgr (&luser[2], NULL, ruser, NULL);
 #endif /* HAVE_NETGROUP */
 
     /* -user */
-    if (strncmp ("-", luser, 1) == 0)
-	return -(strcmp (&luser[1], ruser) == 0);
+    if (__strncmp ("-", luser, 1) == 0)
+	return -(__strcmp (&luser[1], ruser) == 0);
 
     /* + */
-    if (strcmp ("+", luser) == 0)
+    if (__strcmp ("+", luser) == 0)
 	return 1;
 
     /* simple string match */
-    return strcmp (ruser, luser) == 0;
+    return __strcmp (ruser, luser) == 0;
 }
 
 /*
@@ -641,7 +641,7 @@ __ivaliduser2(hostf, raddr, luser, ruser, rhost)
 	}
 
 	/* Skip lines that are too long. */
-	if (strchr (p, '\n') == NULL) {
+	if (__strchr (p, '\n') == NULL) {
 	    int ch = getc_unlocked (hostf);
 
 	    while (ch != '\n' && ch != EOF)

libc/inet/rpc/rexec.c

@@ -70,7 +70,7 @@ rexec_af(ahost, rport, name, pass, cmd, fd2p, af)
 	snprintf(servbuff, sizeof(servbuff), "%d", ntohs(rport));
 	servbuff[sizeof(servbuff) - 1] = '\0';
 
-	memset(&hints, 0, sizeof(hints));
+	__memset(&hints, 0, sizeof(hints));
 	hints.ai_family = af;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_flags = AI_CANONNAME;
@@ -81,7 +81,7 @@ rexec_af(ahost, rport, name, pass, cmd, fd2p, af)
 	}
 
 	if (res0->ai_canonname){
-		strncpy(ahostbuf, res0->ai_canonname, sizeof(ahostbuf));
+		__strncpy(ahostbuf, res0->ai_canonname, sizeof(ahostbuf));
 		ahostbuf[sizeof(ahostbuf)-1] = '\0';
 		*ahost = ahostbuf;
 	}
@@ -97,7 +97,7 @@ retry:
 	}
 	if (connect(s, res0->ai_addr, res0->ai_addrlen) < 0) {
 		if (errno == ECONNREFUSED && timo <= 16) {
-			(void) close(s);
+			(void) __close(s);
 			sleep(timo);
 			timo *= 2;
 			goto retry;
@@ -106,7 +106,7 @@ retry:
 		return (-1);
 	}
 	if (fd2p == 0) {
-		(void) write(s, "", 1);
+		(void) __write(s, "", 1);
 		port = 0;
 	} else {
 		char num[32];
@@ -114,18 +114,18 @@ retry:
 
 		s2 = socket(res0->ai_family, res0->ai_socktype, 0);
 		if (s2 < 0) {
-			(void) close(s);
+			(void) __close(s);
 			return (-1);
 		}
 		listen(s2, 1);
 		sa2len = sizeof (sa2);
 		if (getsockname(s2, (struct sockaddr *)&sa2, &sa2len) < 0) {
 			perror("getsockname");
-			(void) close(s2);
+			(void) __close(s2);
 			goto bad;
 		} else if (sa2len != SA_LEN((struct sockaddr *)&sa2)) {
 			__set_errno(EINVAL);
-			(void) close(s2);
+			(void) __close(s2);
 			goto bad;
 		}
 		port = 0;
@@ -134,10 +134,10 @@ retry:
 				 NI_NUMERICSERV))
 			port = atoi(servbuff);
 		(void) sprintf(num, "%u", port);
-		(void) write(s, num, strlen(num)+1);
+		(void) __write(s, num, __strlen(num)+1);
 		{ socklen_t len = sizeof (from);
 		  s3 = accept(s2, (struct sockaddr *)&from, &len);
-		  close(s2);
+		  __close(s2);
 		  if (s3 < 0) {
 			perror("accept");
 			port = 0;
@@ -146,10 +146,10 @@ retry:
 		}
 		*fd2p = s3;
 	}
-	(void) write(s, name, strlen(name) + 1);
+	(void) __write(s, name, __strlen(name) + 1);
 	/* should public key encypt the password here */
-	(void) write(s, pass, strlen(pass) + 1);
-	(void) write(s, cmd, strlen(cmd) + 1);
+	(void) __write(s, pass, __strlen(pass) + 1);
+	(void) __write(s, cmd, __strlen(cmd) + 1);
 
 	/* We don't need the memory allocated for the name and the password
 	   in ruserpass anymore.  */
@@ -158,13 +158,13 @@ retry:
 	if (pass != orig_pass)
 	  free ((char *) pass);
 
-	if (read(s, &c, 1) != 1) {
+	if (__read(s, &c, 1) != 1) {
 		perror(*ahost);
 		goto bad;
 	}
 	if (c != 0) {
-		while (read(s, &c, 1) == 1) {
-			(void) write(2, &c, 1);
+		while (__read(s, &c, 1) == 1) {
+			(void) __write(2, &c, 1);
 			if (c == '\n')
 				break;
 		}
@@ -174,8 +174,8 @@ retry:
 	return (s);
 bad:
 	if (port)
-		(void) close(*fd2p);
-	(void) close(s);
+		(void) __close(*fd2p);
+	(void) __close(s);
 	freeaddrinfo(res0);
 	return (-1);
 }

libc/inet/rpc/rpc_callmsg.c

@@ -85,7 +85,7 @@ xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg)
 	  IXDR_PUT_INT32 (buf, oa->oa_length);
 	  if (oa->oa_length)
 	    {
-	      memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
+	      __memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
 	      buf = (int32_t *) ((char *) buf + RNDUP (oa->oa_length));
 	    }
 	  oa = &cmsg->rm_call.cb_verf;
@@ -93,7 +93,7 @@ xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg)
 	  IXDR_PUT_INT32 (buf, oa->oa_length);
 	  if (oa->oa_length)
 	    {
-	      memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
+	      __memcpy ((caddr_t) buf, oa->oa_base, oa->oa_length);
 	      /* no real need....
 	         buf = (long *) ((char *) buf + RNDUP(oa->oa_length));
 	       */
@@ -141,7 +141,7 @@ xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg)
 		}
 	      else
 		{
-		  memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
+		  __memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
 		  /* no real need....
 		     buf = (long *) ((char *) buf
 		     + RNDUP(oa->oa_length));
@@ -181,7 +181,7 @@ xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg)
 		}
 	      else
 		{
-		  memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
+		  __memcpy (oa->oa_base, (caddr_t) buf, oa->oa_length);
 		  /* no real need...
 		     buf = (long *) ((char *) buf
 		     + RNDUP(oa->oa_length));

libc/inet/rpc/rtime.c

@@ -68,7 +68,7 @@ do_close (int s)
   int save;
 
   save = errno;
-  close (s);
+  __close (s);
   __set_errno (save);
 }
 
@@ -132,7 +132,7 @@ rtime (struct sockaddr_in *addrp, struct rpc_timeval *timep,
 	  do_close (s);
 	  return -1;
 	}
-      res = read (s, (char *) &thetime, sizeof (thetime));
+      res = __read (s, (char *) &thetime, sizeof (thetime));
       do_close (s);
       if (res < 0)
 	return (-1);

libc/inet/rpc/ruserpass.c

@@ -112,9 +112,9 @@ int ruserpass(const char *host, const char **aname, const char **apass)
 	  	return -1;
 	}
 
-	buf = alloca (strlen(hdir) + 8);
-	strcpy(buf, hdir);
-	strcat(buf, "/.netrc");
+	buf = alloca (__strlen(hdir) + 8);
+	__strcpy(buf, hdir);
+	__strcat(buf, "/.netrc");
 	cfile = fopen(buf, "r");
 	if (cfile == NULL) {
 		if (errno != ENOENT)
@@ -127,9 +127,9 @@ int ruserpass(const char *host, const char **aname, const char **apass)
 #endif
 	if (gethostname(myname, sizeof(myname)) < 0)
 		myname[0] = '\0';
-	mydomain = strchr(myname, '.');
+	mydomain = __strchr(myname, '.');
 	if (mydomain==NULL) {
-	    mydomain=myname + strlen(myname);
+	    mydomain=myname + __strlen(myname);
 	}
 next:
 	while ((t = token())) switch(t) {
@@ -151,12 +151,12 @@ next:
 				goto match;
 /*			if (__strcasecmp(hostname, tokval) == 0)
 				goto match;
-			if ((tmp = strchr(hostname, '.')) != NULL &&
+			if ((tmp = __strchr(hostname, '.')) != NULL &&
 			    __strcasecmp(tmp, mydomain) == 0 &&
 			    __strncasecmp(hostname, tokval, tmp-hostname) == 0 &&
 			    tokval[tmp - hostname] == '\0')
 				goto match; */
-			if ((tmp = strchr(host, '.')) != NULL &&
+			if ((tmp = __strchr(host, '.')) != NULL &&
 			    strcasecmp(tmp, mydomain) == 0 &&
 			    strncasecmp(host, tokval, tmp - host) == 0 &&
 			    tokval[tmp - host] == '\0')
@@ -170,21 +170,21 @@ next:
 			if (token()) {
 				if (*aname == 0) {
 				  char *newp;
-				  newp = malloc((unsigned) strlen(tokval) + 1);
+				  newp = malloc((unsigned) __strlen(tokval) + 1);
 				  if (newp == NULL)
 				    {
 				      printf(_("out of memory"));
 				      goto bad;
 				    }
-				  *aname = strcpy(newp, tokval);
+				  *aname = __strcpy(newp, tokval);
 				} else {
-					if (strcmp(*aname, tokval))
+					if (__strcmp(*aname, tokval))
 						goto next;
 				}
 			}
 			break;
 		case PASSWD:
-			if (strcmp(*aname, "anonymous") &&
+			if (__strcmp(*aname, "anonymous") &&
 			    fstat(fileno(cfile), &stb) >= 0 &&
 			    (stb.st_mode & 077) != 0) {
 	printf(_("Error: .netrc file is readable by others."));
@@ -193,13 +193,13 @@ next:
 			}
 			if (token() && *apass == 0) {
 				char *newp;
-				newp = malloc((unsigned) strlen(tokval) + 1);
+				newp = malloc((unsigned) __strlen(tokval) + 1);
 				if (newp == NULL)
 				  {
 				    printf(_("out of memory"));
 				    goto bad;
 				  }
-				*apass = strcpy(newp, tokval);
+				*apass = __strcpy(newp, tokval);
 			}
 			break;
 		case ACCOUNT:
@@ -211,8 +211,8 @@ next:
 				goto bad;
 			}
 			if (token() && *aacct == 0) {
-				*aacct = malloc((unsigned) strlen(tokval) + 1);
-				(void) strcpy(*aacct, tokval);
+				*aacct = malloc((unsigned) __strlen(tokval) + 1);
+				(void) __strcpy(*aacct, tokval);
 			}
 #endif
 			break;
@@ -327,7 +327,7 @@ token()
 	if (tokval[0] == 0)
 		return (0);
 	for (i = 0; i < (int) (sizeof (toktab) / sizeof (toktab[0])); ++i)
-		if (!strcmp(&tokstr[toktab[i].tokstr_off], tokval))
+		if (!__strcmp(&tokstr[toktab[i].tokstr_off], tokval))
 			return toktab[i].tval;
 	return (ID);
 }

libc/inet/rpc/svc_auth_unix.c

@@ -84,7 +84,7 @@ _svcauth_unix (struct svc_req *rqst, struct rpc_msg *msg)
 	  stat = AUTH_BADCRED;
 	  goto done;
 	}
-      memcpy (aup->aup_machname, (caddr_t) buf, (u_int) str_len);
+      __memcpy (aup->aup_machname, (caddr_t) buf, (u_int) str_len);
       aup->aup_machname[str_len] = 0;
       str_len = RNDUP (str_len);
       buf = (int32_t *) ((char *) buf + str_len);

libc/inet/rpc/svc_simple.c

@@ -96,7 +96,7 @@ registerrpc (u_long prognum, u_long versnum, u_long procnum,
       transp = svcudp_create (RPC_ANYSOCK);
       if (transp == NULL)
 	{
-	  buf = strdup (_("couldn't create an rpc server\n"));
+	  buf = __strdup (_("couldn't create an rpc server\n"));
 	  goto err_out;
 	}
     }
@@ -111,7 +111,7 @@ registerrpc (u_long prognum, u_long versnum, u_long procnum,
   pl = (struct proglst_ *) malloc (sizeof (struct proglst_));
   if (pl == NULL)
     {
-      buf = strdup (_("registerrpc: out of memory\n"));
+      buf = __strdup (_("registerrpc: out of memory\n"));
       goto err_out;
     }
   pl->p_progname = progname;
@@ -150,7 +150,7 @@ universal (struct svc_req *rqstp, SVCXPRT *transp_l)
     {
       if (svc_sendreply (transp_l, (xdrproc_t)xdr_void, (char *) NULL) == FALSE)
 	{
-	  write (STDERR_FILENO, "xxx\n", 4);
+	  __write (STDERR_FILENO, "xxx\n", 4);
 	  exit (1);
 	}
       return;
@@ -161,7 +161,7 @@ universal (struct svc_req *rqstp, SVCXPRT *transp_l)
     if (pl->p_prognum == prog && pl->p_procnum == proc)
       {
 	/* decode arguments into a CLEAN buffer */
-	memset (xdrbuf, 0, sizeof (xdrbuf));	/* required ! */
+	__memset (xdrbuf, 0, sizeof (xdrbuf));	/* required ! */
 	if (!svc_getargs (transp_l, pl->p_inproc, xdrbuf))
 	  {
 	    svcerr_decode (transp_l);

libc/inet/rpc/svc_tcp.c

@@ -164,7 +164,7 @@ svctcp_create (int sock, u_int sendsize, u_int recvsize)
 	}
       madesock = TRUE;
     }
-  memset ((char *) &addr, 0, sizeof (addr));
+  __memset ((char *) &addr, 0, sizeof (addr));
   addr.sin_family = AF_INET;
   if (bindresvport (sock, &addr))
     {
@@ -176,7 +176,7 @@ svctcp_create (int sock, u_int sendsize, u_int recvsize)
     {
       perror (_("svc_tcp.c - cannot getsockname or listen"));
       if (madesock)
-	(void) close (sock);
+	(void) __close (sock);
       return (SVCXPRT *) NULL;
     }
   r = (struct tcp_rendezvous *) mem_alloc (sizeof (*r));
@@ -272,7 +272,7 @@ again:
    * make a new transporter (re-uses xprt)
    */
   xprt = makefd_xprt (sock, r->sendsize, r->recvsize);
-  memcpy (&xprt->xp_raddr, &addr, sizeof (addr));
+  __memcpy (&xprt->xp_raddr, &addr, sizeof (addr));
   xprt->xp_addrlen = len;
   return FALSE;		/* there is never an rpc msg to be processed */
 }
@@ -289,7 +289,7 @@ svctcp_destroy (SVCXPRT *xprt)
   struct tcp_conn *cd = (struct tcp_conn *) xprt->xp_p1;
 
   xprt_unregister (xprt);
-  (void) close (xprt->xp_sock);
+  (void) __close (xprt->xp_sock);
   if (xprt->xp_port != 0)
     {
       /* a rendezvouser socket */
@@ -339,7 +339,7 @@ readtcp (char *xprtptr, char *buf, int len)
     }
   while ((pollfd.revents & POLLIN) == 0);
 
-  if ((len = read (sock, buf, len)) > 0)
+  if ((len = __read (sock, buf, len)) > 0)
     return len;
 
  fatal_err:
@@ -359,7 +359,7 @@ writetcp (char *xprtptr, char * buf, int len)
 
   for (cnt = len; cnt > 0; cnt -= i, buf += i)
     {
-      if ((i = write (xprt->xp_sock, buf, cnt)) < 0)
+      if ((i = __write (xprt->xp_sock, buf, cnt)) < 0)
 	{
 	  ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
 	  return -1;

libc/inet/rpc/svc_udp.c

@@ -136,7 +136,7 @@ svcudp_bufcreate (sock, sendsz, recvsz)
 	}
       madesock = TRUE;
     }
-  memset ((char *) &addr, 0, sizeof (addr));
+  __memset ((char *) &addr, 0, sizeof (addr));
   addr.sin_family = AF_INET;
   if (bindresvport (sock, &addr))
     {
@@ -147,7 +147,7 @@ svcudp_bufcreate (sock, sendsz, recvsz)
     {
       perror (_("svcudp_create - cannot getsockname"));
       if (madesock)
-	(void) close (sock);
+	(void) __close (sock);
       return (SVCXPRT *) NULL;
     }
   xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
@@ -200,7 +200,7 @@ svcudp_bufcreate (sock, sendsz, recvsz)
 #endif
     /* Clear the padding. */
     pad = 0;
-  memset (&xprt->xp_pad [0], pad, sizeof (xprt->xp_pad));
+  __memset (&xprt->xp_pad [0], pad, sizeof (xprt->xp_pad));
 
   xprt_register (xprt);
   return xprt;
@@ -375,7 +375,7 @@ svcudp_destroy (xprt)
   struct svcudp_data *su = su_data (xprt);
 
   xprt_unregister (xprt);
-  (void) close (xprt->xp_sock);
+  (void) __close (xprt->xp_sock);
   XDR_DESTROY (&(su->su_xdrs));
   mem_free (rpc_buffer (xprt), su->su_iosz);
   mem_free ((caddr_t) su, sizeof (struct svcudp_data));
@@ -408,7 +408,7 @@ svcudp_destroy (xprt)
 	(type *) mem_alloc((unsigned) (sizeof(type) * (size)))
 
 #define BZERO(addr, type, size)	 \
-	memset((char *) addr, 0, sizeof(type) * (int) (size))
+	__memset((char *) addr, 0, sizeof(type) * (int) (size))
 
 /*
  * An entry in the cache
@@ -586,7 +586,7 @@ cache_get (xprt, msg, replyp, replylenp)
   struct svcudp_data *su = su_data (xprt);
   struct udp_cache *uc = (struct udp_cache *) su->su_cache;
 
-#define EQADDR(a1, a2)	(memcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
+#define EQADDR(a1, a2)	(__memcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
 
   loc = CACHE_LOC (xprt, su->su_xid);
   for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next)
@@ -609,6 +609,6 @@ cache_get (xprt, msg, replyp, replylenp)
   uc->uc_proc = msg->rm_call.cb_proc;
   uc->uc_vers = msg->rm_call.cb_vers;
   uc->uc_prog = msg->rm_call.cb_prog;
-  memcpy (&uc->uc_addr, &xprt->xp_raddr, sizeof (uc->uc_addr));
+  __memcpy (&uc->uc_addr, &xprt->xp_raddr, sizeof (uc->uc_addr));
   return 0;
 }

libc/inet/rpc/svc_unix.c

@@ -158,10 +158,10 @@ svcunix_create (int sock, u_int sendsize, u_int recvsize, char *path)
 	}
       madesock = TRUE;
     }
-  memset (&addr, '\0', sizeof (addr));
+  __memset (&addr, '\0', sizeof (addr));
   addr.sun_family = AF_UNIX;
-  len = strlen (path) + 1;
-  memcpy (addr.sun_path, path, len);
+  len = __strlen (path) + 1;
+  __memcpy (addr.sun_path, path, len);
   len += sizeof (addr.sun_family);
 
   bind (sock, (struct sockaddr *) &addr, len);
@@ -171,7 +171,7 @@ svcunix_create (int sock, u_int sendsize, u_int recvsize, char *path)
     {
       perror (_("svc_unix.c - cannot getsockname or listen"));
       if (madesock)
-	close (sock);
+	__close (sock);
       return (SVCXPRT *) NULL;
     }
 
@@ -268,10 +268,10 @@ again:
   /*
    * make a new transporter (re-uses xprt)
    */
-  memset (&in_addr, '\0', sizeof (in_addr));
+  __memset (&in_addr, '\0', sizeof (in_addr));
   in_addr.sin_family = AF_UNIX;
   xprt = makefd_xprt (sock, r->sendsize, r->recvsize);
-  memcpy (&xprt->xp_raddr, &in_addr, sizeof (in_addr));
+  __memcpy (&xprt->xp_raddr, &in_addr, sizeof (in_addr));
   xprt->xp_addrlen = len;
   return FALSE;		/* there is never an rpc msg to be processed */
 }
@@ -288,7 +288,7 @@ svcunix_destroy (SVCXPRT *xprt)
   struct unix_conn *cd = (struct unix_conn *) xprt->xp_p1;
 
   xprt_unregister (xprt);
-  close (xprt->xp_sock);
+  __close (xprt->xp_sock);
   if (xprt->xp_port != 0)
     {
       /* a rendezvouser socket */
@@ -380,7 +380,7 @@ __msgwrite (int sock, void *data, size_t cnt)
   cred.uid = geteuid ();
   cred.gid = getegid ();
 
-  memcpy (CMSG_DATA(cmsg), &cred, sizeof (struct ucred));
+  __memcpy (CMSG_DATA(cmsg), &cred, sizeof (struct ucred));
   cmsg->cmsg_level = SOL_SOCKET;
   cmsg->cmsg_type = SCM_CREDENTIALS;
   cmsg->cmsg_len = sizeof(*cmsg) + sizeof(struct ucred);

libc/inet/rpc/xdr.c

@@ -678,7 +678,7 @@ xdr_string (xdrs, cpp, maxsize)
     case XDR_ENCODE:
       if (sp == NULL)
 	return FALSE;
-      size = strlen (sp);
+      size = __strlen (sp);
       break;
     case XDR_DECODE:
       break;

libc/inet/rpc/xdr_array.c

@@ -117,7 +117,7 @@ xdr_array (xdrs, addrp, sizep, maxsize, elsize, elproc)
 	      (void) fputs (_("xdr_array: out of memory\n"), stderr);
 	    return FALSE;
 	  }
-	memset (target, 0, nodesize);
+	__memset (target, 0, nodesize);
 	break;
 
       case XDR_FREE:

libc/inet/rpc/xdr_mem.c

@@ -137,7 +137,7 @@ xdrmem_getbytes (XDR *xdrs, caddr_t addr, u_int len)
 {
   if ((xdrs->x_handy -= len) < 0)
     return FALSE;
-  memcpy (addr, xdrs->x_private, len);
+  __memcpy (addr, xdrs->x_private, len);
   xdrs->x_private += len;
   return TRUE;
 }
@@ -151,7 +151,7 @@ xdrmem_putbytes (XDR *xdrs, const char *addr, u_int len)
 {
   if ((xdrs->x_handy -= len) < 0)
     return FALSE;
-  memcpy (xdrs->x_private, addr, len);
+  __memcpy (xdrs->x_private, addr, len);
   xdrs->x_private += len;
   return TRUE;
 }

libc/inet/rpc/xdr_rec.c

@@ -297,7 +297,7 @@ xdrrec_putbytes (XDR *xdrs, const char *addr, u_int len)
     {
       current = rstrm->out_boundry - rstrm->out_finger;
       current = (len < current) ? len : current;
-      memcpy (rstrm->out_finger, addr, current);
+      __memcpy (rstrm->out_finger, addr, current);
       rstrm->out_finger += current;
       addr += current;
       len -= current;
@@ -599,7 +599,7 @@ get_input_bytes (RECSTREAM *rstrm, caddr_t addr, int len)
 	  continue;
 	}
       current = (len < current) ? len : current;
-      memcpy (addr, rstrm->in_finger, current);
+      __memcpy (addr, rstrm->in_finger, current);
       rstrm->in_finger += current;
       addr += current;
       len -= current;

libc/inet/rpc/xdr_reference.c

@@ -95,7 +95,7 @@ xdr_reference (xdrs, pp, size, proc)
 	      (void) fputs (_("xdr_reference: out of memory\n"), stderr);
 	    return FALSE;
 	  }
-	memset (loc, 0, (int) size);
+	__memset (loc, 0, (int) size);
 	break;
       default:
 	break;

libc/misc/dirent/alphasort.c

@@ -4,7 +4,7 @@
 
 int alphasort(const void * a, const void * b)
 {
-    return strcmp ((*(const struct dirent **) a)->d_name,
+    return __strcmp ((*(const struct dirent **) a)->d_name,
 	    (*(const struct dirent **) b)->d_name);
 }
 

libc/misc/dirent/alphasort64.c

@@ -19,7 +19,7 @@
 
 int alphasort64(const void * a, const void * b)
 {
-    return strcmp ((*(const struct dirent64 **) a)->d_name,
+    return __strcmp ((*(const struct dirent64 **) a)->d_name,
 	    (*(const struct dirent64 **) b)->d_name);
 }
 #endif /* __UCLIBC_HAS_LFS__ */

libc/misc/dirent/closedir.c

@@ -29,5 +29,5 @@ int closedir(DIR * dir)
 #endif
 	free(dir->dd_buf);
 	free(dir);
-	return close(fd);
+	return __close(fd);
 }

libc/misc/dirent/opendir.c

@@ -24,7 +24,7 @@ DIR *opendir(const char *name)
 		__set_errno(ENOTDIR);
 		return NULL;
 	}
-	if ((fd = open(name, O_RDONLY)) < 0)
+	if ((fd = __open(name, O_RDONLY)) < 0)
 		return NULL;
 	/* According to POSIX, directory streams should be closed when
 	 * exec. From "Anna Pluzhnikov" <besp@midway.uchicago.edu>.
@@ -32,7 +32,7 @@ DIR *opendir(const char *name)
 	if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0)
 		return NULL;
 	if (!(ptr = malloc(sizeof(*ptr)))) {
-		close(fd);
+		__close(fd);
 		__set_errno(ENOMEM);
 		return NULL;
 	}
@@ -45,7 +45,7 @@ DIR *opendir(const char *name)
 		ptr->dd_max = 512;
 
 	if (!(buf = calloc(1, ptr->dd_max))) {
-		close(fd);
+		__close(fd);
 		free(ptr);
 		__set_errno(ENOMEM);
 		return NULL;

libc/misc/dirent/readdir64_r.c

@@ -62,7 +62,7 @@ int readdir64_r(DIR *dir, struct dirent64 *entry, struct dirent64 **result)
 	if (de == NULL) {
 	    *result = NULL;
 	} else {
-	    *result = memcpy (entry, de, de->d_reclen);
+	    *result = __memcpy (entry, de, de->d_reclen);
 	}
 	ret = 0;
 

libc/misc/dirent/readdir_r.c

@@ -48,7 +48,7 @@ int readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
 	if (de == NULL) {
 	    *result = NULL;
 	} else {
-	    *result = memcpy (entry, de, de->d_reclen);
+	    *result = __memcpy (entry, de, de->d_reclen);
 	}
 	ret = 0;
 

libc/misc/dirent/scandir.c

@@ -72,7 +72,7 @@ int scandir(const char *dir, struct dirent ***namelist,
 	    if (vnew == NULL)
 		break;
 
-	    names[pos++] = (struct dirent *) memcpy (vnew, current, dsize);
+	    names[pos++] = (struct dirent *) __memcpy (vnew, current, dsize);
 	}
 
     if (unlikely(errno != 0))

libc/misc/dirent/scandir64.c

@@ -87,7 +87,7 @@ int scandir64(const char *dir, struct dirent64 ***namelist,
 	    if (vnew == NULL)
 		break;
 
-	    names[pos++] = (struct dirent64 *) memcpy (vnew, current, dsize);
+	    names[pos++] = (struct dirent64 *) __memcpy (vnew, current, dsize);
 	}
 
     if (unlikely(errno != 0))

libc/misc/error/error.c

@@ -70,7 +70,7 @@ void __error_at_line (int status, int errnum, const char *file_name,
 	static unsigned int old_line_number;
 
 	if (old_line_number == line_number &&
-		(file_name == old_file_name || !strcmp (old_file_name, file_name)))
+		(file_name == old_file_name || !__strcmp (old_file_name, file_name)))
 	    /* Simply return and print nothing.  */
 	    return;
 

libc/misc/file/lockf.c

@@ -28,7 +28,7 @@ int lockf (int fd, int cmd, off_t len)
 {
     struct flock fl;
 
-    memset ((char *) &fl, '\0', sizeof (fl));
+    __memset ((char *) &fl, '\0', sizeof (fl));
 
     /* lockf is always relative to the current file position.  */
     fl.l_whence = SEEK_CUR;

libc/misc/file/lockf64.c

@@ -62,7 +62,7 @@ int lockf64 (int fd, int cmd, off64_t len64)
 	return -1;
     }
 
-    memset((char *) &fl, '\0', sizeof (fl));
+    __memset((char *) &fl, '\0', sizeof (fl));
 
     /* lockf is always relative to the current file position.  */
     fl.l_whence = SEEK_CUR;

libc/misc/ftw/ftw.c

@@ -18,7 +18,10 @@
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#define mempcpy __libc_mempcpy
+/* used by D_EXACT_NAMLEN */
+#define strlen __strlen
+
+#define mempcpy __mempcpy
 #define tsearch __tsearch
 
 #define _GNU_SOURCE
@@ -424,7 +427,7 @@ ftw_dir (struct ftw_data *data, struct STAT *st)
 
     /* Next, update the `struct FTW' information.  */
     ++data->ftw.level;
-    startp = strchr (data->dirbuf, '\0');
+    startp = __strchr (data->dirbuf, '\0');
     /* There always must be a directory name.  */
     assert (startp != data->dirbuf);
     if (startp[-1] != '/')
@@ -460,7 +463,7 @@ ftw_dir (struct ftw_data *data, struct STAT *st)
 
 	while (result == 0 && *runp != '\0')
 	{
-	    char *endp = strchr (runp, '\0');
+	    char *endp = __strchr (runp, '\0');
 
 	    result = process_entry (data, &dir, runp, endp - runp);
 
@@ -501,7 +504,7 @@ ftw_startup (const char *dir, int is_nftw, void *func, int descriptors, int flag
 	__set_errno (ENOENT);
 	return -1;
     }
-    if ((strlen(dir)+1) > NAME_MAX) {
+    if ((__strlen(dir)+1) > NAME_MAX) {
 	__set_errno(ENAMETOOLONG);
 	return -1;
     }
@@ -510,10 +513,10 @@ ftw_startup (const char *dir, int is_nftw, void *func, int descriptors, int flag
     data.actdir = 0;
     data.dirstreams = (struct dir_data **) alloca (data.maxdir
 	    * sizeof (struct dir_data *));
-    memset (data.dirstreams, '\0', data.maxdir * sizeof (struct dir_data *));
+    __memset (data.dirstreams, '\0', data.maxdir * sizeof (struct dir_data *));
 
     /* PATH_MAX is always defined when we get here.  */
-    data.dirbufsize = MAX (2 * strlen (dir), PATH_MAX);
+    data.dirbufsize = MAX (2 * __strlen (dir), PATH_MAX);
     data.dirbuf = (char *) malloc (data.dirbufsize);
     if (data.dirbuf == NULL)
 	return -1;

libc/misc/glob/glob.c

@@ -127,7 +127,7 @@ glob (pattern, flags, errfunc, pglob)
     {
       dirlen = filename - pattern;
       dirname = (char *) alloca (dirlen + 1);
-      memcpy (dirname, pattern, dirlen);
+      __memcpy (dirname, pattern, dirlen);
       dirname[dirlen] = '\0';
       ++filename;
     }
@@ -219,11 +219,11 @@ glob (pattern, flags, errfunc, pglob)
 	/* No matches.  */
 	if (flags & GLOB_NOCHECK)
 	{
-	    size_t len = strlen (pattern) + 1;
+	    size_t len = __strlen (pattern) + 1;
 	    char *patcopy = (char *) malloc (len);
 	    if (patcopy == NULL)
 	      return GLOB_NOSPACE;
-	    memcpy (patcopy, pattern, len);
+	    __memcpy (patcopy, pattern, len);
 
 	    pglob->gl_pathv
 	      = (char **) realloc (pglob->gl_pathv,
@@ -281,7 +281,7 @@ glob (pattern, flags, errfunc, pglob)
       for (i = oldcount; i < pglob->gl_pathc; ++i)
 	if (lstat (pglob->gl_pathv[i], &st) == 0 &&
 	    S_ISDIR (st.st_mode))
-	  strcat (pglob->gl_pathv[i], "/");
+	  __strcat (pglob->gl_pathv[i], "/");
     }
 
   if (!(flags & GLOB_NOSORT))
@@ -343,7 +343,7 @@ prefix_array (dirname, array, n, add_slash)
      int add_slash;
 {
   register size_t i;
-  size_t dirlen = strlen (dirname);
+  size_t dirlen = __strlen (dirname);
 
   if (dirlen == 1 && dirname[0] == '/')
     /* DIRNAME is just "/", so normal prepending would get us "//foo".
@@ -352,7 +352,7 @@ prefix_array (dirname, array, n, add_slash)
 
   for (i = 0; i < n; ++i)
     {
-      size_t eltlen = strlen (array[i]) + 1;
+      size_t eltlen = __strlen (array[i]) + 1;
       char *new = (char *) malloc (dirlen + 1 + eltlen + (add_slash ? 1 : 0));
       if (new == NULL)
 	{
@@ -361,9 +361,9 @@ prefix_array (dirname, array, n, add_slash)
 	  return 1;
 	}
 
-      memcpy (new, dirname, dirlen);
+      __memcpy (new, dirname, dirlen);
       new[dirlen] = '/';
-      memcpy (&new[dirlen + 1], array[i], eltlen);
+      __memcpy (&new[dirlen + 1], array[i], eltlen);
       free ((__ptr_t) array[i]);
       array[i] = new;
     }
@@ -436,7 +436,7 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
 #endif
 	}
 		
-      if ((!meta && strcmp (pattern, name) == 0)
+      if ((!meta && __strcmp (pattern, name) == 0)
 	  || fnmatch (pattern, name,
 		      (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
 		      ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
@@ -444,12 +444,12 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
 	  struct globlink *new
 	    = (struct globlink *) alloca (sizeof (struct globlink));
 	  if (len == 0)
-	    len = strlen (name);
+	    len = __strlen (name);
 	  new->name
 	    = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
 	  if (new->name == NULL)
 	    goto memory_error;
-	  memcpy ((__ptr_t) new->name, name, len);
+	  __memcpy ((__ptr_t) new->name, name, len);
 	  new->name[len] = '\0';
 	  new->next = names;
 	  names = new;
@@ -461,14 +461,14 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
 
   if (nfound == 0 && (flags & GLOB_NOCHECK))
     {
-      size_t len = strlen (pattern);
+      size_t len = __strlen (pattern);
       nfound = 1;
       names = (struct globlink *) alloca (sizeof (struct globlink));
       names->next = NULL;
       names->name = (char *) malloc (len + (flags & GLOB_MARK ? 1 : 0) + 1);
       if (names->name == NULL)
 	goto memory_error;
-      memcpy (names->name, pattern, len);
+      __memcpy (names->name, pattern, len);
       names->name[len] = '\0';
     }
 

libc/misc/internals/__uClibc_main.c

@@ -80,9 +80,9 @@ const char *__progname = 0;
 #endif
 
 extern int __libc_fcntl(int fd, int cmd, ...);
-extern int __libc_open(const char *file, int flags, ...);
 
 #ifdef __ARCH_HAS_MMU__
+
 static void __check_one_fd(int fd, int mode)
 {
     /* Check if the specified fd is already open */
@@ -90,7 +90,7 @@ static void __check_one_fd(int fd, int mode)
     {
 	/* The descriptor is probably not open, so try to use /dev/null */
 	struct stat st;
-	int nullfd = __libc_open(_PATH_DEVNULL, mode);
+	int nullfd = __open(_PATH_DEVNULL, mode);
 	/* /dev/null is major=1 minor=3.  Make absolutely certain
 	 * that is in fact the device that we have opened and not
 	 * some other wierd file... */
@@ -229,7 +229,7 @@ __uClibc_main(int (*main)(int, char **, char **), int argc,
     while (*aux_dat) {
 	ElfW(auxv_t) *auxv_entry = (ElfW(auxv_t) *) aux_dat;
 	if (auxv_entry->a_type <= AT_EGID) {
-	    memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(ElfW(auxv_t)));
+	    __memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(ElfW(auxv_t)));
 	}
 	aux_dat += 2;
     }

libc/misc/internals/tempname.c

@@ -31,6 +31,8 @@
  * Use brain damaged getpid() if real random fails.
  */
 
+#define open64 __open64
+
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -72,7 +74,7 @@ int attribute_hidden __path_search (char *tmpl, size_t tmpl_len, const char *dir
     }
     else
     {
-	plen = strlen (pfx);
+	plen = __strlen (pfx);
 	if (plen > 5)
 	    plen = 5;
     }
@@ -94,7 +96,7 @@ int attribute_hidden __path_search (char *tmpl, size_t tmpl_len, const char *dir
     {
 	if (direxists (P_tmpdir))
 	    dir = P_tmpdir;
-	else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
+	else if (__strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
 	    dir = "/tmp";
 	else
 	{
@@ -103,7 +105,7 @@ int attribute_hidden __path_search (char *tmpl, size_t tmpl_len, const char *dir
 	}
     }
 
-    dlen = strlen (dir);
+    dlen = __strlen (dir);
     while (dlen > 1 && dir[dlen - 1] == '/')
 	dlen--;			/* remove trailing slashes */
 
@@ -126,13 +128,13 @@ static unsigned int fillrand(unsigned char *buf, unsigned int len)
 {
     int fd;
     unsigned int result = -1;
-    fd = open("/dev/urandom", O_RDONLY);
+    fd = __open("/dev/urandom", O_RDONLY);
     if (fd < 0) {
-	fd = open("/dev/random", O_RDONLY | O_NONBLOCK);
+	fd = __open("/dev/random", O_RDONLY | O_NONBLOCK);
     }
     if (fd >= 0) {
-	result = read(fd, buf, len);
-	close(fd);
+	result = __read(fd, buf, len);
+	__close(fd);
     }
     return result;
 }
@@ -182,8 +184,8 @@ int attribute_hidden __gen_tempname (char *tmpl, int kind)
     int len, i, count, fd, save_errno = errno;
     unsigned char randomness[6];
 
-    len = strlen (tmpl);
-    if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
+    len = __strlen (tmpl);
+    if (len < 6 || __strcmp (&tmpl[len - 6], "XXXXXX"))
     {
 	__set_errno (EINVAL);
 	return -1;
@@ -223,7 +225,7 @@ int attribute_hidden __gen_tempname (char *tmpl, int kind)
 			continue;
 		}
 	    case __GT_FILE:
-		fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+		fd = __open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 		break;
 #if defined __UCLIBC_HAS_LFS__
 	    case __GT_BIGFILE:

libc/misc/intl/intl.c

@@ -60,7 +60,7 @@ char *__uClibc_textdomain(const char *domainname)
 {
 	static const char default_str[] = "messages";
 
-	if (domainname && *domainname && strcmp(domainname, default_str)) {
+	if (domainname && *domainname && __strcmp(domainname, default_str)) {
 		__set_errno(EINVAL);
 		return NULL;
 	}
@@ -82,7 +82,7 @@ char *__uClibc_bindtextdomain(const char *domainname, const char *dirname)
 #if 1
 			&& ((dirname[0] != '/') || dirname[1])
 #else
-			&& strcmp(dirname, dir)
+			&& __strcmp(dirname, dir)
 #endif
 			)
 		) {

libc/misc/locale/locale.c

@@ -155,7 +155,7 @@ char *setlocale(int category, register const char *locale)
 			 && ( (!locale)		/* Request for locale category string. */
 				  || (!*locale)	/* Implementation-defined default is C. */
 				  || ((*locale == 'C') && !locale[1])
-				  || (!strcmp(locale, "POSIX"))) )
+				  || (!__strcmp(locale, "POSIX"))) )
 		? (char *) C_string		/* Always in C/POSIX locale. */
 		: NULL;
 }
@@ -226,7 +226,7 @@ static void update_hr_locale(const unsigned char *spec)
 					*n = 0;
 				} else {
 					char at = 0;
-					memcpy(n, LOCALE_NAMES + 5*((*loc)-1), 5);
+					__memcpy(n, LOCALE_NAMES + 5*((*loc)-1), 5);
 					if (n[2] != '_') {
 						at = n[2];
 						n[2] = '_';
@@ -455,7 +455,7 @@ static int init_cur_collate(int der_num, __collate_t *cur_collate)
 								+ cdd->base_idx * sizeof(coldata_base_t)
 								)/2 );
 
-	memcpy(cur_collate, cdb, offsetof(coldata_base_t,index2weight_offset));
+	__memcpy(cur_collate, cdb, offsetof(coldata_base_t,index2weight_offset));
 	cur_collate->undefined_idx = cdd->undefined_idx;
 
 	cur_collate->ti_mask = (1 << cur_collate->ti_shift)-1;
@@ -507,9 +507,9 @@ static int init_cur_collate(int der_num, __collate_t *cur_collate)
 	cur_collate->index2ruleidx = cur_collate->index2weight
 		+ cur_collate->max_col_index + 1;
 
-	memcpy(cur_collate->index2weight, cur_collate->index2weight_tbl,
+	__memcpy(cur_collate->index2weight, cur_collate->index2weight_tbl,
 		   cur_collate->num_col_base * sizeof(uint16_t));
-	memcpy(cur_collate->index2ruleidx, cur_collate->index2ruleidx_tbl,
+	__memcpy(cur_collate->index2ruleidx, cur_collate->index2ruleidx_tbl,
 		   cur_collate->num_col_base * sizeof(uint16_t));
 
 	/* now do the overrides */
@@ -594,7 +594,7 @@ int _locale_set_l(const unsigned char *p, __locale_t base)
 			return 0;			/* calloc failed. */
 		}
 		free(base->collate.index2weight);
-		memcpy(&base->collate, &newcol, sizeof(__collate_t));
+		__memcpy(&base->collate, &newcol, sizeof(__collate_t));
 	}
 
 	do {
@@ -664,15 +664,15 @@ int _locale_set_l(const unsigned char *p, __locale_t base)
 					 * All of this will be replaced in the next generation
 					 * of locale support anyway... */
 
-					memcpy(base->__ctype_b_data,
+					__memcpy(base->__ctype_b_data,
 						   __C_ctype_b - __UCLIBC_CTYPE_B_TBL_OFFSET,
 						   (256 + __UCLIBC_CTYPE_B_TBL_OFFSET)
 						   * sizeof(__ctype_mask_t));
-					memcpy(base->__ctype_tolower_data,
+					__memcpy(base->__ctype_tolower_data,
 						   __C_ctype_tolower - __UCLIBC_CTYPE_TO_TBL_OFFSET,
 						   (256 + __UCLIBC_CTYPE_TO_TBL_OFFSET)
 						   * sizeof(__ctype_touplow_t));
-					memcpy(base->__ctype_toupper_data,
+					__memcpy(base->__ctype_toupper_data,
 						   __C_ctype_toupper - __UCLIBC_CTYPE_TO_TBL_OFFSET,
 						   (256 + __UCLIBC_CTYPE_TO_TBL_OFFSET)
 						   * sizeof(__ctype_touplow_t));
@@ -782,7 +782,7 @@ int _locale_set_l(const unsigned char *p, __locale_t base)
 				d = base->outdigit_length;
 				x = &base->outdigit0_mb;
 				for (c = 0 ; c < 10 ; c++) {
-					((unsigned char *)d)[c] = strlen(x[c]);
+					((unsigned char *)d)[c] = __strlen(x[c]);
 					assert(d[c] > 0);
 				}
 			} else if (i == LC_NUMERIC) {
@@ -847,10 +847,10 @@ static const uint16_t __code2flag[16] = {
 
 void _locale_init_l(__locale_t base)
 {
-	memset(base->cur_locale, 0, LOCALE_SELECTOR_SIZE);
+	__memset(base->cur_locale, 0, LOCALE_SELECTOR_SIZE);
 	base->cur_locale[0] = '#';
 
-	memcpy(base->category_item_count,
+	__memcpy(base->category_item_count,
 		   __locale_mmap->lc_common_item_offsets_LEN,
 		   LC_ALL);
 
@@ -1072,14 +1072,14 @@ static int find_locale(int category_mask, const char *p,
 	char buf[18];	/* TODO: 7+{max codeset name length} */
 	const char *q;
 
-	if ((q = strchr(p,'@')) != NULL) {
+	if ((q = __strchr(p,'@')) != NULL) {
 		if ((((size_t)((q-p)-5)) > (sizeof(buf) - 5)) || (p[2] != '_')) {
 			return 0;
 		}
 		/* locale name at least 5 chars long and 3rd char is '_' */
 		s = LOCALE_AT_MODIFIERS;
 		do {
-			if (!strcmp(s+2, q+1)) {
+			if (!__strcmp(s+2, q+1)) {
 				break;
 			}
 			s += 2 + *s;		/* TODO - fix this throughout */
@@ -1088,7 +1088,7 @@ static int find_locale(int category_mask, const char *p,
 			return 0;
 		}
 		assert(q - p < sizeof(buf));
-		memcpy(buf, p, q-p);
+		__memcpy(buf, p, q-p);
 		buf[q-p] = 0;
 		buf[2] = s[1];
 		p = buf;
@@ -1096,19 +1096,19 @@ static int find_locale(int category_mask, const char *p,
 #endif
 
 	lang_cult = codeset = 0;	/* Assume C and default codeset.  */
-	if (((*p == 'C') && !p[1]) || !strcmp(p, posix)) {
+	if (((*p == 'C') && !p[1]) || !__strcmp(p, posix)) {
 		goto FIND_LOCALE;
 	}
 
-	if ((strlen(p) > 5) && (p[5] == '.')) {	/* Codeset in locale name? */
+	if ((__strlen(p) > 5) && (p[5] == '.')) {	/* Codeset in locale name? */
 		/* TODO: maybe CODESET_LIST + *s ??? */
 		/* 7bit is 1, UTF-8 is 2, 8-bit is >= 3 */
 		codeset = 2;
-		if (strcmp(utf8,p+6) != 0) {/* TODO - fix! */
+		if (__strcmp(utf8,p+6) != 0) {/* TODO - fix! */
 			s = CODESET_LIST;
 			do {
 				++codeset;		/* Increment codeset first. */
-				if (!strcmp(CODESET_LIST+*s, p+6)) {
+				if (!__strcmp(CODESET_LIST+*s, p+6)) {
 					goto FIND_LANG_CULT;
 				}
 			} while (*++s);
@@ -1121,7 +1121,7 @@ static int find_locale(int category_mask, const char *p,
 	do {						/* TODO -- do a binary search? */
 		/* TODO -- fix gen_mmap!*/
 		++lang_cult;			/* Increment first since C/POSIX is 0. */
-		if (!strncmp(s,p,5)) { /* Found a matching locale name; */
+		if (!__strncmp(s,p,5)) { /* Found a matching locale name; */
 			goto FIND_LOCALE;
 		}
 		s += 5;
@@ -1163,14 +1163,14 @@ static unsigned char *composite_locale(int category_mask, const char *locale,
 	int c;
 	int component_mask;
 
-	if (!strchr(locale,'=')) {
+	if (!__strchr(locale,'=')) {
 		if (!find_locale(category_mask, locale, new_locale)) {
 			return NULL;
 		}
 		return new_locale;
 	}
 
-	if (strlen(locale) >= sizeof(buf)) {
+	if (__strlen(locale) >= sizeof(buf)) {
 		return NULL;
 	}
 	stpcpy(buf, locale);
@@ -1179,7 +1179,7 @@ static unsigned char *composite_locale(int category_mask, const char *locale,
 	t = strtok_r(buf, "=", &e);	/* This can't fail because of strchr test above. */
 	do {
 		c = 0;
-		while (strcmp(CATEGORY_NAMES + (int) CATEGORY_NAMES[c], t)) {
+		while (__strcmp(CATEGORY_NAMES + (int) CATEGORY_NAMES[c], t)) {
 			if (++c == LC_ALL) { /* Unknown category name! */
 				return NULL;
 			}
@@ -1221,7 +1221,7 @@ __locale_t __newlocale(int category_mask, const char *locale, __locale_t base)
 #ifdef __UCLIBC_MJN3_ONLY__
 #warning TODO: Rename cur_locale to locale_selector.
 #endif
-	strcpy((char *) new_selector,
+	__strcpy((char *) new_selector,
 		   (base ? (char *) base->cur_locale : C_LOCALE_SELECTOR));
 
 	if (!*locale) {			 /* locale == "", so check environment. */
@@ -1310,9 +1310,9 @@ __locale_t __duplocale(__locale_t dataset)
 		if ((i2w = calloc(n, sizeof(uint16_t)))
 			!= NULL
 			) {
-			memcpy(r, dataset, sizeof(__uclibc_locale_t));
+			__memcpy(r, dataset, sizeof(__uclibc_locale_t));
 			r->collate.index2weight = i2w;
-			memcpy(i2w, dataset->collate.index2weight, n * sizeof(uint16_t));
+			__memcpy(i2w, dataset->collate.index2weight, n * sizeof(uint16_t));
 		} else {
 			free(r);
 			r = NULL;

libc/misc/regex/regex.c

@@ -44,6 +44,15 @@ extern wctype_t __wctype (__const char *__property) attribute_hidden;
 
 extern int __iswctype (wint_t __wc, wctype_t __desc) /*attribute_hidden*/;
 #endif
+
+#define memcmp __memcmp
+#define memcpy __memcpy
+#define memmove __memmove
+#define memset __memset
+#define strchr __strchr
+#define strcmp __strcmp
+#define strlen __strlen
+#define strncpy __strncpy
 #endif
 
 /* Make sure noone compiles this code with a C++ compiler.  */

libc/misc/regex/regex_old.c

@@ -21,7 +21,6 @@
    02111-1307 USA.  */
 
 #define HAVE_MEMPCPY
-#define __mempcpy __libc_mempcpy
 #define memset __memset
 #define memcmp __memcmp
 #define strcmp __strcmp
@@ -40,8 +39,8 @@
 #define STDC_HEADERS
 #define RE_TRANSLATE_TYPE char *
 
-extern void *__libc_mempcpy (void *__restrict __dest,
-			__const void *__restrict __src, size_t __n) /*attribute_hidden*/;
+extern void *__mempcpy (void *__restrict __dest,
+			__const void *__restrict __src, size_t __n) attribute_hidden;
 
 /* AIX requires this to be the first thing in the file. */
 #if defined _AIX && !defined REGEX_MALLOC

libc/misc/search/hsearch_r.c

@@ -140,7 +140,7 @@ int hsearch_r (ENTRY item, ACTION action, ENTRY **retval,
 {
   unsigned int hval;
   unsigned int count;
-  unsigned int len = strlen (item.key);
+  unsigned int len = __strlen (item.key);
   unsigned int idx;
 
   /* Compute an value for the given string. Perhaps use a better method. */
@@ -166,7 +166,7 @@ int hsearch_r (ENTRY item, ACTION action, ENTRY **retval,
       unsigned hval2;
 
       if (htab->table[idx].used == hval
-	  && strcmp (item.key, htab->table[idx].entry.key) == 0)
+	  && __strcmp (item.key, htab->table[idx].entry.key) == 0)
 	{
 	  *retval = &htab->table[idx].entry;
 	  return 1;
@@ -190,7 +190,7 @@ int hsearch_r (ENTRY item, ACTION action, ENTRY **retval,
 
             /* If entry is found use it. */
           if (htab->table[idx].used == hval
-	      && strcmp (item.key, htab->table[idx].entry.key) == 0)
+	      && __strcmp (item.key, htab->table[idx].entry.key) == 0)
 	    {
 	      *retval = &htab->table[idx].entry;
 	      return 1;

libc/misc/search/lsearch.c

@@ -37,7 +37,7 @@ void *lsearch(const void *key, void *base, size_t *nmemb,
 	register char *p;
 
 	if ((p = lfind(key, base, nmemb, size, compar)) == NULL) {
-		p = memcpy((base + (size * (*nmemb))), key, size);
+		p = __memcpy((base + (size * (*nmemb))), key, size);
 		++(*nmemb);
 	}
 	return (p);

libc/misc/statfs/fstatfs64.c

@@ -57,7 +57,7 @@ int fstatfs64 (int fd, struct statfs64 *buf)
     buf->f_ffree = buf32.f_ffree;
     buf->f_fsid = buf32.f_fsid;
     buf->f_namelen = buf32.f_namelen;
-    memcpy (buf->f_spare, buf32.f_spare, sizeof (buf32.f_spare));
+    __memcpy (buf->f_spare, buf32.f_spare, sizeof (buf32.f_spare));
 
     return 0;
 }

libc/misc/statfs/internal_statvfs.c

@@ -39,7 +39,7 @@
   buf->__f_unused = 0;
 #endif
   buf->f_namemax = fsbuf.f_namelen;
-  memset (buf->__f_spare, '\0', 6 * sizeof (int));
+  __memset (buf->__f_spare, '\0', 6 * sizeof (int));
 
   /* What remains to do is to fill the fields f_favail and f_flag.  */
 
@@ -79,21 +79,21 @@
 		  char *opt;
 
 		  while ((opt = strsep (&cp, ",")) != NULL)
-		    if (strcmp (opt, "ro") == 0)
+		    if (__strcmp (opt, "ro") == 0)
 		      buf->f_flag |= ST_RDONLY;
-		    else if (strcmp (opt, "nosuid") == 0)
+		    else if (__strcmp (opt, "nosuid") == 0)
 		      buf->f_flag |= ST_NOSUID;
-		    else if (strcmp (opt, "noexec") == 0)
+		    else if (__strcmp (opt, "noexec") == 0)
 		      buf->f_flag |= ST_NOEXEC;
-		    else if (strcmp (opt, "nodev") == 0)
+		    else if (__strcmp (opt, "nodev") == 0)
 		      buf->f_flag |= ST_NODEV;
-		    else if (strcmp (opt, "sync") == 0)
+		    else if (__strcmp (opt, "sync") == 0)
 		      buf->f_flag |= ST_SYNCHRONOUS;
-		    else if (strcmp (opt, "mand") == 0)
+		    else if (__strcmp (opt, "mand") == 0)
 		      buf->f_flag |= ST_MANDLOCK;
-		    else if (strcmp (opt, "noatime") == 0)
+		    else if (__strcmp (opt, "noatime") == 0)
 		      buf->f_flag |= ST_NOATIME;
-		    else if (strcmp (opt, "nodiratime") == 0)
+		    else if (__strcmp (opt, "nodiratime") == 0)
 		      buf->f_flag |= ST_NODIRATIME;
 
 		  /* We can stop looking for more entries.  */

libc/misc/statfs/statfs64.c

@@ -55,7 +55,7 @@ int statfs64 (const char *file, struct statfs64 *buf)
     buf->f_ffree = buf32.f_ffree;
     buf->f_fsid = buf32.f_fsid;
     buf->f_namelen = buf32.f_namelen;
-    memcpy (buf->f_spare, buf32.f_spare, sizeof (buf32.f_spare));
+    __memcpy (buf->f_spare, buf32.f_spare, sizeof (buf32.f_spare));
 
     return 0;
 }

libc/misc/syslog/syslog.c

@@ -31,8 +31,6 @@
  * SUCH DAMAGE.
  */
 
-#define memmove __memmove
-
 #define __FORCE_GLIBC
 #define _GNU_SOURCE
 #include <features.h>
@@ -114,7 +112,7 @@ closelog_intern(int to_default)
 {
 	LOCK;
 	if (LogFile != -1) {
-	    (void) close(LogFile);
+	    (void) __close(LogFile);
 	}
 	LogFile = -1;
 	connected = 0;
@@ -160,7 +158,7 @@ vsyslog( int pri, const char *fmt, va_list ap )
 
 	struct sigaction action, oldaction;
 	int sigpipe;
-	memset (&action, 0, sizeof (action));
+	__memset (&action, 0, sizeof (action));
 	action.sa_handler = sigpipe_handler;
 	sigemptyset (&action.sa_mask);
 	sigpipe = sigaction (SIGPIPE, &action, &oldaction);
@@ -186,7 +184,7 @@ vsyslog( int pri, const char *fmt, va_list ap )
 	(void)time(&now);
 	stdp = p = tbuf + sprintf(tbuf, "<%d>%.15s ", pri, ctime(&now) + 4);
 	if (LogTag) {
-		if (strlen(LogTag) < sizeof(tbuf) - 64)
+		if (__strlen(LogTag) < sizeof(tbuf) - 64)
 			p += sprintf(p, "%s", LogTag);
 		else
 			p += sprintf(p, "<BUFFER OVERRUN ATTEMPT>");
@@ -209,9 +207,9 @@ vsyslog( int pri, const char *fmt, va_list ap )
 	p += vsnprintf(p, end - p, fmt, ap);
 	if (p >= end || p < head_end) {	/* Returned -1 in case of error... */
 		static const char truncate_msg[12] = "[truncated] ";
-		memmove(head_end + sizeof(truncate_msg), head_end,
+		__memmove(head_end + sizeof(truncate_msg), head_end,
 			end - head_end - sizeof(truncate_msg));
-		memcpy(head_end, truncate_msg, sizeof(truncate_msg));
+		__memcpy(head_end, truncate_msg, sizeof(truncate_msg));
 		if (p < head_end) {
 			while (p < end && *p) {
 				p++;
@@ -227,14 +225,14 @@ vsyslog( int pri, const char *fmt, va_list ap )
 	/* Output to stderr if requested. */
 	if (LogStat & LOG_PERROR) {
 		*last_chr = '\n';
-		(void)write(STDERR_FILENO, stdp, last_chr - stdp + 1);
+		(void)__write(STDERR_FILENO, stdp, last_chr - stdp + 1);
 	}
 
 	/* Output the message to the local logger using NUL as a message delimiter. */
 	p = tbuf;
 	*last_chr = 0;
 	do {
-		rc = write(LogFile, p, last_chr + 1 - p);
+		rc = __write(LogFile, p, last_chr + 1 - p);
 		if (rc < 0) {
 			if ((errno==EAGAIN) || (errno==EINTR))
 				rc=0;
@@ -255,12 +253,12 @@ vsyslog( int pri, const char *fmt, va_list ap )
 	 */
 	/* should mode be `O_WRONLY | O_NOCTTY' ? -- Uli */
 	if (LogStat & LOG_CONS &&
-	    (fd = open(_PATH_CONSOLE, O_WRONLY, 0)) >= 0) {
-		p = strchr(tbuf, '>') + 1;
+	    (fd = __open(_PATH_CONSOLE, O_WRONLY, 0)) >= 0) {
+		p = __strchr(tbuf, '>') + 1;
 		last_chr[0] = '\r';
 		last_chr[1] = '\n';
-		(void)write(fd, p, last_chr - p + 2);
-		(void)close(fd);
+		(void)__write(fd, p, last_chr - p + 2);
+		(void)__close(fd);
 	}
 
 getout:
@@ -287,7 +285,7 @@ openlog( const char *ident, int logstat, int logfac )
 	LogFacility = logfac;
     if (LogFile == -1) {
 	SyslogAddr.sa_family = AF_UNIX;
-	(void)strncpy(SyslogAddr.sa_data, _PATH_LOG,
+	(void)__strncpy(SyslogAddr.sa_data, _PATH_LOG,
 		      sizeof(SyslogAddr.sa_data));
 retry:
 	if (LogStat & LOG_NDELAY) {
@@ -301,19 +299,19 @@ retry:
 
     if (LogFile != -1 && !connected) {
 	if (connect(LogFile, &SyslogAddr, sizeof(SyslogAddr) - 
-		    sizeof(SyslogAddr.sa_data) + strlen(SyslogAddr.sa_data)) != -1)
+		    sizeof(SyslogAddr.sa_data) + __strlen(SyslogAddr.sa_data)) != -1)
 	{
 	    connected = 1;
 	} else if (logType == SOCK_DGRAM) {
 	    logType = SOCK_STREAM;
 	    if (LogFile != -1) {
-		close(LogFile);
+		__close(LogFile);
 		LogFile = -1;
 	    }
 	    goto retry;
 	} else {
 	    if (LogFile != -1) {
-		close(LogFile);
+		__close(LogFile);
 		LogFile = -1;
 	    }
 	}

libc/misc/time/time.c

@@ -131,7 +131,6 @@
 
 #define _uintmaxtostr __libc__uintmaxtostr
 #define strnlen __strnlen
-#define memcpy __memcpy
 
 #define _GNU_SOURCE
 #include <stdio.h>
@@ -316,23 +315,23 @@ char attribute_hidden *__asctime_r(register const struct tm *__restrict ptm,
 	assert(buffer);
 
 #ifdef SAFE_ASCTIME_R
-	memcpy(buffer, at_data + 3*(7 + 12), sizeof(at_data) - 3*(7 + 12));
+	__memcpy(buffer, at_data + 3*(7 + 12), sizeof(at_data) - 3*(7 + 12));
 
 	if (((unsigned int)(ptm->tm_wday)) <= 6) {
-		memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
+		__memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
 	}
 
 	if (((unsigned int)(ptm->tm_mon)) <= 11) {
-		memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
+		__memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
 	}
 #else
 	assert(((unsigned int)(ptm->tm_wday)) <= 6);
 	assert(((unsigned int)(ptm->tm_mon)) <= 11);
 
-	memcpy(buffer, at_data + 3*(7 + 12) - 3, sizeof(at_data) + 3 - 3*(7 + 12));
+	__memcpy(buffer, at_data + 3*(7 + 12) - 3, sizeof(at_data) + 3 - 3*(7 + 12));
 
-	memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
-	memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
+	__memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
+	__memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
 #endif
 
 #ifdef SAFE_ASCTIME_R
@@ -587,7 +586,7 @@ static const char *lookup_tzname(const char *key)
 	ll_tzname_item_t *p;
 
 	for (p=ll_tzname ; p ; p=p->next) {
-		if (!strcmp(p->tzname, key)) {
+		if (!__strcmp(p->tzname, key)) {
 			return p->tzname;
 		}
 	}
@@ -598,7 +597,7 @@ static const char *lookup_tzname(const char *key)
 			/* Insert as 3rd item in the list. */
 			p->next = ll_tzname[1].next;
 			ll_tzname[1].next = p;
-			strcpy(p->tzname, key);
+			__strcpy(p->tzname, key);
 			return p->tzname;
 		}
 	}
@@ -742,8 +741,8 @@ time_t timegm(struct tm *timeptr)
 {
 	rule_struct gmt_tzinfo[2];
 
-	memset(gmt_tzinfo, 0, sizeof(gmt_tzinfo));
-	strcpy(gmt_tzinfo[0].tzname, "GMT"); /* Match glibc behavior here. */
+	__memset(gmt_tzinfo, 0, sizeof(gmt_tzinfo));
+	__strcpy(gmt_tzinfo[0].tzname, "GMT"); /* Match glibc behavior here. */
 
 	return  _time_mktime_tzi(timeptr, 1, gmt_tzinfo);
 }
@@ -1503,7 +1502,7 @@ char *__XL(strptime)(const char *__restrict buf, const char *__restrict format,
 			do {
 				--j;
 				o = __XL(nl_langinfo)(i+j   __LOCALE_ARG);
-				if (!__XL(strncasecmp)(buf,o,strlen(o)   __LOCALE_ARG) && *o) {
+				if (!__XL(strncasecmp)(buf,o,__strlen(o)   __LOCALE_ARG) && *o) {
 					do {		/* Found a match. */
 						++buf;
 					} while (*++o);
@@ -1758,11 +1757,11 @@ static char *read_TZ_file(char *buf)
 	size_t todo;
 	char *p = NULL;
 
-	if ((fd = open(__UCLIBC_TZ_FILE_PATH__, O_RDONLY)) >= 0) {
+	if ((fd = __open(__UCLIBC_TZ_FILE_PATH__, O_RDONLY)) >= 0) {
 		todo = TZ_BUFLEN;
 		p = buf;
 		do {
-			if ((r = read(fd, p, todo)) < 0) {
+			if ((r = __read(fd, p, todo)) < 0) {
 				goto ERROR;
 			}
 			if (r == 0) {
@@ -1782,7 +1781,7 @@ static char *read_TZ_file(char *buf)
 		ERROR:
 			p = NULL;
 		}
-		close(fd);
+		__close(fd);
 	}
 	return p;
 }
@@ -1834,8 +1833,8 @@ void tzset(void)
 #ifdef __UCLIBC_HAS_TZ_CACHING__
 		*oldval = 0;			/* Set oldval to an empty string. */
 #endif /* __UCLIBC_HAS_TZ_CACHING__ */
-		memset(_time_tzinfo, 0, 2*sizeof(rule_struct));
-		strcpy(_time_tzinfo[0].tzname, UTC);
+		__memset(_time_tzinfo, 0, 2*sizeof(rule_struct));
+		__strcpy(_time_tzinfo[0].tzname, UTC);
 		goto DONE;
 	}
 
@@ -1844,13 +1843,13 @@ void tzset(void)
 	}
 
 #ifdef __UCLIBC_HAS_TZ_CACHING__
-	if (strcmp(e, oldval) == 0) { /* Same string as last time... */
+	if (__strcmp(e, oldval) == 0) { /* Same string as last time... */
 		goto FAST_DONE;			/* So nothing to do. */
 	}
 	/* Make a copy of the TZ env string.  It won't be nul-terminated if
 	 * it is too long, but it that case it will be illegal and will be reset
 	 * to the empty string anyway. */
-	strncpy(oldval, e, TZ_BUFLEN);
+	__strncpy(oldval, e, TZ_BUFLEN);
 #endif /* __UCLIBC_HAS_TZ_CACHING__ */
 	
 	count = 0;
@@ -1964,7 +1963,7 @@ void tzset(void)
 		}
 	}
 
-	memcpy(_time_tzinfo, new_rules, sizeof(new_rules));
+	__memcpy(_time_tzinfo, new_rules, sizeof(new_rules));
  DONE:
 	tzname[0] = _time_tzinfo[0].tzname;
 	tzname[1] = _time_tzinfo[1].tzname;
@@ -2211,7 +2210,7 @@ time_t attribute_hidden _time_mktime_tzi(struct tm *timeptr, int store_on_succes
 	register const unsigned char *s;
 	int d, default_dst;
 
-	memcpy(p, timeptr, sizeof(struct tm));
+	__memcpy(p, timeptr, sizeof(struct tm));
 
 	if (!tzi[1].tzname[0]) { /* No dst in this timezone, */
 		p[8] = 0;				/* so set tm_isdst to 0. */
@@ -2301,7 +2300,7 @@ time_t attribute_hidden _time_mktime_tzi(struct tm *timeptr, int store_on_succes
 
 
 	if (store_on_success) {
-		memcpy(timeptr, p, sizeof(struct tm));
+		__memcpy(timeptr, p, sizeof(struct tm));
 	}
 
 

libc/misc/ttyent/getttyent.c

@@ -52,7 +52,7 @@ struct ttyent * getttynam(const char *tty)
 
     setttyent();
     while ((t = getttyent()))
-	if (!strcmp(tty, t->ty_name))
+	if (!__strcmp(tty, t->ty_name))
 	    break;
     endttyent();
     return (t);
@@ -98,7 +98,7 @@ static char * skip(register char *p)
 static char * value(register char *p)
 {
 
-    return ((p = strchr(p, '=')) ? ++p : NULL);
+    return ((p = __strchr(p, '=')) ? ++p : NULL);
 }
 
 struct ttyent * getttyent(void)
@@ -124,7 +124,7 @@ struct ttyent * getttyent(void)
 	    return (NULL);
 	}
 	/* skip lines that are too big */
-	if (!strchr(p, '\n')) {
+	if (!__strchr(p, '\n')) {
 	    while ((c = getc_unlocked(tf)) != '\n' && c != EOF)
 		;
 	    continue;
@@ -150,8 +150,8 @@ struct ttyent * getttyent(void)
     tty.ty_status = 0;
     tty.ty_window = NULL;
 
-#define	scmp(e)	!strncmp(p, e, sizeof(e) - 1) && isspace(p[sizeof(e) - 1])
-#define	vcmp(e)	!strncmp(p, e, sizeof(e) - 1) && p[sizeof(e) - 1] == '='
+#define	scmp(e)	!__strncmp(p, e, sizeof(e) - 1) && isspace(p[sizeof(e) - 1])
+#define	vcmp(e)	!__strncmp(p, e, sizeof(e) - 1) && p[sizeof(e) - 1] == '='
     for (; *p; p = skip(p)) {
 	if (scmp(_TTYS_OFF))
 	    tty.ty_status &= ~TTY_ON;
@@ -173,7 +173,7 @@ struct ttyent * getttyent(void)
     tty.ty_comment = p;
     if (*p == 0)
 	tty.ty_comment = 0;
-    if ((p = strchr(p, '\n')))
+    if ((p = __strchr(p, '\n')))
 	*p = '\0';
     return (&tty);
 }

libc/misc/utmp/utent.c

@@ -53,7 +53,7 @@ static struct utmp *__getutent(int utmp_fd)
     }
 
     LOCK;
-    if (read(utmp_fd, (char *) &static_utmp, sizeof(struct utmp)) != sizeof(struct utmp)) 
+    if (__read(utmp_fd, (char *) &static_utmp, sizeof(struct utmp)) != sizeof(struct utmp)) 
     {
 	return NULL;
     }
@@ -68,8 +68,8 @@ void setutent(void)
 
     LOCK;
     if (static_fd == -1) {
-	if ((static_fd = open(static_ut_name, O_RDWR)) < 0) {
-	    if ((static_fd = open(static_ut_name, O_RDONLY)) < 0) {
+	if ((static_fd = __open(static_ut_name, O_RDWR)) < 0) {
+	    if ((static_fd = __open(static_ut_name, O_RDONLY)) < 0) {
 		goto bummer;
 	    }
 	}
@@ -82,7 +82,7 @@ void setutent(void)
 bummer:
 	    UNLOCK;
 	    static_fd = -1;
-	    close(static_fd);
+	    __close(static_fd);
 	    return;
 	}
     }
@@ -95,7 +95,7 @@ void endutent(void)
 {
     LOCK;
     if (static_fd != -1) {
-	close(static_fd);
+	__close(static_fd);
     }
     static_fd = -1;
     UNLOCK;
@@ -125,7 +125,7 @@ struct utmp attribute_hidden *__getutid (const struct utmp *utmp_entry)
 		 utmp_entry->ut_type == DEAD_PROCESS ||
 		 utmp_entry->ut_type == LOGIN_PROCESS ||
 		 utmp_entry->ut_type == USER_PROCESS) &&
-		!strncmp(lutmp->ut_id, utmp_entry->ut_id, sizeof(lutmp->ut_id))) 
+		!__strncmp(lutmp->ut_id, utmp_entry->ut_id, sizeof(lutmp->ut_id))) 
 	{
 	    return lutmp;
 	}
@@ -142,7 +142,7 @@ struct utmp *getutline(const struct utmp *utmp_entry)
 
     while ((lutmp = __getutent(static_fd)) != NULL) {
 	if ((lutmp->ut_type == USER_PROCESS || lutmp->ut_type == LOGIN_PROCESS) &&
-		!strcmp(lutmp->ut_line, utmp_entry->ut_line))
+		!__strcmp(lutmp->ut_line, utmp_entry->ut_line))
 	{
 	    return lutmp;
 	}
@@ -162,11 +162,11 @@ struct utmp *pututline (const struct utmp *utmp_entry)
 
     if (__getutid(utmp_entry) != NULL) {
 	lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
-	if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
+	if (__write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
 	    return NULL;
     } else {
 	lseek(static_fd, (off_t) 0, SEEK_END);
-	if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
+	if (__write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
 	    return NULL;
     }
 
@@ -180,7 +180,7 @@ int utmpname (const char *new_ut_name)
     if (new_ut_name != NULL) {
 	if (static_ut_name != default_file_name)
 	    free((char *)static_ut_name);
-	static_ut_name = strdup(new_ut_name);
+	static_ut_name = __strdup(new_ut_name);
 	if (static_ut_name == NULL) {
 	    /* We should probably whine about out-of-memory 
 	     * errors here...  Instead just reset to the default */
@@ -189,7 +189,7 @@ int utmpname (const char *new_ut_name)
     }
 
     if (static_fd != -1)
-	close(static_fd);
+	__close(static_fd);
     UNLOCK;
     return 0;
 }

libc/misc/utmp/wtent.c

@@ -31,13 +31,13 @@
 void logwtmp (const char *line, const char *name, const char *host)
 {
     struct utmp lutmp;
-    memset (&(lutmp), 0, sizeof (struct utmp));
+    __memset (&(lutmp), 0, sizeof (struct utmp));
 
     lutmp.ut_type = (name && *name)? USER_PROCESS : DEAD_PROCESS;
     lutmp.ut_pid = getpid();
-    strncpy(lutmp.ut_line, line, sizeof(lutmp.ut_line)-1);
-    strncpy(lutmp.ut_name, name, sizeof(lutmp.ut_name)-1);
-    strncpy(lutmp.ut_host, host, sizeof(lutmp.ut_host)-1);
+    __strncpy(lutmp.ut_line, line, sizeof(lutmp.ut_line)-1);
+    __strncpy(lutmp.ut_name, name, sizeof(lutmp.ut_name)-1);
+    __strncpy(lutmp.ut_host, host, sizeof(lutmp.ut_host)-1);
     gettimeofday(&(lutmp.ut_tv), NULL);
 
     updwtmp(_PATH_WTMP, &(lutmp));
@@ -48,12 +48,12 @@ extern void updwtmp(const char *wtmp_file, const struct utmp *lutmp)
 {
     int fd;
 
-    fd = open(wtmp_file, O_APPEND | O_WRONLY, 0);
+    fd = __open(wtmp_file, O_APPEND | O_WRONLY, 0);
     if (fd >= 0) {
 	if (lockf(fd, F_LOCK, 0)==0) {
-	    write(fd, (const char *) lutmp, sizeof(struct utmp));
+	    __write(fd, (const char *) lutmp, sizeof(struct utmp));
 	    lockf(fd, F_ULOCK, 0);
-	    close(fd);
+	    __close(fd);
 	}
     }
 }

libc/misc/wchar/wchar.c

@@ -98,8 +98,6 @@
  * Manuel
  */
 
-#define memmove __memmove
-
 #define _GNU_SOURCE
 #define _ISOC99_SOURCE
 #include <errno.h>
@@ -1620,7 +1618,7 @@ int main(int argc, char **argv)
 			break;
 		}
 		do {
-			if ((s = strchr(opt_chars,*p)) == NULL) {
+			if ((s = __strchr(opt_chars,*p)) == NULL) {
 			USAGE:
 				s = basename(progname);
 				fprintf(stderr,
@@ -1697,7 +1695,7 @@ int main(int argc, char **argv)
 				}
 			}
 			if (ni) {			/* still bytes in buffer! */
-				memmove(ibuf, pi, ni);
+				__memmove(ibuf, pi, ni);
 			}
 		}
 

libc/misc/wctype/wctype.c

@@ -490,7 +490,7 @@ wctype_t attribute_hidden __wctype(const char *property)
 	p = typestring;
 	i = 1;
 	do {
-		if (!strcmp(property, ++p)) {
+		if (!__strcmp(property, ++p)) {
 			return i;
 		}
 		++i;
@@ -886,7 +886,7 @@ wctrans_t wctrans(const char *property)
 	p = transstring;
 	i = 1;
 	do {
-		if (!strcmp(property, ++p)) {
+		if (!__strcmp(property, ++p)) {
 			return i;
 		}
 		++i;

libc/misc/wordexp/wordexp.c

@@ -19,7 +19,7 @@
    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#define mempcpy __libc_mempcpy
+#define mempcpy __mempcpy
 #define strndup __strndup
 #define strspn __strspn
 #define unsetenv __unsetenv
@@ -135,7 +135,7 @@ static char *w_addstr(char *buffer, size_t * actlen, size_t * maxlen,
 {
 	size_t len;
 	assert(str != NULL);		/* w_addstr only called from this file */
-	len = strlen(str);
+	len = __strlen(str);
 
 	return w_addmem(buffer, actlen, maxlen, str, len);
 }
@@ -150,7 +150,7 @@ static int w_addword(wordexp_t * pwordexp, char *word)
 	 * the caller sees them.
 	 */
 	if (word == NULL) {
-		word = strdup("");
+		word = __strdup("");
 		if (word == NULL)
 			goto no_space;
 	}
@@ -252,7 +252,7 @@ parse_tilde(char **word, size_t * word_length, size_t * max_length,
 	if (*word_length != 0) {
 		if (!((*word)[*word_length - 1] == '=' && wordc == 0)) {
 			if (!((*word)[*word_length - 1] == ':'
-				  && strchr(*word, '=') && wordc == 0)) {
+				  && __strchr(*word, '=') && wordc == 0)) {
 				*word = w_addchar(*word, word_length, max_length, '~');
 				return *word ? 0 : WRDE_NOSPACE;
 			}
@@ -377,7 +377,7 @@ do_parse_glob(const char *glob_word, char **word, size_t * word_length,
 	}
 
 	for (match = 0; match < globbuf.gl_pathc; ++match) {
-		char *matching_word = strdup(globbuf.gl_pathv[match]);
+		char *matching_word = __strdup(globbuf.gl_pathv[match]);
 
 		if (matching_word == NULL || w_addword(pwordexp, matching_word)) {
 			globfree(&globbuf);
@@ -404,8 +404,8 @@ parse_glob(char **word, size_t * word_length, size_t * max_length,
 	glob_list.we_wordv = NULL;
 	glob_list.we_offs = 0;
 	for (; words[*offset] != '\0'; ++*offset) {
-		if ((ifs && strchr(ifs, words[*offset])) ||
-			(!ifs && strchr(" \t\n", words[*offset])))
+		if ((ifs && __strchr(ifs, words[*offset])) ||
+			(!ifs && __strchr(" \t\n", words[*offset])))
 			/* Reached IFS */
 			break;
 
@@ -762,24 +762,24 @@ exec_comm_child(char *comm, int *fildes, int showerr, int noexec)
 
 	/* Redirect output.  */
 	dup2(fildes[1], 1);
-	close(fildes[1]);
+	__close(fildes[1]);
 
 	/* Redirect stderr to /dev/null if we have to.  */
 	if (showerr == 0) {
 		int fd;
 
-		close(2);
-		fd = open(_PATH_DEVNULL, O_WRONLY);
+		__close(2);
+		fd = __open(_PATH_DEVNULL, O_WRONLY);
 		if (fd >= 0 && fd != 2) {
 			dup2(fd, 2);
-			close(fd);
+			__close(fd);
 		}
 	}
 
 	/* Make sure the subshell doesn't field-split on our behalf. */
 	unsetenv("IFS");
 
-	close(fildes[0]);
+	__close(fildes[0]);
 	execve(_PATH_BSHELL, (char *const *) args, __environ);
 
 	/* Bad.  What now?  */
@@ -812,8 +812,8 @@ exec_comm(char *comm, char **word, size_t * word_length,
 
 	if ((pid = fork()) < 0) {
 		/* Bad */
-		close(fildes[0]);
-		close(fildes[1]);
+		__close(fildes[0]);
+		__close(fildes[1]);
 		return WRDE_NOSPACE;
 	}
 
@@ -822,17 +822,17 @@ exec_comm(char *comm, char **word, size_t * word_length,
 
 	/* Parent */
 
-	close(fildes[1]);
+	__close(fildes[1]);
 	buffer = alloca(bufsize);
 
 	if (!pwordexp)
 		/* Quoted - no field splitting */
 	{
 		while (1) {
-			if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
+			if ((buflen = __read(fildes[0], buffer, bufsize)) < 1) {
 				if (waitpid(pid, &status, WNOHANG) == 0)
 					continue;
-				if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
+				if ((buflen = __read(fildes[0], buffer, bufsize)) < 1)
 					break;
 			}
 
@@ -855,17 +855,17 @@ exec_comm(char *comm, char **word, size_t * word_length,
 		 */
 
 		while (1) {
-			if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
+			if ((buflen = __read(fildes[0], buffer, bufsize)) < 1) {
 				if (waitpid(pid, &status, WNOHANG) == 0)
 					continue;
-				if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
+				if ((buflen = __read(fildes[0], buffer, bufsize)) < 1)
 					break;
 			}
 
 			for (i = 0; i < buflen; ++i) {
-				if (strchr(ifs, buffer[i]) != NULL) {
+				if (__strchr(ifs, buffer[i]) != NULL) {
 					/* Current character is IFS */
-					if (strchr(ifs_white, buffer[i]) == NULL) {
+					if (__strchr(ifs_white, buffer[i]) == NULL) {
 						/* Current character is IFS but not whitespace */
 						if (copying == 2) {
 							/*            current character
@@ -959,7 +959,7 @@ exec_comm(char *comm, char **word, size_t * word_length,
 		}
 	}
 
-	close(fildes[0]);
+	__close(fildes[0]);
 
 	/* Check for syntax error (re-execute but with "-n" flag) */
 	if (buflen < 1 && status != 0) {
@@ -982,7 +982,7 @@ exec_comm(char *comm, char **word, size_t * word_length,
   no_space:
 	kill(pid, SIGKILL);
 	waitpid(pid, NULL, 0);
-	close(fildes[0]);
+	__close(fildes[0]);
 	return WRDE_NOSPACE;
 }
 
@@ -1181,7 +1181,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 				goto envsubst;
 		}
 		while (isdigit(words[++*offset]));
-	} else if (strchr("*@$", words[*offset]) != NULL) {
+	} else if (__strchr("*@$", words[*offset]) != NULL) {
 		/* Special parameter. */
 		special = 1;
 		env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
@@ -1217,7 +1217,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 			break;
 
 		case ':':
-			if (strchr("-=?+", words[1 + *offset]) == NULL)
+			if (__strchr("-=?+", words[1 + *offset]) == NULL)
 				goto syntax;
 
 			colon_seen = 1;
@@ -1349,7 +1349,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 
 			/* Build up value parameter by parameter (copy them) */
 			for (p = 1; __libc_argv[p]; ++p)
-				plist_len += strlen(__libc_argv[p]) + 1;	/* for space */
+				plist_len += __strlen(__libc_argv[p]) + 1;	/* for space */
 			value = malloc(plist_len);
 			if (value == NULL)
 				goto no_space;
@@ -1379,7 +1379,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 					goto no_space;
 
 				for (p = 2; __libc_argv[p + 1]; p++) {
-					char *newword = strdup(__libc_argv[p]);
+					char *newword = __strdup(__libc_argv[p]);
 
 					if (newword == NULL || w_addword(pwordexp, newword))
 						goto no_space;
@@ -1559,7 +1559,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 			if (value == NULL || pattern == NULL || *pattern == '\0')
 				break;
 
-			end = value + strlen(value);
+			end = value + __strlen(value);
 
 			switch (action) {
 			case ACT_RP_SHORT_LEFT:
@@ -1569,7 +1569,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 					if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
 						*p = c;
 						if (free_value) {
-							char *newval = strdup(p);
+							char *newval = __strdup(p);
 
 							if (newval == NULL) {
 								free(value);
@@ -1593,7 +1593,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 					if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
 						*p = c;
 						if (free_value) {
-							char *newval = strdup(p);
+							char *newval = __strdup(p);
 
 							if (newval == NULL) {
 								free(value);
@@ -1697,7 +1697,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 				/* Substitute NULL */
 				goto success;
 
-			value = pattern ? strdup(pattern) : pattern;
+			value = pattern ? __strdup(pattern) : pattern;
 			free_value = 1;
 
 			if (pattern && !value)
@@ -1710,7 +1710,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 				if (free_value && value)
 					free(value);
 
-				value = pattern ? strdup(pattern) : pattern;
+				value = pattern ? __strdup(pattern) : pattern;
 				free_value = 1;
 
 				if (pattern && !value)
@@ -1739,7 +1739,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 			if (free_value && value)
 				free(value);
 
-			value = pattern ? strdup(pattern) : pattern;
+			value = pattern ? __strdup(pattern) : pattern;
 			free_value = 1;
 
 			if (pattern && !value)
@@ -1763,7 +1763,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 
 		param_length[20] = '\0';
 		*word = w_addstr(*word, word_length, max_length,
-						 _itoa(value ? strlen(value) : 0,
+						 _itoa(value ? __strlen(value) : 0,
 									&param_length[20]));
 		if (free_value) {
 			assert(value != NULL);
@@ -1785,7 +1785,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 		return *word ? 0 : WRDE_NOSPACE;
 	} else {
 		/* Need to field-split */
-		char *value_copy = strdup(value);	/* Don't modify value */
+		char *value_copy = __strdup(value);	/* Don't modify value */
 		char *field_begin = value_copy;
 		int seen_nonws_ifs = 0;
 
@@ -1825,7 +1825,7 @@ parse_param(char **word, size_t * word_length, size_t * max_length,
 
 			/* Skip at most one non-whitespace IFS character after the field */
 			seen_nonws_ifs = 0;
-			if (*next_field && strchr(ifs, *next_field)) {
+			if (*next_field && __strchr(ifs, *next_field)) {
 				seen_nonws_ifs = 1;
 				next_field++;
 			}
@@ -2071,7 +2071,7 @@ int wordexp(const char *words, wordexp_t * we, int flags)
 
 	if (!ifs)
 		/* IFS unset - use <space><tab><newline>. */
-		ifs = strcpy(ifs_white, " \t\n");
+		ifs = __strcpy(ifs_white, " \t\n");
 	else {
 		char *ifsch = ifs;
 		char *whch = ifs_white;
@@ -2190,11 +2190,11 @@ int wordexp(const char *words, wordexp_t * we, int flags)
 
 		default:
 			/* Is it a word separator? */
-			if (strchr(" \t", words[words_offset]) == NULL) {
+			if (__strchr(" \t", words[words_offset]) == NULL) {
 				char ch = words[words_offset];
 
 				/* Not a word separator -- but is it a valid word char? */
-				if (strchr("\n|&;<>(){}", ch)) {
+				if (__strchr("\n|&;<>(){}", ch)) {
 					/* Fail */
 					error = WRDE_BADCHAR;
 					goto do_error;

libc/pwd_grp/lckpwdf.c

@@ -64,7 +64,7 @@ int lckpwdf (void)
 
 	LOCK;
 
-	lock_fd = open (_PATH_PASSWD, O_WRONLY);
+	lock_fd = __open (_PATH_PASSWD, O_WRONLY);
 	if (lock_fd == -1) {
 		/* Cannot create lock file.  */
 		UNLOCK;
@@ -75,7 +75,7 @@ int lckpwdf (void)
 	flags = fcntl (lock_fd, F_GETFD, 0);
 	if (flags == -1) {
 		/* Cannot get file flags.  */
-		close(lock_fd);
+		__close(lock_fd);
 		lock_fd = -1;
 		UNLOCK;
 		return -1;
@@ -83,7 +83,7 @@ int lckpwdf (void)
 	flags |= FD_CLOEXEC;		/* Close on exit.  */
 	if (fcntl (lock_fd, F_SETFD, flags) < 0) {
 		/* Cannot set new flags.  */
-		close(lock_fd);
+		__close(lock_fd);
 		lock_fd = -1;
 		UNLOCK;
 		return -1;
@@ -97,7 +97,7 @@ int lckpwdf (void)
 
 	   It is important that we don't change the signal state.  We must
 	   restore the old signal behaviour.  */
-	memset (&new_act, '\0', sizeof (struct sigaction));
+	__memset (&new_act, '\0', sizeof (struct sigaction));
 	new_act.sa_handler = noop_handler;
 	sigfillset (&new_act.sa_mask);
 	new_act.sa_flags = 0ul;
@@ -105,7 +105,7 @@ int lckpwdf (void)
 	/* Install new action handler for alarm and save old.  */
 	if (sigaction (SIGALRM, &new_act, &saved_act) < 0) {
 		/* Cannot install signal handler.  */
-		close(lock_fd);
+		__close(lock_fd);
 		lock_fd = -1;
 		UNLOCK;
 		return -1;
@@ -114,9 +114,9 @@ int lckpwdf (void)
 	/* Now make sure the alarm signal is not blocked.  */
 	sigemptyset (&new_set);
 	sigaddset (&new_set, SIGALRM);
-	if (sigprocmask (SIG_UNBLOCK, &new_set, &saved_set) < 0) {
+	if (__sigprocmask (SIG_UNBLOCK, &new_set, &saved_set) < 0) {
 		sigaction (SIGALRM, &saved_act, NULL);
-		close(lock_fd);
+		__close(lock_fd);
 		lock_fd = -1;
 		UNLOCK;
 		return -1;
@@ -127,7 +127,7 @@ int lckpwdf (void)
 	alarm (TIMEOUT);
 
 	/* Try to get the lock.  */
-	memset (&fl, '\0', sizeof (struct flock));
+	__memset (&fl, '\0', sizeof (struct flock));
 	fl.l_type = F_WRLCK;
 	fl.l_whence = SEEK_SET;
 	result = fcntl (lock_fd, F_SETLKW, &fl);
@@ -137,14 +137,14 @@ int lckpwdf (void)
 
 	/* Restore old set of handled signals.  We don't need to know
 	   about the current one.*/
-	sigprocmask (SIG_SETMASK, &saved_set, NULL);
+	__sigprocmask (SIG_SETMASK, &saved_set, NULL);
 
 	/* Restore old action handler for alarm.  We don't need to know
 	   about the current one.  */
 	sigaction (SIGALRM, &saved_act, NULL);
 
 	if (result < 0) {
-		close(lock_fd);
+		__close(lock_fd);
 		lock_fd = -1;
 		UNLOCK;
 		return -1;
@@ -165,7 +165,7 @@ int ulckpwdf (void)
 	}
 	else {
 		LOCK;
-		result = close (lock_fd);
+		result = __close (lock_fd);
 		/* Mark descriptor as unused.  */
 		lock_fd = -1;
 		UNLOCK;

libc/pwd_grp/pwd_grp.c

@@ -190,10 +190,10 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 	}
 
 	if (string != buffer) {
-		if (strlen(string) >= buflen) {
+		if (__strlen(string) >= buflen) {
 			goto DO_ERANGE;
 		}
-		strcpy(buffer, string);
+		__strcpy(buffer, string);
 	}
 
 	if (!(rv = __parsespent(result_buf, buffer))) {
@@ -215,7 +215,7 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 #define GETXXKEY_R_FUNC			getpwnam_r
 #define GETXXKEY_R_PARSER   	__parsepwent
 #define GETXXKEY_R_ENTTYPE		struct passwd
-#define GETXXKEY_R_TEST(ENT)	(!strcmp((ENT)->pw_name, key))
+#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
 #include "pwd_grp_internal.c"
@@ -225,7 +225,7 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 #define GETXXKEY_R_FUNC			getgrnam_r
 #define GETXXKEY_R_PARSER   	__parsegrent
 #define GETXXKEY_R_ENTTYPE		struct group
-#define GETXXKEY_R_TEST(ENT)	(!strcmp((ENT)->gr_name, key))
+#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
 #include "pwd_grp_internal.c"
@@ -235,7 +235,7 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 #define GETXXKEY_R_FUNC			getspnam_r
 #define GETXXKEY_R_PARSER   	__parsespent
 #define GETXXKEY_R_ENTTYPE		struct spwd
-#define GETXXKEY_R_TEST(ENT)	(!strcmp((ENT)->sp_namp, key))
+#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
 #include "pwd_grp_internal.c"
@@ -658,7 +658,7 @@ int initgroups(const char *user, gid_t gid)
 			assert(group.gr_mem); /* Must have at least a NULL terminator. */
 			if (group.gr_gid != gid) {
 				for (m=group.gr_mem ; *m ; m++) {
-					if (!strcmp(*m, user)) {
+					if (!__strcmp(*m, user)) {
 						if (!(num_groups & 7)) {
 							gid_t *tmp = (gid_t *)
 								realloc(group_list,
@@ -851,7 +851,7 @@ int attribute_hidden __parsepwent(void *data, char *line)
 			/* NOTE: glibc difference - glibc allows omission of
 			 * ':' seperators after the gid field if all remaining
 			 * entries are empty.  We require all separators. */
-			if (!(line = strchr(line, ':'))) {
+			if (!(line = __strchr(line, ':'))) {
 				break;
 			}
 		} else {
@@ -903,7 +903,7 @@ int attribute_hidden __parsegrent(void *data, char *line)
 
 		if (i < 2) {
 			*((char **) p) = line;
-			if (!(line = strchr(line, ':'))) {
+			if (!(line = __strchr(line, ':'))) {
 				break;
 			}
 			*line++ = 0;
@@ -1003,7 +1003,7 @@ int attribute_hidden __parsespent(void *data, char * line)
 		p = ((char *) ((struct spwd *) data)) + sp_off[i];
 		if (i < 2) {
 			*((char **) p) = line;
-			if (!(line = strchr(line, ':'))) {
+			if (!(line = __strchr(line, ':'))) {
 				break;
 			}
 		} else {
@@ -1080,7 +1080,7 @@ int attribute_hidden __pgsreader(int (*__parserfunc)(void *d, char *line), void
 				break;
 			}
 
-			line_len = strlen(line_buff) - 1; /* strlen() must be > 0. */
+			line_len = __strlen(line_buff) - 1; /* strlen() must be > 0. */
 			if (line_buff[line_len] == '\n') {
 				line_buff[line_len] = 0;
 			} else if (line_len + 2 == buflen) { /* line too long */

libc/signal/sigaction.c

@@ -45,7 +45,7 @@ __libc_sigaction (sig, act, oact)
 
 	if (act) {
 		kact.k_sa_handler = act->sa_handler;
-		memcpy (&kact.sa_mask, &act->sa_mask, sizeof (kact.sa_mask));
+		__memcpy (&kact.sa_mask, &act->sa_mask, sizeof (kact.sa_mask));
 		kact.sa_flags = act->sa_flags;
 # ifdef HAVE_SA_RESTORER
 		kact.sa_restorer = act->sa_restorer;
@@ -60,7 +60,7 @@ __libc_sigaction (sig, act, oact)
 
 	if (oact && result >= 0) {
 		oact->sa_handler = koact.k_sa_handler;
-		memcpy (&oact->sa_mask, &koact.sa_mask, sizeof (oact->sa_mask));
+		__memcpy (&oact->sa_mask, &koact.sa_mask, sizeof (oact->sa_mask));
 		oact->sa_flags = koact.sa_flags;
 # ifdef HAVE_SA_RESTORER
 		oact->sa_restorer = koact.sa_restorer;

libc/signal/sigblock.c

@@ -29,7 +29,7 @@ int __sigblock (int mask)
   if (sigset_set_old_mask (&set, mask) < 0)
     return -1;
 
-  if (sigprocmask (SIG_BLOCK, &set, &oset) < 0)
+  if (__sigprocmask (SIG_BLOCK, &set, &oset) < 0)
     return -1;
 
   return sigset_get_old_mask (&oset);

libc/signal/sigempty.c

@@ -31,7 +31,7 @@ sigemptyset (set)
       return -1;
     }
 
-  memset (set, 0, sizeof (sigset_t));
+  __memset (set, 0, sizeof (sigset_t));
 
   return 0;
 }

libc/signal/sigfillset.c

@@ -31,7 +31,7 @@ sigfillset (set)
       return -1;
     }
 
-  memset (set, 0xff, sizeof (sigset_t));
+  __memset (set, 0xff, sizeof (sigset_t));
 
   /* If the implementation uses a cancellation signal don't set the bit.  */
 #ifdef SIGCANCEL

libc/signal/sighold.c

@@ -30,7 +30,7 @@ sighold (sig)
   sigset_t set;
 
   /* Retrieve current signal set.  */
-  if (sigprocmask (SIG_SETMASK, NULL, &set) < 0)
+  if (__sigprocmask (SIG_SETMASK, NULL, &set) < 0)
     return -1;
 
   /* Add the specified signal.  */
@@ -38,5 +38,5 @@ sighold (sig)
     return -1;
 
   /* Set the new mask.  */
-  return sigprocmask (SIG_SETMASK, &set, NULL);
+  return __sigprocmask (SIG_SETMASK, &set, NULL);
 }

libc/signal/sigjmp.c

@@ -27,7 +27,7 @@
 int __sigjmp_save (sigjmp_buf env, int savemask)
 {
     env[0].__mask_was_saved = (savemask && 
-	    sigprocmask (SIG_BLOCK, (sigset_t *) NULL, &env[0].__saved_mask) == 0);
+	    __sigprocmask (SIG_BLOCK, (sigset_t *) NULL, &env[0].__saved_mask) == 0);
 
     return 0;
 }

libc/signal/sigpause.c

@@ -32,7 +32,7 @@ int __sigpause (int sig_or_mask, int is_sig)
   if (is_sig != 0)
     {
       /* The modern X/Open implementation is requested.  */
-      if (sigprocmask (0, NULL, &set) < 0
+      if (__sigprocmask (0, NULL, &set) < 0
 	  /* Yes, we call `sigdelset' and not `__sigdelset'.  */
 	  || sigdelset (&set, sig_or_mask) < 0)
 	return -1;

libc/signal/sigrelse.c

@@ -30,7 +30,7 @@ sigrelse (sig)
   sigset_t set;
 
   /* Retrieve current signal set.  */
-  if (sigprocmask (SIG_SETMASK, NULL, &set) < 0)
+  if (__sigprocmask (SIG_SETMASK, NULL, &set) < 0)
     return -1;
 
   /* Remove the specified signal.  */
@@ -38,5 +38,5 @@ sigrelse (sig)
     return -1;
 
   /* Set the new mask.  */
-  return sigprocmask (SIG_SETMASK, &set, NULL);
+  return __sigprocmask (SIG_SETMASK, &set, NULL);
 }

libc/signal/sigset.c

@@ -46,7 +46,7 @@ sigset (sig, disp)
 	return SIG_ERR;
 
       /* Add the signal set to the current signal mask.  */
-      if (sigprocmask (SIG_BLOCK, &set, NULL) < 0)
+      if (__sigprocmask (SIG_BLOCK, &set, NULL) < 0)
 	return SIG_ERR;
 
       return SIG_HOLD;
@@ -76,7 +76,7 @@ sigset (sig, disp)
     return SIG_ERR;
 
   /* Remove the signal set from the current signal mask.  */
-  if (sigprocmask (SIG_UNBLOCK, &set, NULL) < 0)
+  if (__sigprocmask (SIG_UNBLOCK, &set, NULL) < 0)
     return SIG_ERR;
 
   return oact.sa_handler;

libc/signal/sigsetmask.c

@@ -30,7 +30,7 @@ __sigsetmask (int mask)
   if (sigset_set_old_mask (&set, mask) < 0)
     return -1;
 
-  if (sigprocmask (SIG_SETMASK, &set, &oset) < 0)
+  if (__sigprocmask (SIG_SETMASK, &set, &oset) < 0)
     return -1;
 
 

libc/stdio/_cs_funcs.c

@@ -13,14 +13,14 @@
 
 ssize_t attribute_hidden _cs_read(void *cookie, char *buf, size_t bufsize)
 {
-	return read(*((int *) cookie), buf, bufsize);
+	return __read(*((int *) cookie), buf, bufsize);
 }
 
 /**********************************************************************/
 
 ssize_t attribute_hidden _cs_write(void *cookie, const char *buf, size_t bufsize)
 {
-	return write(*((int *) cookie), (char *) buf, bufsize);
+	return __write(*((int *) cookie), (char *) buf, bufsize);
 }
 
 /**********************************************************************/
@@ -42,7 +42,7 @@ int attribute_hidden _cs_seek(void *cookie, register __offmax_t *pos, int whence
 
 int attribute_hidden _cs_close(void *cookie)
 {
-	return close(*((int *) cookie));
+	return __close(*((int *) cookie));
 }
 
 /**********************************************************************/

libc/stdio/_fopen.c

@@ -128,7 +128,7 @@ FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode,
 										& O_LARGEFILE) );
 	} else {
 		__STDIO_WHEN_LFS( if (filedes < -1) open_mode |= O_LARGEFILE );
-		if ((stream->__filedes = open(((const char *) fname_or_mode),
+		if ((stream->__filedes = __open(((const char *) fname_or_mode),
 									  open_mode, 0666)) < 0) {
 			goto FREE_STREAM;
 		}

libc/stdio/_fpmaxtostr.c

@@ -417,7 +417,7 @@ ssize_t attribute_hidden _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info
 	if (mode == 'f') {
 		round += exp;
 		if (round < -1) {
-			memset(buf, '0', DECIMAL_DIG); /* OK, since 'f' -> decimal case. */
+			__memset(buf, '0', DECIMAL_DIG); /* OK, since 'f' -> decimal case. */
 		    exp = -1;
 		    round = -1;
 		}

libc/stdio/_fwrite.c

@@ -35,7 +35,7 @@ size_t attribute_hidden __stdio_fwrite(const unsigned char * __restrict buffer,
 			if (pending > bytes) {
 				pending = bytes;
 			}
-			memcpy(stream->__bufpos, buffer, pending);
+			__memcpy(stream->__bufpos, buffer, pending);
 			stream->__bufpos += pending;
 			__STDIO_STREAM_VALIDATE(stream);
 			return bytes;
@@ -43,7 +43,7 @@ size_t attribute_hidden __stdio_fwrite(const unsigned char * __restrict buffer,
 
 /* 	RETRY: */
 		if (bytes <= __STDIO_STREAM_BUFFER_WAVAIL(stream)) {
-			memcpy(stream->__bufpos, buffer, bytes);
+			__memcpy(stream->__bufpos, buffer, bytes);
 			stream->__bufpos += bytes;
 			if (__STDIO_STREAM_IS_LBF(stream)
 				&& memrchr(buffer, '\n', bytes)	/* Search backwards. */

libc/stdio/_stdio.c

@@ -167,7 +167,7 @@ void attribute_hidden __stdio_init_mutex(pthread_mutex_t *m)
 	static const pthread_mutex_t __stdio_mutex_initializer
 		= PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 
-	memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
+	__memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
 }
 
 #endif

libc/stdio/_uintmaxtostr.c

@@ -61,7 +61,7 @@ char attribute_hidden *__libc__uintmaxtostr(register char * __restrict bufend, u
 #ifndef __LOCALE_C_ONLY
 		if (!grouping) {		/* Finished a group. */
 			bufend -= __UCLIBC_CURLOCALE_DATA.thousands_sep_len;
-			memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep,
+			__memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep,
 				   __UCLIBC_CURLOCALE_DATA.thousands_sep_len);
 			if (g[1] != 0) { 	/* g[1] == 0 means repeat last grouping. */
 				/* Note: g[1] == -1 means no further grouping.  But since
@@ -79,7 +79,7 @@ char attribute_hidden *__libc__uintmaxtostr(register char * __restrict bufend, u
 #ifndef __LOCALE_C_ONLY
 		if (unlikely(outdigit)) {
 			bufend -= __UCLIBC_CURLOCALE_DATA.outdigit_length[digit];
-			memcpy(bufend,
+			__memcpy(bufend,
 				   (&__UCLIBC_CURLOCALE_DATA.outdigit0_mb)[digit],
 				   __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]);
 		} else
@@ -104,7 +104,7 @@ char attribute_hidden *__libc__uintmaxtostr(register char * __restrict bufend, u
 #ifndef __LOCALE_C_ONLY
 		if (!grouping) {		/* Finished a group. */
 			bufend -= __UCLIBC_CURLOCALE_DATA.thousands_sep_len;
-			memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep,
+			__memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep,
 				   __UCLIBC_CURLOCALE_DATA.thousands_sep_len);
 			if (g[1] != 0) { 	/* g[1] == 0 means repeat last grouping. */
 				/* Note: g[1] == -1 means no further grouping.  But since
@@ -131,7 +131,7 @@ char attribute_hidden *__libc__uintmaxtostr(register char * __restrict bufend, u
 #ifndef __LOCALE_C_ONLY
 		if (unlikely(outdigit)) {
 			bufend -= __UCLIBC_CURLOCALE_DATA.outdigit_length[digit];
-			memcpy(bufend,
+			__memcpy(bufend,
 				   (&__UCLIBC_CURLOCALE_DATA.outdigit0_mb)[digit],
 				   __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]);
 		} else

libc/stdio/ctermid.c

@@ -21,6 +21,6 @@ char *ctermid(register char *s)
 	return s;
 #else
 	/* glibc always returns /dev/tty for linux. */
-	return strcpy((s ? s : sbuf), "/dev/tty");
+	return __strcpy((s ? s : sbuf), "/dev/tty");
 #endif
 }

libc/stdio/fmemopen.c

@@ -35,7 +35,7 @@ static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize)
 		bufsize = count;
 	}
 
-	memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize);
+	__memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize);
 	COOKIE->pos += bufsize;
 
 	return bufsize;
@@ -62,7 +62,7 @@ static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize)
 		}
 	}
 
-	memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
+	__memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
 	COOKIE->pos += bufsize;
 
 	if (COOKIE->pos > COOKIE->eof) {

libc/stdio/fputs.c

@@ -17,7 +17,7 @@
 int attribute_hidden __fputs_unlocked(register const char * __restrict s,
 					 FILE * __restrict stream)
 {
-	size_t n = strlen(s);
+	size_t n = __strlen(s);
 
 	return ((__fwrite_unlocked(s, 1, n, stream) == n) ? n : EOF);
 }

libc/stdio/fread.c

@@ -44,7 +44,7 @@ size_t attribute_hidden __fread_unlocked(void * __restrict ptr, size_t size, siz
 				if (avail > todo) {
 					avail = todo;
 				}
-				memcpy(buffer, stream->__bufpos, avail);
+				__memcpy(buffer, stream->__bufpos, avail);
 				buffer += avail;
 				stream->__bufpos += avail;
 				if (!(todo -= avail)) {

libc/stdio/old_vfprintf.c

@@ -191,7 +191,7 @@ static void _outnstr(FILE *stream, const unsigned char *s, size_t n)
 		if (r > n) {
 			r = n;
 		}
-		memcpy(f->bufpos, s, r);
+		__memcpy(f->bufpos, s, r);
 		f->bufpos += r;
 	}
 }
@@ -237,7 +237,7 @@ static void _charpad(FILE * __restrict stream, int padchar, size_t numpad)
 static void _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf)
 {
 	if (type & 0x80) {			/* Some type of padding needed. */
-		int buflen = strlen((const char *) buf);
+		int buflen = __strlen((const char *) buf);
 		if ((len -= buflen) > 0) {
 			_charpad(fp, (type & 0x7f), len);
 		}

libc/stdio/open_memstream.c

@@ -51,7 +51,7 @@ static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize)
 		}
 	}
 
-	memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
+	__memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
 	COOKIE->pos += bufsize;
 
 	if (COOKIE->pos > COOKIE->eof) {
@@ -90,7 +90,7 @@ static int oms_seek(register void *cookie, __offmax_t *pos, int whence)
 		if (buf) {
 			*COOKIE->bufloc = COOKIE->buf = buf;
 			COOKIE->len = leastlen;
-			memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */
+			__memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */
 		} else {
 			/* TODO: check glibc errno setting... */
 			return -1;
@@ -100,7 +100,7 @@ static int oms_seek(register void *cookie, __offmax_t *pos, int whence)
 	*pos = COOKIE->pos = --leastlen;
 
 	if (leastlen > COOKIE->eof) {
-		memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0);
+		__memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0);
 		*COOKIE->sizeloc = COOKIE->eof;
 	}
 

libc/stdio/popen.c

@@ -84,23 +84,23 @@ FILE *popen(const char *command, const char *modes)
 	parent_fd = pipe_fd[1-child_writing];
 
 	if (!(fp = fdopen(parent_fd, modes))) {
-		close(parent_fd);
-		close(child_fd);
+		__close(parent_fd);
+		__close(child_fd);
 		goto FREE_PI;
 	}
 
 	VFORK_LOCK;
 	if ((pid = vfork()) == 0) {	/* Child of vfork... */
-		close(parent_fd);
+		__close(parent_fd);
 		if (child_fd != child_writing) {
 			dup2(child_fd, child_writing);
-			close(child_fd);
+			__close(child_fd);
 		}
 
 		/* SUSv3 requires that any previously popen()'d streams in the
 		 * parent shall be closed in the child. */
 		for (po = popen_list ; po ; po = po->next) {
-			close(po->f->__filedes);
+			__close(po->f->__filedes);
 		}
 
 		execl("/bin/sh", "sh", "-c", command, (char *)0);
@@ -113,7 +113,7 @@ FILE *popen(const char *command, const char *modes)
 
 	/* We need to close the child filedes whether vfork failed or
 	 * it succeeded and we're in the parent. */
-	close(child_fd);
+	__close(child_fd);
 
 	if (pid > 0) {				/* Parent of vfork... */
 		pi->pid = pid;

libc/stdio/scanf.c

@@ -246,7 +246,7 @@ int vsscanf(__const char *sp, __const char *fmt, va_list ap)
 	f.__bufstart = 
 	f.__bufpos = (unsigned char *) ((void *) sp);
 	f.__bufread =
-	f.__bufend = f.__bufstart + strlen(sp);
+	f.__bufend = f.__bufstart + __strlen(sp);
 	__STDIO_STREAM_ENABLE_GETC(&f);
 	__STDIO_STREAM_DISABLE_PUTC(&f);
 
@@ -260,7 +260,7 @@ int vsscanf(__const char *sp, __const char *fmt, va_list ap)
 	__FILE_vsscanf f;
 
 	f.bufpos = (unsigned char *) ((void *) sp);
-	f.bufread = f.bufpos + strlen(sp);
+	f.bufread = f.bufpos + __strlen(sp);
 
 /* 	__STDIO_STREAM_RESET_GCS(&f.f); */
 #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
@@ -298,7 +298,7 @@ int vsscanf(__const char *sp, __const char *fmt, va_list ap)
 	FILE *f;
 	int rv = EOF;
 
-	if ((f = fmemopen((char *)sp, strlen(sp), "r")) != NULL) {
+	if ((f = fmemopen((char *)sp, __strlen(sp), "r")) != NULL) {
 		rv = vfscanf(f, fmt, ap);
 		fclose(f);
 	}
@@ -1188,7 +1188,7 @@ int VFSCANF (FILE *__restrict fp, const Wchar *__restrict format, va_list arg)
 #if defined(NL_ARGMAX) && (NL_ARGMAX > 0)
 	psfs.num_pos_args = -1;		/* Must start at -1. */
 	/* Initialize positional arg ptrs to NULL. */
-	memset(psfs.pos_args, 0, sizeof(psfs.pos_args));
+	__memset(psfs.pos_args, 0, sizeof(psfs.pos_args));
 #endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */
 
 	__STDIO_AUTO_THREADLOCK(fp);
@@ -1420,7 +1420,7 @@ int VFSCANF (FILE *__restrict fp, const Wchar *__restrict format, va_list arg)
 						++fmt;
 						invert = 1;
  					}
-					memset(scanset, invert, sizeof(scanset));
+					__memset(scanset, invert, sizeof(scanset));
 					invert = 1-invert;
 
 					if (*fmt == ']') {
@@ -1969,14 +1969,14 @@ int attribute_hidden __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc)
 
 							if ((psfs->conv_num > CONV_i) /* float conversion */
 								&& (!pass || (i == nblk1)) /* possible last */
-								&& !memcmp(sc->thousands_sep, sc->fake_decpt, k)
+								&& !__memcmp(sc->thousands_sep, sc->fake_decpt, k)
 								/* and prefix matched, so could be decpt */
 								) {
 								__scan_getc(sc);
 								p = sc->fake_decpt + k;
 								do {
 									if (!*++p) {
-										strcpy(b, sc->decpt);
+										__strcpy(b, sc->decpt);
 										b += sc->decpt_len;
 										goto GOT_DECPT;
 									}
@@ -2070,7 +2070,7 @@ int attribute_hidden __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc)
 	p = sc->fake_decpt;
 	do {
 		if (!*p) {
-			strcpy(b, sc->decpt);
+			__strcpy(b, sc->decpt);
 			b += sc->decpt_len;
 			break;
 		}

libc/stdio/tempnam.c

@@ -38,6 +38,6 @@ tempnam (const char *dir, const char *pfx)
   if (__gen_tempname (buf, __GT_NOCREATE))
     return NULL;
 
-  return strdup (buf);
+  return __strdup (buf);
 }
 

libc/stdio/tmpfile.c

@@ -42,7 +42,7 @@ FILE * tmpfile (void)
     (void) remove (buf);
 
     if ((f = fdopen (fd, "w+b")) == NULL)
-	close (fd);
+	__close (fd);
 
     return f;
 }