A patch set that should probably become uClibc-0.9.28.1

This patch supports cross-development for embedded systems by allowing the

host version of ldconfig (ldconfig.host) to build ld.so.cache for the target.

Changes include:

 1) LDSO_CACHE_SUPPORT is defined for the host build.

 2) A little-endian host can create a big-endian ld.so.cache, and vice versa.

 3) Can use -r option without chroot(), so no need to run as superuser.

Dan Howell <dahowell@directv.com>

diff -urN uClibc-orig/utils/chroot_realpath.c uClibc-20050502/utils/chroot_realpath.c

--- uClibc-orig/utils/chroot_realpath.c	1969-12-31 16:00:00.000000000 -0800

+++ uClibc-20050502/utils/chroot_realpath.c	2005-09-12 18:30:29.000000000 -0700

@@ -0,0 +1,163 @@

+/*

+ * chroot_realpath.c -- reslove pathname as if inside chroot

+ * Based on realpath.c Copyright (C) 1993 Rick Sladkey <jrs@world.std.com>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Library Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Library Public License for more details.

+ *

+ * 2005/09/12: Dan Howell (modified from realpath.c to emulate chroot)

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <sys/types.h>

+#include <unistd.h>

+#include <stdio.h>

+#include <string.h>

+#include <strings.h>

+#include <limits.h>				/* for PATH_MAX */

+#include <sys/param.h>			/* for MAXPATHLEN */

+#include <errno.h>

+#ifndef __set_errno

+#define __set_errno(val) ((errno) = (val))

+#endif

+

+#include <sys/stat.h>			/* for S_IFLNK */

+

+#ifndef PATH_MAX

+#define PATH_MAX _POSIX_PATH_MAX

+#endif

+

+#define MAX_READLINKS 32

+

+char *chroot_realpath(const char *chroot, const char *path, char resolved_path[])

+{

+	char copy_path[PATH_MAX];

+	char link_path[PATH_MAX];

+	char got_path[PATH_MAX];

+	char *got_path_root = got_path;

+	char *new_path = got_path;

+	char *max_path;

+	int readlinks = 0;

+	int n;

+	int chroot_len;

+

+	/* Trivial case. */

+	if (chroot == NULL || *chroot == '\0' ||

+	    (*chroot == '/' && chroot[1] == '\0')) {

+		strcpy(resolved_path, path);

+		return resolved_path;

+	}

+

+	chroot_len = strlen(chroot);

+

+	if (chroot_len + strlen(path) >= PATH_MAX - 3) {

+		__set_errno(ENAMETOOLONG);

+		return NULL;

+	}

+

+	/* Make a copy of the source path since we may need to modify it. */

+	strcpy(copy_path, path);

+	path = copy_path;

+	max_path = copy_path + PATH_MAX - chroot_len - 3;

+

+	/* Start with the chroot path. */

+	strcpy(new_path, chroot);

+	new_path += chroot_len;

+	while (*new_path == '/' && new_path > got_path)

+		new_path--;

+	got_path_root = new_path;

+	*new_path++ = '/';

+

+	/* Expand each slash-separated pathname component. */

+	while (*path != '\0') {

+		/* Ignore stray "/". */

+		if (*path == '/') {

+			path++;

+			continue;

+		}

+		if (*path == '.') {

+			/* Ignore ".". */

+			if (path[1] == '\0' || path[1] == '/') {

+				path++;

+				continue;

+			}

+			if (path[1] == '.') {

+				if (path[2] == '\0' || path[2] == '/') {

+					path += 2;

+					/* Ignore ".." at root. */

+					if (new_path == got_path_root + 1)

+						continue;

+					/* Handle ".." by backing up. */

+					while ((--new_path)[-1] != '/');

+					continue;

+				}

+			}

+		}

+		/* Safely copy the next pathname component. */

+		while (*path != '\0' && *path != '/') {

+			if (path > max_path) {

+				__set_errno(ENAMETOOLONG);

+				return NULL;

+			}

+			*new_path++ = *path++;

+		}

+		if (*path == '\0')

+			/* Don't follow symlink for last pathname component. */

+			break;

+#ifdef S_IFLNK

+		/* Protect against infinite loops. */

+		if (readlinks++ > MAX_READLINKS) {

+			__set_errno(ELOOP);

+			return NULL;

+		}

+		/* See if latest pathname component is a symlink. */

+		*new_path = '\0';

+		n = readlink(got_path, link_path, PATH_MAX - 1);

+		if (n < 0) {

+			/* EINVAL means the file exists but isn't a symlink. */

+			if (errno != EINVAL) {

+				/* Make sure it's null terminated. */

+				*new_path = '\0';

+				strcpy(resolved_path, got_path);

+				return NULL;

+			}

+		} else {

+			/* Note: readlink doesn't add the null byte. */

+			link_path[n] = '\0';

+			if (*link_path == '/')

+				/* Start over for an absolute symlink. */

+				new_path = got_path_root;

+			else

+				/* Otherwise back up over this component. */

+				while (*(--new_path) != '/');

+			/* Safe sex check. */

+			if (strlen(path) + n >= PATH_MAX - 2) {

+				__set_errno(ENAMETOOLONG);

+				return NULL;

+			}

+			/* Insert symlink contents into path. */

+			strcat(link_path, path);

+			strcpy(copy_path, link_path);

+			path = copy_path;

+		}

+#endif							/* S_IFLNK */

+		*new_path++ = '/';

+	}

+	/* Delete trailing slash but don't whomp a lone slash. */

+	if (new_path != got_path + 1 && new_path[-1] == '/')

+		new_path--;

+	/* Make sure it's null terminated. */

+	*new_path = '\0';

+	strcpy(resolved_path, got_path);

+	return resolved_path;

+}

