merge uClibc git master

33 files changed, 363 insertions, 431 deletions

diff --git a/libc/inet/resolv.c b/libc/inet/resolv.c
index cfc1eee9b..31e63810b 100644
--- a/libc/inet/resolv.c
+++ b/libc/inet/resolv.c
@@ -1615,9 +1615,13 @@ int __read_etc_hosts_r(
 #endif
 							;
 	int ret = HOST_NOT_FOUND;
+	/* make sure pointer is aligned */
+	int i = ALIGN_BUFFER_OFFSET(buf);
+	buf += i;
+	buflen -= i;
 
 	*h_errnop = NETDB_INTERNAL;
-	if (buflen < aliaslen
+	if (/* (ssize_t)buflen < 0 || */ buflen < aliaslen
 		|| (buflen - aliaslen) < BUFSZ + 1)
 		return ERANGE;
 	if (parser == NULL)
diff --git a/libc/misc/utmp/Makefile.in b/libc/misc/utmp/Makefile.in
index 535efb150..6c54ade96 100644
--- a/libc/misc/utmp/Makefile.in
+++ b/libc/misc/utmp/Makefile.in
@@ -7,8 +7,8 @@
 
 subdirs += libc/misc/utmp
 
-CSRC-y := utent.c wtent.c
-CSRC-$(UCLIBC_HAS_UTMPX) += utxent.c
+CSRC-y :=
+CSRC-$(if $(findstring y,$(UCLIBC_HAS_UTMP)$(UCLIBC_HAS_UTMPX)),y) += utent.c
 
 MISC_UTMP_DIR := $(top_srcdir)libc/misc/utmp
 MISC_UTMP_OUT := $(top_builddir)libc/misc/utmp
diff --git a/libc/misc/utmp/utent.c b/libc/misc/utmp/utent.c
index a35bb2b84..3671bb05c 100644
--- a/libc/misc/utmp/utent.c
+++ b/libc/misc/utmp/utent.c
@@ -1,3 +1,4 @@
+/* vi: set sw=4 ts=4: */
 /* utent.c <ndf@linux.mit.edu> */
 /* Let it be known that this is very possibly the worst standard ever.  HP-UX
    does one thing, someone else does another, linux another... If anyone
@@ -18,230 +19,211 @@
 #include <paths.h>
 #include <errno.h>
 #include <string.h>
-#include <utmp.h>
-#ifdef __UCLIBC_HAS_UTMPX__
-# include <utmpx.h>
-#endif
+#include "internal/utmp.h"
 #include <not-cancel.h>
-
 #include <bits/uClibc_mutex.h>
+
 __UCLIBC_MUTEX_STATIC(utmplock, PTHREAD_MUTEX_INITIALIZER);
 
 /* Some global crap */
 static int static_fd = -1;
-static struct utmp static_utmp;
-static const char default_file_name[] = _PATH_UTMP;
-static const char *static_ut_name = default_file_name;
+static struct UT static_utmp;
+static const char default_file[] = __DEFAULT_PATH_UTMP;
+static const char *current_file = default_file;
 
 /* This function must be called with the LOCK held */
-static void __setutent_unlocked(void)
+static void __set_unlocked(void)
 {
-    if (static_fd < 0) {
-	static_fd = open_not_cancel_2(static_ut_name, O_RDWR | O_CLOEXEC);
 	if (static_fd < 0) {
-	    static_fd = open_not_cancel_2(static_ut_name, O_RDONLY | O_CLOEXEC);
-	    if (static_fd < 0) {
-		return; /* static_fd remains < 0 */
-	    }
-	}
+		static_fd = open_not_cancel_2(current_file, O_RDWR | O_CLOEXEC);
+		if (static_fd < 0) {
+			static_fd = open_not_cancel_2(current_file, O_RDONLY | O_CLOEXEC);
+			if (static_fd < 0) {
+				return; /* static_fd remains < 0 */
+			}
+		}
 #ifndef __ASSUME_O_CLOEXEC
-	/* Make sure the file will be closed on exec()  */
-	fcntl_not_cancel(static_fd, F_SETFD, FD_CLOEXEC);
+		/* Make sure the file will be closed on exec()  */
+		fcntl_not_cancel(static_fd, F_SETFD, FD_CLOEXEC);
 #endif
-	return;
-    }
-    lseek(static_fd, 0, SEEK_SET);
+		return;
+	}
+	lseek(static_fd, 0, SEEK_SET);
 }
 #if defined __UCLIBC_HAS_THREADS__
-static void __setutent(void)
+void set(void)
 {
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    __setutent_unlocked();
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	__set_unlocked();
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
 }
 #else
-static void __setutent(void);
-strong_alias(__setutent_unlocked,__setutent)
-#endif
-strong_alias(__setutent,setutent)
-
-#ifdef __UCLIBC_HAS_UTMPX__
-strong_alias(__setutent,setutxent)
+strong_alias(__set_unlocked,set)
 #endif
+/* not used in libc_hidden_def(set) */
+other(setutxent,setutent)
 
 /* This function must be called with the LOCK held */
-static struct utmp *__getutent_unlocked(void)
+static struct UT *__get_unlocked(void)
 {
-    if (static_fd < 0) {
-	__setutent();
 	if (static_fd < 0) {
-	    return NULL;
+		__set_unlocked();
+		if (static_fd < 0)
+			return NULL;
 	}
-    }
 
-    if (read_not_cancel(static_fd, &static_utmp, sizeof(static_utmp)) == sizeof(static_utmp)) {
-	return &static_utmp;
-    }
+	if (read_not_cancel(static_fd, &static_utmp,
+				sizeof(static_utmp)) == sizeof(static_utmp)) {
+		return &static_utmp;
+	}
 
-    return NULL;
+	return NULL;
 }
 #if defined __UCLIBC_HAS_THREADS__
-static struct utmp *__getutent(void)
+struct UT *get(void)
 {
-    struct utmp *ret;
+	struct UT *ret;
 
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    ret = __getutent_unlocked();
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
-    return ret;
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	ret = __get_unlocked();
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
+	return ret;
 }
 #else
-static struct utmp *__getutent(void);
-strong_alias(__getutent_unlocked,__getutent)
+strong_alias(__get_unlocked,get)
 #endif
-strong_alias(__getutent,getutent)
+/* not used in libc_hidden_def(get) */
+other(getutxent,getutent)
 
-#ifdef __UCLIBC_HAS_UTMPX__
-struct utmpx *getutxent(void)
+void end(void)
 {
-	return (struct utmpx *) __getutent ();
-}
-#endif
-
-static void __endutent(void)
-{
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    if (static_fd >= 0)
-	close_not_cancel_no_status(static_fd);
-    static_fd = -1;
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	if (static_fd >= 0)
+		close_not_cancel_no_status(static_fd);
+	static_fd = -1;
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
 }
-strong_alias(__endutent,endutent)
-
-#ifdef __UCLIBC_HAS_UTMPX__
-strong_alias(__endutent,endutxent)
-#endif
+/* not used in libc_hidden_def(end) */
+other(endutxent,endutent)
 
 /* This function must be called with the LOCK held */
-static struct utmp *__getutid_unlocked(const struct utmp *utmp_entry)
+static struct UT *__getid_unlocked(const struct UT *utmp_entry)
 {
-    struct utmp *lutmp;
-    unsigned type;
-
-    /* We use the fact that constants we are interested in are: */
-    /* RUN_LVL=1, ... OLD_TIME=4; INIT_PROCESS=5, ... USER_PROCESS=8 */
-    type = utmp_entry->ut_type - 1;
-    type /= 4;
-
-    while ((lutmp = __getutent_unlocked()) != NULL) {
-	if (type == 0 && lutmp->ut_type == utmp_entry->ut_type)	{
-	    /* one of RUN_LVL, BOOT_TIME, NEW_TIME, OLD_TIME */
-	    return lutmp;
+	struct UT *lutmp;
+	unsigned type;
+
+	/* We use the fact that constants we are interested in are: */
+	/* RUN_LVL=1, ... OLD_TIME=4; INIT_PROCESS=5, ... USER_PROCESS=8 */
+	type = utmp_entry->ut_type - 1;
+	type /= 4;
+
+	while ((lutmp = __get_unlocked()) != NULL) {
+		if (type == 0 && lutmp->ut_type == utmp_entry->ut_type)	{
+			/* one of RUN_LVL, BOOT_TIME, NEW_TIME, OLD_TIME */
+			return lutmp;
+		}
+		if (type == 1
+			&& strncmp(lutmp->ut_id, utmp_entry->ut_id,
+						sizeof(lutmp->ut_id)) == 0) {
+			/* INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, DEAD_PROCESS */
+			return lutmp;
+		}
 	}
-	if (type == 1 && strncmp(lutmp->ut_id, utmp_entry->ut_id, sizeof(lutmp->ut_id)) == 0) {
-	    /* INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, DEAD_PROCESS */
-	    return lutmp;
-	}
-    }
 
-    return NULL;
+	return NULL;
 }
 #if defined __UCLIBC_HAS_THREADS__
-static struct utmp *__getutid(const struct utmp *utmp_entry)
+struct UT *getid(const struct UT *utmp_entry)
 {
-    struct utmp *ret;
+	struct UT *ret;
 
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    ret = __getutid_unlocked(utmp_entry);
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
-    return ret;
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	ret = __getid_unlocked(utmp_entry);
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
+	return ret;
 }
 #else
-static struct utmp *__getutid(const struct utmp *utmp_entry);
-strong_alias(__getutid_unlocked,__getutid)
-#endif
-strong_alias(__getutid,getutid)
-
-#ifdef __UCLIBC_HAS_UTMPX__
-struct utmpx *getutxid(const struct utmpx *utmp_entry)
-{
-	return (struct utmpx *) __getutid ((const struct utmp *) utmp_entry);
-}
+strong_alias(__getid_unlocked,getid)
 #endif
+/* not used in libc_hidden_def(getid) */
+other(getutxid,getutid)
 
-static struct utmp *__getutline(const struct utmp *utmp_entry)
+struct UT *getline(const struct UT *utmp_entry)
 {
-    struct utmp *lutmp;
-
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    while ((lutmp = __getutent_unlocked()) != NULL) {
-	if (lutmp->ut_type == USER_PROCESS || lutmp->ut_type == LOGIN_PROCESS) {
-	    if (strncmp(lutmp->ut_line, utmp_entry->ut_line, sizeof(lutmp->ut_line)) == 0) {
-		break;
-	    }
+	struct UT *lutmp;
+
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	while ((lutmp = __get_unlocked()) != NULL) {
+		if (lutmp->ut_type == USER_PROCESS || lutmp->ut_type == LOGIN_PROCESS) {
+			if (strncmp(lutmp->ut_line, utmp_entry->ut_line,
+						sizeof(lutmp->ut_line)) == 0) {
+				break;
+			}
+		}
 	}
-    }
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
-    return lutmp;
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
+	return lutmp;
 }
-strong_alias(__getutline,getutline)
+/* libc_hidden_def(getline) */
+other(getutxline,getutline)
 
-#ifdef __UCLIBC_HAS_UTMPX__
-struct utmpx *getutxline(const struct utmpx *utmp_entry)
+struct UT *putline(const struct UT *utmp_entry)
 {
-	return (struct utmpx *) __getutline ((const struct utmp *) utmp_entry);
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	/* Ignore the return value.  That way, if they've already positioned
+	   the file pointer where they want it, everything will work out. */
+	lseek(static_fd, (off_t) - sizeof(struct UT), SEEK_CUR);
+
+	if (__getid_unlocked(utmp_entry) != NULL)
+		lseek(static_fd, (off_t) - sizeof(struct UT), SEEK_CUR);
+	else
+		lseek(static_fd, (off_t) 0, SEEK_END);
+	if (write(static_fd, utmp_entry, sizeof(struct UT))
+			!= sizeof(struct UT))
+		utmp_entry = NULL;
+
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
+	return (struct UT *)utmp_entry;
 }
-#endif
+/* not used in libc_hidden_def(putline) */
+other(pututxline,pututline)
 
-static struct utmp *__pututline(const struct utmp *utmp_entry)
+int name(const char *new_file)
 {
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    /* Ignore the return value.  That way, if they've already positioned
-       the file pointer where they want it, everything will work out. */
-    lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
-
-    if (__getutid_unlocked(utmp_entry) != NULL)
-	lseek(static_fd, (off_t) - sizeof(struct utmp), SEEK_CUR);
-    else
-	lseek(static_fd, (off_t) 0, SEEK_END);
-    if (write(static_fd, utmp_entry, sizeof(struct utmp)) != sizeof(struct utmp))
-	utmp_entry = NULL;
-
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
-    return (struct utmp *)utmp_entry;
-}
-strong_alias(__pututline,pututline)
+	__UCLIBC_MUTEX_LOCK(utmplock);
+	if (new_file != NULL) {
+		if (current_file != default_file)
+			free((char *)current_file);
+		current_file = strdup(new_file);
+		if (current_file == NULL) {
+			/* We should probably whine about out-of-memory
+			 * errors here...  Instead just reset to the default */
+			current_file = default_file;
+		}
+	}
 
-#ifdef __UCLIBC_HAS_UTMPX__
-struct utmpx *pututxline (const struct utmpx *utmp_entry)
-{
-	return (struct utmpx *) __pututline ((const struct utmp *) utmp_entry);
+	if (static_fd >= 0) {
+		close_not_cancel_no_status(static_fd);
+		static_fd = -1;
+	}
+	__UCLIBC_MUTEX_UNLOCK(utmplock);
+	return 0; /* or maybe return -(current_file != new_file)? */
 }
-#endif
+/* not used in libc_hidden_def(name) */
+other(utmpxname,utmpname)
 
-static int __utmpname(const char *new_ut_name)
+void updw(const char *wtmp_file, const struct UT *lutmp)
 {
-    __UCLIBC_MUTEX_LOCK(utmplock);
-    if (new_ut_name != NULL) {
-	if (static_ut_name != default_file_name)
-	    free((char *)static_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 */
-	    static_ut_name = default_file_name;
+	int fd;
+
+	fd = open_not_cancel_2(wtmp_file, O_APPEND | O_WRONLY);
+	if (fd >= 0) {
+		if (lockf(fd, F_LOCK, 0) == 0) {
+			write_not_cancel(fd, lutmp, sizeof(struct UT));
+			lockf(fd, F_ULOCK, 0);
+			close_not_cancel_no_status(fd);
+		}
 	}
-    }
-
-    if (static_fd >= 0) {
-	close_not_cancel_no_status(static_fd);
-	static_fd = -1;
-    }
-    __UCLIBC_MUTEX_UNLOCK(utmplock);
-    return 0; /* or maybe return -(static_ut_name != new_ut_name)? */
 }
-strong_alias(__utmpname,utmpname)
-
-#ifdef __UCLIBC_HAS_UTMPX__
-strong_alias(__utmpname,utmpxname)
-#endif
+/* not used in libc_hidden_def(updw) */
+other(updwtmpx,updwtmp)
diff --git a/libc/misc/utmp/utxent.c b/libc/misc/utmp/utxent.c
deleted file mode 100644
index 71157ccd8..000000000
--- a/libc/misc/utmp/utxent.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * utexent.c : Support for accessing user accounting database.
- * Copyright (C) 2010 STMicroelectronics Ltd.
- *
- * Author: Salvatore Cro <salvatore.cro@st.com>
- *
- * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
- *
- */
-
-#include <features.h>
-#include <string.h>
-#include <utmpx.h>
-#include <utmp.h>
-
-#if 0 /* moved to utent.c */
-void setutxent(void)
-{
-	setutent ();
-}
-
-void endutxent(void)
-{
-	endutent ();
-}
-
-struct utmpx *getutxent(void)
-{
-	return (struct utmpx *) getutent ();
-}
-
-struct utmpx *getutxid(const struct utmpx *utmp_entry)
-{
-	return (struct utmpx *) getutid ((const struct utmp *) utmp_entry);
-}
-
-struct utmpx *getutxline(const struct utmpx *utmp_entry)
-{
-	return (struct utmpx *) getutline ((const struct utmp *) utmp_entry);
-}
-
-struct utmpx *pututxline (const struct utmpx *utmp_entry)
-{
-	return (struct utmpx *) pututline ((const struct utmp *) utmp_entry);
-}
-
-int utmpxname (const char *new_ut_name)
-{
-	return utmpname (new_ut_name);
-}
-
-/* moved to wtent.c */
-void updwtmpx (const char *wtmpx_file, const struct utmpx *utmpx)
-{
-	updwtmp (wtmpx_file, (const struct utmp *) utmpx);
-}
-#endif
-
-/* Copy the information in UTMPX to UTMP. */
-void getutmp (const struct utmpx *utmpx, struct utmp *utmp)
-{
-#if _HAVE_UT_TYPE - 0
-	utmp->ut_type = utmpx->ut_type;
-#endif
-#if _HAVE_UT_PID - 0
-	utmp->ut_pid = utmpx->ut_pid;
-#endif
-	memcpy (utmp->ut_line, utmpx->ut_line, sizeof (utmp->ut_line));
-	memcpy (utmp->ut_user, utmpx->ut_user, sizeof (utmp->ut_user));
-#if _HAVE_UT_ID - 0
-	memcpy (utmp->ut_id, utmpx->ut_id, sizeof (utmp->ut_id));
-#endif
-#if _HAVE_UT_HOST - 0
-	memcpy (utmp->ut_host, utmpx->ut_host, sizeof (utmp->ut_host));
-#endif
-#if _HAVE_UT_TV - 0
-	utmp->ut_tv.tv_sec = utmpx->ut_tv.tv_sec;
-	utmp->ut_tv.tv_usec = utmpx->ut_tv.tv_usec;
-#else
-	utmp->ut_time = utmpx->ut_time;
-#endif
-}
-
-/* Copy the information in UTMP to UTMPX. */
-void getutmpx (const struct utmp *utmp, struct utmpx *utmpx)
-{
-	memset (utmpx, 0, sizeof (struct utmpx));
-
-#if _HAVE_UT_TYPE - 0
-	utmpx->ut_type = utmp->ut_type;
-#endif
-#if _HAVE_UT_PID - 0
-	utmpx->ut_pid = utmp->ut_pid;
-#endif
-	memcpy (utmpx->ut_line, utmp->ut_line, sizeof (utmp->ut_line));
-	memcpy (utmpx->ut_user, utmp->ut_user, sizeof (utmp->ut_user));
-#if _HAVE_UT_ID - 0
-	memcpy (utmpx->ut_id, utmp->ut_id, sizeof (utmp->ut_id));
-#endif
-#if _HAVE_UT_HOST - 0
-	memcpy (utmpx->ut_host, utmp->ut_host, sizeof (utmp->ut_host));
-#endif
-#if _HAVE_UT_TV - 0
-	utmpx->ut_tv.tv_sec = utmp->ut_tv.tv_sec;
-	utmpx->ut_tv.tv_usec = utmp->ut_tv.tv_usec;
-#else
-	utmpx->ut_time = utmp->ut_time;
-#endif
-}
diff --git a/libc/misc/utmp/wtent.c b/libc/misc/utmp/wtent.c
deleted file mode 100644
index 9b3ad5084..000000000
--- a/libc/misc/utmp/wtent.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
- *
- * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
- */
-
-/* wtmp support rubbish (i.e. complete crap) */
-
-#include <string.h>
-#include <sys/time.h>
-#include <time.h>
-#include <unistd.h>
-#include <utmp.h>
-#ifdef __UCLIBC_HAS_UTMPX__
-# include <utmpx.h>
-#endif
-#include <fcntl.h>
-#include <sys/file.h>
-#include <not-cancel.h>
-
-#if 0
-/* This is enabled in uClibc/libutil/logwtmp.c */
-void logwtmp (const char *line, const char *name, const char *host)
-{
-    struct utmp lutmp;
-    memset(&lutmp, 0, sizeof(lutmp));
-
-    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);
-    gettimeofday(&(lutmp.ut_tv), NULL);
-
-    updwtmp(_PATH_WTMP, &lutmp);
-}
-#endif
-
-static void __updwtmp(const char *wtmp_file, const struct utmp *lutmp)
-{
-    int fd;
-
-    fd = open_not_cancel_2(wtmp_file, O_APPEND | O_WRONLY);
-    if (fd >= 0) {
-	if (lockf(fd, F_LOCK, 0) == 0) {
-	    write_not_cancel(fd, lutmp, sizeof(struct utmp));
-	    lockf(fd, F_ULOCK, 0);
-	    close_not_cancel_no_status(fd);
-	}
-    }
-}
-strong_alias(__updwtmp,updwtmp)
-
-#ifdef __UCLIBC_HAS_UTMPX__
-void updwtmpx (const char *wtmpx_file, const struct utmpx *utmpx)
-{
-	__updwtmp (wtmpx_file, (const struct utmp *) utmpx);
-}
-#endif
diff --git a/libc/stdio/_fpmaxtostr.h b/libc/stdio/_fpmaxtostr.h
index b4e7321c2..7694629ec 100644
--- a/libc/stdio/_fpmaxtostr.h
+++ b/libc/stdio/_fpmaxtostr.h
@@ -11,39 +11,39 @@
 #define _FPMAXTOSTR_H 1
 
 #include <features.h>
-#ifdef __UCLIBC_HAS_FLOATS__
-
 #define __need_size_t
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <printf.h>
 #include <sys/types.h>
-#include <float.h>
-#include <bits/uClibc_fpmax.h>
+
+#ifdef __UCLIBC_HAS_FLOATS__
+# include <float.h>
+# include <bits/uClibc_fpmax.h>
 
 /* WARNING: Adjust _fp_out_wide() in _vfprintf.c if this changes! */
 /* With 32 bit ints, we can get 9 decimal digits per block. */
-#define DIGITS_PER_BLOCK     9
+# define DIGITS_PER_BLOCK     9
 
-#define NUM_DIGIT_BLOCKS   ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
+# define NUM_DIGIT_BLOCKS   ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
 
 /* WARNING: Adjust _fp_out_wide() in _vfprintf.c if this changes! */
 /* extra space for '-', '.', 'e+###', and nul */
-#define BUF_SIZE  ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
+# define BUF_SIZE  ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
 
 /* psm: why do these internals differ? */
-#ifdef __USE_OLD_VFPRINTF__
+#  ifdef __USE_OLD_VFPRINTF__
 typedef void (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len, intptr_t buf);
 
 extern size_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info,
 			  __fp_outfunc_t fp_outfunc) attribute_hidden;
-#else
+#  else
 typedef size_t (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len, intptr_t buf);
 
 extern ssize_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info,
 			   __fp_outfunc_t fp_outfunc) attribute_hidden;
-#endif
+#  endif
 
-#endif /* __UCLIBC_HAS_FLOATS__ */
+# endif /* __UCLIBC_HAS_FLOATS__ */
 #endif /* _FPMAXTOSTR_H */
diff --git a/libc/stdio/_vfprintf.c b/libc/stdio/_vfprintf.c
index 01ee218e5..a795f4979 100644
--- a/libc/stdio/_vfprintf.c
+++ b/libc/stdio/_vfprintf.c
@@ -121,18 +121,6 @@
 #error Apparently, LONG_LONG_MAX is defined but LLONG_MAX is not.  You need to fix your toolchain headers to support the standard macros for (unsigned) long long.
 #endif
 
-/**********************************************************************/
-/* These provide some control over printf's feature set */
-
-/* Now controlled by uClibc_config.h. */
-/* #define __UCLIBC_HAS_FLOATS__ 1 */
-
-/* Now controlled by uClibc_config.h. */
-/* #define __UCLIBC_HAS_PRINTF_M_SPEC__ */
-
-
-/**********************************************************************/
-
 #include "_fpmaxtostr.h"
 
 #undef __STDIO_HAS_VSNPRINTF
@@ -142,9 +130,6 @@
 
 /**********************************************************************/
 
-/* Now controlled by uClibc_config.h. */
-/* #define __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */
-
 #ifdef __UCLIBC_MJN3_ONLY__
 # ifdef L_register_printf_function
 /* emit only once */
diff --git a/libc/stdlib/Makefile.in b/libc/stdlib/Makefile.in
index 880de78d8..071f91119 100644
--- a/libc/stdlib/Makefile.in
+++ b/libc/stdlib/Makefile.in
@@ -61,7 +61,6 @@ CSRC-$(if $(findstring yyy,$(UCLIBC_HAS_FLOATS)$(UCLIBC_HAS_WCHAR)$(UCLIBC_HAS_X
 
 # multi source _atexit.c
 CSRC-y += __cxa_atexit.c __cxa_finalize.c __exit_handler.c exit.c on_exit.c
-CSRC-$(COMPAT_ATEXIT) += old_atexit.c
 
 STDLIB_DIR := $(top_srcdir)libc/stdlib
 STDLIB_OUT := $(top_builddir)libc/stdlib
@@ -71,11 +70,12 @@ STDLIB_OBJ := $(patsubst %.c,$(STDLIB_OUT)/%.o,$(CSRC-y))
 
 libc-y += $(STDLIB_OBJ)
 libc-static-y += $(STDLIB_OUT)/atexit.o $(STDLIB_OUT)/system.o
+libc-static-$(COMPAT_ATEXIT) += $(STDLIB_OUT)/old_atexit.o
 libc-shared-y += $(STDLIB_OUT)/system.oS
 
 # this should always be the PIC version, because it could be used in shared libs
 libc-nonshared-y += $(STDLIB_OUT)/atexit.os
-
+libc-nonshared-$(COMPAT_ATEXIT) += $(STDLIB_OUT)/old_atexit.os
 libc-nomulti-y += $(STDLIB_OUT)/labs.o $(STDLIB_OUT)/atol.o $(STDLIB_OUT)/_stdlib_strto_l.o $(STDLIB_OUT)/_stdlib_strto_ll.o
 libc-nomulti-$(UCLIBC_HAS_XLOCALE) += $(STDLIB_OUT)/_stdlib_strto_l_l.o $(STDLIB_OUT)/_stdlib_strto_ll_l.o
 
diff --git a/libc/stdlib/malloc-standard/free.c b/libc/stdlib/malloc-standard/free.c
index 39e54d635..8b7a81fca 100644
--- a/libc/stdlib/malloc-standard/free.c
+++ b/libc/stdlib/malloc-standard/free.c
@@ -104,9 +104,13 @@ static int __malloc_trim(size_t pad, mstate av)
 */
 int malloc_trim(size_t pad)
 {
+  int r;
+  __MALLOC_LOCK;
   mstate av = get_malloc_state();
   __malloc_consolidate(av);
-  return __malloc_trim(pad, av);
+  r = __malloc_trim(pad, av);
+  __MALLOC_UNLOCK;
+  return r;
 }
 
 /*
diff --git a/libc/stdlib/malloc-standard/malloc.c b/libc/stdlib/malloc-standard/malloc.c
index 2abb5bbdd..fd33b50c7 100644
--- a/libc/stdlib/malloc-standard/malloc.c
+++ b/libc/stdlib/malloc-standard/malloc.c
@@ -832,8 +832,6 @@ void* malloc(size_t bytes)
     }
 #endif
 
-    __MALLOC_LOCK;
-    av = get_malloc_state();
     /*
        Convert request size to internal form by adding (sizeof(size_t)) bytes
        overhead plus possibly more to obtain necessary alignment and/or
@@ -845,6 +843,9 @@ void* malloc(size_t bytes)
 
     checked_request2size(bytes, nb);
 
+    __MALLOC_LOCK;
+    av = get_malloc_state();
+
     /*
        Bypass search if no frees yet
        */
diff --git a/libc/stdlib/malloc-standard/memalign.c b/libc/stdlib/malloc-standard/memalign.c
index 6303c1dd9..e9ae5a7b9 100644
--- a/libc/stdlib/malloc-standard/memalign.c
+++ b/libc/stdlib/malloc-standard/memalign.c
@@ -52,8 +52,8 @@ void* memalign(size_t alignment, size_t bytes)
 	alignment = a;
     }
 
-    __MALLOC_LOCK;
     checked_request2size(bytes, nb);
+    __MALLOC_LOCK;
 
     /* Strategy: find a spot within that chunk that meets the alignment
      * request, and then possibly free the leading and trailing space.  */
diff --git a/libc/stdlib/malloc-standard/realloc.c b/libc/stdlib/malloc-standard/realloc.c
index e060b70ea..e49d11125 100644
--- a/libc/stdlib/malloc-standard/realloc.c
+++ b/libc/stdlib/malloc-standard/realloc.c
@@ -54,9 +54,9 @@ void* realloc(void* oldmem, size_t bytes)
 	return NULL;
     }
 
+    checked_request2size(bytes, nb);
     __MALLOC_LOCK;
     av = get_malloc_state();
-    checked_request2size(bytes, nb);
 
     oldp    = mem2chunk(oldmem);
     oldsize = chunksize(oldp);
diff --git a/libc/string/strverscmp.c b/libc/string/strverscmp.c
index 714f4ed67..7818a9186 100644
--- a/libc/string/strverscmp.c
+++ b/libc/string/strverscmp.c
@@ -1,13 +1,8 @@
-/* GNU's strverscmp() function, taken from glibc 2.3.2 sources
- */
-
 /* Compare strings while treating digits characters numerically.
-   Copyright (C) 1997, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1997-2015 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Jean-François Bignolles <bignolle@ecoledoc.ibp.fr>, 1997.
 
-