diff -urN uClibc-orig/utils/ldconfig.c uClibc-20050502/utils/ldconfig.c

--- uClibc-orig/utils/ldconfig.c	2005-05-01 23:10:12.000000000 -0700

+++ uClibc-20050502/utils/ldconfig.c	2005-09-16 19:26:33.000000000 -0700

@@ -22,6 +22,8 @@

  *

  * This program may be used for any purpose as long as this

  * copyright notice is kept.

+ *

+ * 2005/09/16: Dan Howell (modified for cross-development)

  */

 #include <stdio.h>

@@ -37,6 +39,7 @@

 #include <errno.h>

 #include <sys/stat.h>

 #include <sys/mman.h>

+#include "bswap.h"

 #include "dl-defs.h"

 #define BUFFER_SIZE 4096

@@ -56,6 +59,7 @@

 #if !defined (N_MAGIC)

 #define N_MAGIC(exec) ((exec).a_info & 0xffff)

 #endif

+#define N_MAGIC_SWAP(exec) (bswap_32((exec).a_info) & 0xffff)

 /* Code indicating object file or impure executable.  */

 #define OMAGIC 0407

 /* Code indicating pure executable.  */

@@ -97,6 +101,8 @@

 char *conffile = LDSO_CONF;	/* default conf file */

 char *cachefile = LDSO_CACHE;	/* default cache file */

 #endif

+char *chroot_dir = NULL;

+int byteswap = 0;

 struct needed_tab

 {

@@ -117,6 +123,8 @@

   { NULL,           LIB_ELF }

 };

+extern char *chroot_realpath(const char *chroot, const char *path, char resolved_path[]);

+

 /* These two are used internally -- you shouldn't need to use them */

 static void verror_msg(const char *s, va_list p)

@@ -242,6 +250,8 @@

     ElfW(Ehdr) *elf_hdr;

     struct stat statbuf;

     char buff[BUFFER_SIZE];

+    char real[BUFFER_SIZE];

+    static int byteswapflag = -1;	/* start with byte-order unknown */

     /* see if name is of the form *.so* */

     if (name[strlen(name)-1] != '~' && (cp = strstr(name, ".so")))

@@ -256,8 +266,12 @@

 	sprintf(buff, "%s%s%s", dir, (*dir && strcmp(dir, "/")) ?

 		"/" : "", name);

+	/* get real path in case of chroot */

+	if (!chroot_realpath(chroot_dir, buff, real))

+	    warn("can't resolve %s in chroot %s", buff, chroot_dir);

+

 	/* first, make sure it's a regular file */

-	if (lstat(buff, &statbuf))

+	if (lstat(real, &statbuf))

 	    warn("skipping %s", buff);

 	else if (!S_ISREG(statbuf.st_mode) && !S_ISLNK(statbuf.st_mode))

 	    warnx("%s is not a regular file or symlink, skipping", buff);

@@ -267,14 +281,15 @@

 	    *islink = S_ISLNK(statbuf.st_mode);

 	    /* then try opening it */

-	    if (!(file = fopen(buff, "rb")))

+	    if (!(file = fopen(real, "rb")))

 		warn("skipping %s", buff);

 	    else

 	    {

 		/* now make sure it's a shared library */

 		if (fread(&exec, sizeof exec, 1, file) < 1)

 		    warnx("can't read header from %s, skipping", buff);

-		else if (N_MAGIC(exec) != ZMAGIC && N_MAGIC(exec) != QMAGIC)

+		else if (N_MAGIC(exec) != ZMAGIC && N_MAGIC(exec) != QMAGIC &&

+			 N_MAGIC_SWAP(exec) != ZMAGIC && N_MAGIC_SWAP(exec) != QMAGIC)

 		{

 		    elf_hdr = (ElfW(Ehdr) *) &exec;

 		    if (elf_hdr->e_ident[0] != 0x7f ||

@@ -294,6 +309,9 @@

 			*type = LIB_ELF;

 			good = readsoname(buff, file, expected_type, type, 

 				elf_hdr->e_ident[EI_CLASS]);

+			if (byteswapflag == -1)

+			    /* byte-order detected */

+			    byteswapflag = byteswap;

 			if (good == NULL || *islink)

 			{

 			    if (good != NULL)

@@ -313,6 +331,12 @@

 		}

 		else

 		{

+		    /* Determine byte-order */

+		    byteswap = (N_MAGIC(exec) == ZMAGIC || N_MAGIC(exec) == QMAGIC) ? 0 : 1;

+		    if (byteswapflag == -1)

+			/* byte-order detected */

+			byteswapflag = byteswap;

+

 		    if (*islink)

 			good = xstrdup(name);

 		    else

@@ -330,6 +354,14 @@

 		    *type = LIB_DLL;

 		}

 		fclose(file);

+

+		if (byteswapflag >= 0 && byteswap != byteswapflag)

+		{

+		    byteswapflag = -2;

+		    warnx("mixed byte-order detected, using host byte-order...");

+		}

+		if (byteswapflag == -2)

+		    byteswap = 0;

 	    }

 	}

     }

@@ -343,18 +375,24 @@

     int change = 1;

     char libname[BUFFER_SIZE];

     char linkname[BUFFER_SIZE];

+    char reallibname[BUFFER_SIZE];

+    char reallinkname[BUFFER_SIZE];

     struct stat libstat;

     struct stat linkstat;

     /* construct the full path names */

     sprintf(libname, "%s/%s", dir, file);

     sprintf(linkname, "%s/%s", dir, so);

+    if (!chroot_realpath(chroot_dir, libname, reallibname))

+	warn("can't resolve %s in chroot %s", libname, chroot_dir);

+    if (!chroot_realpath(chroot_dir, linkname, reallinkname))

+	warn("can't resolve %s in chroot %s", linkname, chroot_dir);

     /* see if a link already exists */

-    if (!stat(linkname, &linkstat))

+    if (!stat(reallinkname, &linkstat))

     {

 	/* now see if it's the one we want */

-	if (stat(libname, &libstat))

+	if (stat(reallibname, &libstat))

 	    warn("can't stat %s", libname);

 	else if (libstat.st_dev == linkstat.st_dev &&

 		libstat.st_ino == linkstat.st_ino)

@@ -364,14 +402,14 @@

     /* then update the link, if required */

     if (change > 0 && !nolinks)

     {

-	if (!lstat(linkname, &linkstat))

+	if (!lstat(reallinkname, &linkstat))

 	{

 	    if (!S_ISLNK(linkstat.st_mode))

 	    {

 		warnx("%s is not a symlink", linkname);

 		change = -1;

 	    }

-	    else if (remove(linkname))

+	    else if (remove(reallinkname))

 	    {

 		warn("can't unlink %s", linkname);

 		change = -1;

@@ -379,7 +417,7 @@

 	}

 	if (change > 0)

 	{

-	    if (symlink(file, linkname))

+	    if (symlink(file, reallinkname))

 	    {

 		warn("can't link %s to %s", linkname, file);

 		change = -1;

@@ -441,6 +479,7 @@

     char *so, *path, *path_n;

     struct lib *lp, *libs = NULL;

     int i, libtype, islink, expected_type = LIB_ANY;

+    char realname[BUFFER_SIZE];

     /* We need a writable copy of this string */

     path = strdup(rawname);

@@ -500,8 +539,12 @@

     if (verbose > 0)

 	printf("%s:\n", name);

+    /* get real path in case of chroot */

+    if (!chroot_realpath(chroot_dir, name, realname))

+	warn("can't resolve %s in chroot %s", name, chroot_dir);

+

     /* if we can't open it, we can't do anything */

-    if ((dir = opendir(name)) == NULL)

+    if ((dir = opendir(realname)) == NULL)

     {

 	warn("skipping %s", name);

 	free(path);

@@ -596,8 +639,12 @@

     char *res = NULL, *cp;

     FILE *file;

     struct stat stat;

+    char realconffile[BUFFER_SIZE];

+

+    if (!chroot_realpath(chroot_dir, conffile, realconffile))

+	return NULL;

-    if ((file = fopen(conffile, "r")) != NULL)

+    if ((file = fopen(realconffile, "r")) != NULL)

     {

 	fstat(fileno(file), &stat);

 	res = xmalloc(stat.st_size + 1);

@@ -678,22 +725,38 @@

 {

     int cachefd;

     int stroffset = 0;

+    char realcachefile[BUFFER_SIZE];

     char tempfile[BUFFER_SIZE];

+    header_t swap_magic;

+    header_t *magic_ptr;

+    libentry_t swap_lib;

+    libentry_t *lib_ptr;

     liblist_t *cur_lib;

     if (!magic.nlibs)

 	return;

-    sprintf(tempfile, "%s~", cachefile);

+    if (!chroot_realpath(chroot_dir, cachefile, realcachefile))

+	err(EXIT_FATAL,"can't resolve %s in chroot %s (%s)",

+	    cachefile, chroot_dir, strerror(errno));

+

+    sprintf(tempfile, "%s~", realcachefile);

     if (unlink(tempfile) && errno != ENOENT)

-	err(EXIT_FATAL,"can't unlink %s (%s)", tempfile, strerror(errno));

+	err(EXIT_FATAL,"can't unlink %s~ (%s)", cachefile, strerror(errno));

     if ((cachefd = creat(tempfile, 0644)) < 0)

-	err(EXIT_FATAL,"can't create %s (%s)", tempfile, strerror(errno));

+	err(EXIT_FATAL,"can't create %s~ (%s)", cachefile, strerror(errno));

-    if (write(cachefd, &magic, sizeof (header_t)) != sizeof (header_t))

-	err(EXIT_FATAL,"can't write %s (%s)", tempfile, strerror(errno));

+    if (byteswap) {

+	swap_magic = magic;

+	swap_magic.nlibs = bswap_32(swap_magic.nlibs);

+	magic_ptr = &swap_magic;

+    } else {

+	magic_ptr = &magic;

+    }

+    if (write(cachefd, magic_ptr, sizeof (header_t)) != sizeof (header_t))

+	err(EXIT_FATAL,"can't write %s~ (%s)", cachefile, strerror(errno));

     for (cur_lib = lib_head; cur_lib != NULL; cur_lib = cur_lib->next)

     {

@@ -701,29 +764,37 @@

 	stroffset += strlen(cur_lib->soname) + 1;

 	cur_lib->liboffset = stroffset;

 	stroffset += strlen(cur_lib->libname) + 1;

-	if (write(cachefd, cur_lib, sizeof (libentry_t)) !=

-		sizeof (libentry_t))

-	    err(EXIT_FATAL,"can't write %s (%s)", tempfile, strerror(errno));

+	if (byteswap) {

+	    swap_lib.flags = bswap_32(cur_lib->flags);

+	    swap_lib.sooffset = bswap_32(cur_lib->sooffset);

+	    swap_lib.liboffset = bswap_32(cur_lib->liboffset);

+	    lib_ptr = &swap_lib;

+	} else {

+	    lib_ptr = (libentry_t *)cur_lib;

+	}

+	if (write(cachefd, lib_ptr, sizeof (libentry_t)) !=

+	    sizeof (libentry_t))

+	err(EXIT_FATAL,"can't write %s~ (%s)", cachefile, strerror(errno));

     }

     for (cur_lib = lib_head; cur_lib != NULL; cur_lib = cur_lib->next)

     {

 	if (write(cachefd, cur_lib->soname, strlen(cur_lib->soname) + 1)

 		!= strlen(cur_lib->soname) + 1)

-	    err(EXIT_FATAL,"can't write %s (%s)", tempfile, strerror(errno));

+	    err(EXIT_FATAL,"can't write %s~ (%s)", cachefile, strerror(errno));

 	if (write(cachefd, cur_lib->libname, strlen(cur_lib->libname) + 1)

 		!= strlen(cur_lib->libname) + 1)

-	    err(EXIT_FATAL,"can't write %s (%s)", tempfile, strerror(errno));

+	    err(EXIT_FATAL,"can't write %s~ (%s)", cachefile, strerror(errno));

     }

     if (close(cachefd))

-	err(EXIT_FATAL,"can't close %s (%s)", tempfile, strerror(errno));

+	err(EXIT_FATAL,"can't close %s~ (%s)", cachefile, strerror(errno));

     if (chmod(tempfile, 0644))

-	err(EXIT_FATAL,"can't chmod %s (%s)", tempfile, strerror(errno));

+	err(EXIT_FATAL,"can't chmod %s~ (%s)", cachefile, strerror(errno));

-    if (rename(tempfile, cachefile))

-	err(EXIT_FATAL,"can't rename %s (%s)", tempfile, strerror(errno));

+    if (rename(tempfile, realcachefile))

+	err(EXIT_FATAL,"can't rename %s~ (%s)", cachefile, strerror(errno));

 }

 void cache_print(void)

@@ -734,8 +805,13 @@

     char *strs;

     header_t *header;

     libentry_t *libent;

+    char realcachefile[BUFFER_SIZE];

+

+    if (!chroot_realpath(chroot_dir, cachefile, realcachefile))

+	err(EXIT_FATAL,"can't resolve %s in chroot %s (%s)",

+	    cachefile, chroot_dir, strerror(errno));

-    if (stat(cachefile, &st) || (fd = open(cachefile, O_RDONLY))<0)

+    if (stat(realcachefile, &st) || (fd = open(realcachefile, O_RDONLY))<0)

 	err(EXIT_FATAL,"can't read %s (%s)", cachefile, strerror(errno));

     if ((c = mmap(0,st.st_size, PROT_READ, MAP_SHARED ,fd, 0)) == (caddr_t)-1)

 	err(EXIT_FATAL,"can't map %s (%s)", cachefile, strerror(errno));

@@ -828,7 +904,6 @@

     int nodefault = 0;

     char *cp, *dir, *so;

     int libtype, islink;

-    char *chroot_dir = NULL;

     int printcache = 0;

 #ifdef __LDSO_CACHE_SUPPORT__

     char *extpath;

@@ -891,10 +966,16 @@

 	}

     if (chroot_dir && *chroot_dir) {

-	if (chroot(chroot_dir) < 0)

-	    err(EXIT_FATAL,"couldn't chroot to %s (%s)", chroot_dir, strerror(errno));

-	if (chdir("/") < 0)

-	    err(EXIT_FATAL,"couldn't chdir to / (%s)", strerror(errno));

+	if (chroot(chroot_dir) < 0) {

+	    if (chdir(chroot_dir) < 0)

+		err(EXIT_FATAL,"couldn't chroot to %s (%s)", chroot_dir, strerror(errno));

+	}

+	else

+	{

+	    if (chdir("/") < 0)

+		err(EXIT_FATAL,"couldn't chdir to / (%s)", strerror(errno));

+	    chroot_dir = NULL;

+	}

     }

     /* allow me to introduce myself, hi, my name is ... */

diff -urN uClibc-orig/utils/Makefile uClibc-20050502/utils/Makefile

--- uClibc-orig/utils/Makefile	2005-05-01 23:10:12.000000000 -0700

+++ uClibc-20050502/utils/Makefile	2005-09-16 19:28:55.000000000 -0700

@@ -29,6 +29,12 @@

 TARGET_ICONV =

 endif

+ifeq ($(strip $(LDSO_CACHE_SUPPORT)),y)

+HOST_LDSO_CACHE_FLAG = -D__LDSO_CACHE_SUPPORT__=1

+else

+HOST_LDSO_CACHE_FLAG =

+endif

+

 # NOTE: We build the utils AFTER we have a uClibc-targeted toolchain.

 ifeq ($(strip $(HAVE_SHARED)),y)

@@ -51,7 +57,7 @@

 else

 LDCONFIG_CFLAGS := $(PIEFLAG) $(LDPIEFLAG)

 endif

-ldconfig: ldconfig.c

+ldconfig: ldconfig.c chroot_realpath.c

 	$(CC) $(CFLAGS) $(LDCONFIG_CFLAGS) \

 		-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \

 		-DUCLIBC_LDSO=$(UCLIBC_LDSO) -I. -I../ldso/include \

@@ -79,13 +85,13 @@

 ldd.host: ldd.c

 	$(HOSTCC) $(HOSTCFLAGS) -Wl,-s \

-		-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \

+ 		-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" $(HOST_LDSO_CACHE_FLAG) \

 		-DUCLIBC_LDSO=$(UCLIBC_LDSO) -I. -I../ldso/include \

 		$^ -o $@

-ldconfig.host: ldconfig.c

+ldconfig.host: ldconfig.c chroot_realpath.c

 	$(HOSTCC) $(HOSTCFLAGS) -Wl,-s \

-		-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \

+ 		-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" $(HOST_LDSO_CACHE_FLAG) \

 		-DUCLIBC_LDSO=$(UCLIBC_LDSO) -I. -I../ldso/include \

 		$^ -o $@

diff -urN uClibc-orig/utils/readsoname2.c uClibc-20050502/utils/readsoname2.c

--- uClibc-orig/utils/readsoname2.c	2005-05-01 23:10:12.000000000 -0700

+++ uClibc-20050502/utils/readsoname2.c	2005-09-16 17:48:59.000000000 -0700

@@ -26,7 +26,7 @@

   if (fstat(fileno(infile), &st))

     return NULL;

-  header = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fileno(infile), 0);

+  header = mmap(0, st.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fileno(infile), 0);

   if (header == (caddr_t)-1)

     return NULL;

@@ -34,6 +34,19 @@

   if ((char *)(epnt+1) > (char *)(header + st.st_size))

     goto skip;

+#if __BYTE_ORDER == __LITTLE_ENDIAN

+  byteswap = (epnt->e_ident[5] == ELFDATA2MSB) ? 1 : 0;

+#elif __BYTE_ORDER == __BIG_ENDIAN

+  byteswap = (epnt->e_ident[5] == ELFDATA2LSB) ? 1 : 0;

+#else

+#error Unknown host byte order!

+#endif

+  /* Be very lazy, and only byteswap the stuff we use */

+  if (byteswap==1) {

+    epnt->e_phoff=bswap_32(epnt->e_phoff);

+    epnt->e_phnum=bswap_16(epnt->e_phnum);

+  }

+

   ppnt = (ElfW(Phdr) *)&header[epnt->e_phoff];

   if ((char *)ppnt < (char *)header ||

       (char *)(ppnt+epnt->e_phnum) > (char *)(header + st.st_size))

@@ -41,6 +54,14 @@

   for(i = 0; i < epnt->e_phnum; i++)

   {

+    /* Be very lazy, and only byteswap the stuff we use */

+    if (byteswap==1) {

+      ppnt->p_type=bswap_32(ppnt->p_type);

+      ppnt->p_vaddr=bswap_32(ppnt->p_vaddr);

+      ppnt->p_offset=bswap_32(ppnt->p_offset);

+      ppnt->p_filesz=bswap_32(ppnt->p_filesz);

+    }

+

     if (loadaddr == -1 && ppnt->p_type == PT_LOAD) 

       loadaddr = (ppnt->p_vaddr & ~(page_size-1)) -

 	(ppnt->p_offset & ~(page_size-1));

@@ -58,11 +79,20 @@

       (char *)(dpnt+dynamic_size) > (char *)(header + st.st_size))

     goto skip;

+  if (byteswap==1) {

+    dpnt->d_tag=bswap_32(dpnt->d_tag);

+    dpnt->d_un.d_val=bswap_32(dpnt->d_un.d_val);

+  }

+

   while (dpnt->d_tag != DT_NULL)

   {

     if (dpnt->d_tag == DT_STRTAB)

       strtab_val = dpnt->d_un.d_val;

     dpnt++;

+    if (byteswap==1) {

+      dpnt->d_tag=bswap_32(dpnt->d_tag);

+      dpnt->d_un.d_val=bswap_32(dpnt->d_un.d_val);

+    }

   };

   if (!strtab_val)

--- uClibc/libc/misc/time/time.c	(revision 16488)

+++ uClibc/libc/misc/time/time.c	(working copy)

@@ -155,6 +155,20 @@

 #define TZNAME_MAX _POSIX_TZNAME_MAX

 #endif

+#if defined (L_tzset) || defined (L_localtime_r) || defined(L_strftime) || \

+    defined(L__time_mktime) || defined(L__time_mktime_tzi)

+

+void _time_tzset (int);

+

+#ifndef L__time_mktime

+

+ /* Jan 1, 2007 Z - tm = 0,0,0,1,0,107,1,0,0 */

+

+const static time_t new_rule_starts = 1167609600;

+

+#endif

+#endif

+

 /**********************************************************************/

 /* The era code is currently unfinished. */

 /*  #define ENABLE_ERA_CODE */

@@ -544,7 +558,7 @@

 {

 	TZLOCK;

-	tzset();

+	_time_tzset(*timer < new_rule_starts);

 	__time_localtime_tzi(timer, result, _time_tzinfo);

@@ -968,7 +982,8 @@

 	unsigned char mod;

 	unsigned char code;

-	tzset();					/* We'll, let's get this out of the way. */

+	/* We'll, let's get this out of the way. */

+	_time_tzset(_time_mktime((struct tm *) timeptr, 0) < new_rule_starts);

 	lvl = 0;

 	p = format;

@@ -1650,7 +1665,9 @@

 	6,  0,  0,					/* Note: overloaded for non-M non-J case... */

 	0, 1, 0,					/* J */

 	',', 'M',      '4', '.', '1', '.', '0',

-	',', 'M', '1', '0', '.', '5', '.', '0', 0

+	',', 'M', '1', '0', '.', '5', '.', '0', 0,

+	',', 'M',      '3', '.', '2', '.', '0',

+	',', 'M', '1', '1', '.', '1', '.', '0', 0

 };

 #define TZ    vals

@@ -1658,6 +1675,7 @@

 #define RANGE (vals + 7)

 #define RULE  (vals + 11 - 1)

 #define DEFAULT_RULES (vals + 22)

+#define DEFAULT_2007_RULES (vals + 38)

 /* Initialize to UTC. */

 int daylight = 0;

@@ -1782,6 +1800,11 @@

 void tzset(void)

 {

+    _time_tzset((time(NULL)) < new_rule_starts);

+}

+

+void _time_tzset(int use_old_rules)

+{

 	register const char *e;

 	register char *s;

 	long off;

@@ -1904,7 +1927,15 @@

 	} else {					/* OK, we have dst, so get some rules. */

 		count = 0;

 		if (!*e) {				/* No rules so default to US rules. */

-			e = DEFAULT_RULES;

+		        e = use_old_rules ? DEFAULT_RULES : DEFAULT_2007_RULES;

+#ifdef DEBUG_TZSET			

+			if (e == DEFAULT_RULES)

+			    printf("tzset: Using old rules.\n");

+			else if (e == DEFAULT_2007_RULES)

+			    printf("tzset: Using new rules\n");

+			else

+			    printf("tzset: Using undefined rules\n");

+#endif /* DEBUG_TZSET */

 		}

 		do {

@@ -2238,6 +2269,8 @@

 		--d;

 	}

+	_time_tzset (x.tm_year < 2007);	/* tm_year was expanded above */

+

 #ifdef __BCC__

 	d = p[5] - 1;

 	days = -719163L + ((long)d)*365 + ((d/4) - (d/100) + (d/400) + p[3] + p[7]);