+2000-06-09 Ulrich Drepper <drepper@redhat.com>
+
+ Rewrite error message handling.
+ * elf/dl-deps.c (_dl_map_object_deps): Pass new parameter to
+ _dl_catch_error.
+ * elf/dl-error (struct catch): Add objname member.
+ (_dl_signal_error): Take new parameter with object name. When
+ passing message on simply store object name and duplicate error
+ message.
+ (_dl_catch_error): Take new parameter. Store object name in the
+ place pointed to.
+ * include/dlfcn.h: Adjust _dl_catch_error prototype.
+ * sysdeps/generic/ldsodefs.h: Adjust _dl_signal_error prototype.
+ * elf/dl-libc.c (dlerror_run): Pass new parameter to _dl_catch_error.
+ * elf/dl-open.c (_dl_open): Likewise.
+ * elf/rtld.c (dl_main): Likewise.
+ * elf/dl-close.c: Mark error messages with N_().
+ * elf/dl-deps.c: Likewise.
+ * elf/dl-error.c: Likewise.
+ * elf/dl-load.c: Likewise.
+ * elf/dl-open.c: Likewise.
+ * elf/dl-reloc.c: Likewise.
+ * elf/dl-support.c: Likewise.
+ * elf/dl-sym.c: Likewise.
+ * elf/dl-version.c: Likewise.
+ * elf/dl-lookup.c: Add comments about problems with error message
+ translations.
+ * elf/dl-reloc.c: Likewise.
+ * elf/dl-version.c: Likewise.
+
2000-06-09 David Mosberger-Tang <davidm@hpl.hp.com>
* sysdeps/unix/sysv/linux/ia64/__longjmp.S: new file
#include <assert.h>
#include <dlfcn.h>
+#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <bits/libc-lock.h>
protect `dlopen' and `dlclose' in dlclose.c. */
__libc_lock_define (extern, _dl_load_lock)
-#define LOSE(s) _dl_signal_error (0, map->l_name, s)
-
void
internal_function
_dl_close (void *_map)
unsigned int i;
if (map->l_opencount == 0)
- LOSE ("shared object not open");
+ _dl_signal_error (0, map->l_name, N_("shared object not open"));
/* Acquire the lock. */
__libc_lock_lock (_dl_load_lock);
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
+#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/* DST must not appear in SUID/SGID programs. */ \
if (__libc_enable_secure) \
_dl_signal_error (0, __str, \
- "DST not allowed in SUID/SGID programs"); \
+ N_("DST not allowed in SUID/SGID programs")); \
\
__newp = (char *) alloca (DL_DST_REQUIRED (l, __str, strlen (__str), \
__cnt)); \
/* The replacement for the DST is not known. We can't \
processed. */ \
if (fatal) \
- _dl_signal_error (0, __str, \
- "empty dynamics string token substitution"); \
+ _dl_signal_error (0, __str, N_("\
+empty dynamics string token substitution")); \
else \
{ \
/* This is for DT_AUXILIARY. */ \
}
else if (d->d_tag == DT_AUXILIARY || d->d_tag == DT_FILTER)
{
- char *errstring;
+ const char *objname;
+ const char *errstring;
struct list *newp;
/* Object name. */
const char *name;
/* We must be prepared that the addressed shared
object is not available. */
- if (_dl_catch_error (&errstring, openaux, &args))
+ if (_dl_catch_error (&objname, &errstring, openaux, &args))
{
/* We are not interested in the error message. */
assert (errstring != NULL);
- free (errstring);
+ free ((char *) errstring);
/* Simply ignore this error and continue the work. */
continue;
l->l_initfini = malloc (nneeded * sizeof needed[0]);
if (l->l_initfini == NULL)
_dl_signal_error (ENOMEM, map->l_name,
- "cannot allocate dependency list");
+ N_("cannot allocate dependency list"));
memcpy (l->l_initfini, needed, nneeded * sizeof needed[0]);
}
* sizeof (struct link_map *));
if (map->l_searchlist.r_list == NULL)
_dl_signal_error (ENOMEM, map->l_name,
- "cannot allocate symbol search list");
+ N_("cannot allocate symbol search list"));
map->l_searchlist.r_nlist = nlist;
for (nlist = 0, runp = known; runp; runp = runp->unique)
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <libintl.h>
#include <setjmp.h>
#include <stdlib.h>
#include <string.h>
_dl_signal_error. */
struct catch
{
- char *errstring; /* Error detail filled in here. */
+ const char *objname; /* Object/File name. */
+ const char *errstring; /* Error detail filled in here. */
jmp_buf env; /* longjmp here on error. */
};
void
internal_function
-_dl_signal_error (int errcode,
- const char *objname,
- const char *errstring)
+_dl_signal_error (int errcode, const char *objname, const char *errstring)
{
struct catch *lcatch;
if (! errstring)
- errstring = "DYNAMIC LINKER BUG!!!";
+ errstring = N_("DYNAMIC LINKER BUG!!!");
lcatch = tsd_getspecific ();
if (lcatch != NULL)
{
/* We are inside _dl_catch_error. Return to it. We have to
duplicate the error string since it might be allocated on the
- stack. */
- size_t objname_len = objname ? strlen (objname) + 2 : 0;
- size_t errstring_len = strlen (errstring) + 1;
- lcatch->errstring = malloc (objname_len + errstring_len);
- if (lcatch->errstring != NULL)
- {
- char *cp = lcatch->errstring;
- if (objname_len > 0)
- {
- cp = __mempcpy (cp, objname, objname_len - 2);
- cp = __mempcpy (cp, ": ", 2);
- }
- memcpy (cp, errstring, errstring_len);
- }
+ stack. The object name is always a string constant. */
+ lcatch->objname = objname;
+ lcatch->errstring = strdup (errstring);
longjmp (lcatch->env, errcode ?: -1);
}
else
int
internal_function
-_dl_catch_error (char **errstring,
- void (*operate) (void *),
- void *args)
+_dl_catch_error (const char **objname, const char **errstring,
+ void (*operate) (void *), void *args)
{
int errcode;
struct catch *volatile old;
tsd_setspecific (&c);
(*operate) (args);
tsd_setspecific (old);
+ *objname = NULL;
*errstring = NULL;
return 0;
}
/* We get here only if we longjmp'd out of OPERATE. */
tsd_setspecific (old);
+ *objname = c.objname;
*errstring = c.errstring;
return errcode == -1 ? 0 : errcode;
}
/* Handle loading and unloading shared objects for internal libc purposes.
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Zack Weinberg <zack@rabi.columbia.edu>, 1999.
internal_function
dlerror_run (void (*operate) (void *), void *args)
{
- char *last_errstring = NULL;
+ const char *objname;
+ const char *last_errstring = NULL;
int result;
- (void) _dl_catch_error (&last_errstring, operate, args);
+ (void) _dl_catch_error (&objname, &last_errstring, operate, args);
result = last_errstring != NULL;
if (result)
- free (last_errstring);
+ free ((char *) last_errstring);
return result;
}
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
+#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <endian.h>
#if BYTE_ORDER == BIG_ENDIAN
# define byteorder ELFDATA2MSB
-# define byteorder_name "big-endian"
#elif BYTE_ORDER == LITTLE_ENDIAN
# define byteorder ELFDATA2LSB
-# define byteorder_name "little-endian"
#else
# error "Unknown BYTE_ORDER " BYTE_ORDER
# define byteorder ELFDATANONE
if (newname == NULL)
{
/* No more memory. */
- _dl_signal_error (ENOMEM, name, "cannot allocate name record");
+ _dl_signal_error (ENOMEM, name, N_("cannot allocate name record"));
return;
}
/* The object should have a libname set from _dl_new_object. */
malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status));
if (dirp == NULL)
_dl_signal_error (ENOMEM, NULL,
- "cannot create cache for search path");
+ N_("cannot create cache for search path"));
dirp->dirname = cp;
dirp->dirnamelen = len;
malloc (sizeof (*result));
if (result == NULL)
_dl_signal_error (ENOMEM, NULL,
- "cannot create cache for search path");
+ N_("cannot create cache for search path"));
result[0] = NULL;
return result;
string tokens. */
copy = expand_dynamic_string_token (l, rpath);
if (copy == NULL)
- _dl_signal_error (ENOMEM, NULL, "cannot create RUNPATH/RPATH copy");
+ _dl_signal_error (ENOMEM, NULL, N_("cannot create RUNPATH/RPATH copy"));
/* Count the number of necessary elements in the result array. */
nelems = 0;
result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
* sizeof (*result));
if (result == NULL)
- _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
+ _dl_signal_error (ENOMEM, NULL, N_("cannot create cache for search path"));
return fillin_rpath (copy, result, ":", 0, what, where);
}
malloc ((sizeof (system_dirs_len) / sizeof (system_dirs_len[0]) + 1)
* sizeof (struct r_search_path_elem *));
if (rtld_search_dirs == NULL)
- _dl_signal_error (ENOMEM, NULL, "cannot create search path array");
+ _dl_signal_error (ENOMEM, NULL, N_("cannot create search path array"));
round_size = ((2 * sizeof (struct r_search_path_elem) - 1
+ ncapstr * sizeof (enum r_dir_status))
malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
* round_size * sizeof (struct r_search_path_elem));
if (rtld_search_dirs[0] == NULL)
- _dl_signal_error (ENOMEM, NULL, "cannot create cache for search path");
+ _dl_signal_error (ENOMEM, NULL, N_("cannot create cache for search path"));
pelem = all_dirs = rtld_search_dirs[0];
strp = system_dirs;
malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
if (env_path_list == NULL)
_dl_signal_error (ENOMEM, NULL,
- "cannot create cache for search path");
+ N_("cannot create cache for search path"));
(void) fillin_rpath (local_strdup (llp), env_path_list, ":;",
__libc_enable_secure, "LD_LIBRARY_PATH", NULL);
fixed|MAP_COPY|MAP_FILE,
fd, offset);
if (mapat == MAP_FAILED)
- LOSE (errno, "failed to map segment from shared object");
+ LOSE (errno, N_("failed to map segment from shared object"));
return mapat;
}
/* Get file information. */
if (__fxstat (_STAT_VER, fd, &st) < 0)
- LOSE (errno, "cannot stat shared object");
+ LOSE (errno, N_("cannot stat shared object"));
/* Look again to see if the real name matched another already loaded. */
for (l = _dl_loaded; l; l = l->l_next)
readbuf = alloca (_dl_pagesize);
readlength = __libc_read (fd, readbuf, _dl_pagesize);
if (readlength < (ssize_t) sizeof (*header))
- LOSE (errno, "cannot read file data");
+ LOSE (errno, N_("cannot read file data"));
header = (void *) readbuf;
/* Check the header for basic validity. */
(ELFMAG3 << (EI_MAG0 * 8)))
#endif
)
- LOSE (0, "invalid ELF header");
+ LOSE (0, N_("invalid ELF header"));
if (header->e_ident[EI_CLASS] != ELFW(CLASS))
- LOSE (0, "ELF file class not " STRING(__ELF_NATIVE_CLASS) "-bit");
+ {
+ if (__ELF_NATIVE_CLASS == 32)
+ LOSE (0, N_("ELF file class not 32-bit"));
+ else
+ LOSE (0, N_("ELF file class not 64-bit"));
+ }
if (header->e_ident[EI_DATA] != byteorder)
- LOSE (0, "ELF file data encoding not " byteorder_name);
+ {
+ if (BYTE_ORDER == BIG_ENDIAN)
+ LOSE (0, "ELF file data encoding not big-endian");
+ else
+ LOSE (0, "ELF file data encoding not little-endian");
+ }
if (header->e_ident[EI_VERSION] != EV_CURRENT)
- LOSE (0, "ELF file version ident not " STRING(EV_CURRENT));
+ LOSE (0, N_("ELF file version ident does not match current one"));
/* XXX We should be able so set system specific versions which are
allowed here. */
if (!VALID_ELF_OSABI (header->e_ident[EI_OSABI]))
- LOSE (0, "ELF file OS ABI invalid.");
+ LOSE (0, N_("ELF file OS ABI invalid."));
if (!VALID_ELF_ABIVERSION (header->e_ident[EI_ABIVERSION]))
- LOSE (0, "ELF file ABI version invalid.");
- LOSE (0, "internal error");
+ LOSE (0, N_("ELF file ABI version invalid."));
+ LOSE (0, N_("internal error"));
}
if (__builtin_expect (header->e_version, EV_CURRENT) != EV_CURRENT)
- LOSE (0, "ELF file version not " STRING(EV_CURRENT));
+ LOSE (0, N_("ELF file version does not not match current one"));
if (! __builtin_expect (elf_machine_matches_host (header->e_machine), 1))
- LOSE (0, "ELF file machine architecture not " ELF_MACHINE_NAME);
+ LOSE (0, N_("ELF file machine architecture does not match"));
if (__builtin_expect (header->e_phentsize, sizeof (ElfW(Phdr)))
!= sizeof (ElfW(Phdr)))
- LOSE (0, "ELF file's phentsize not the expected size");
+ LOSE (0, N_("ELF file's phentsize not the expected size"));
#ifndef MAP_ANON
# define MAP_ANON 0
if (_dl_zerofd == -1)
{
__close (fd);
- _dl_signal_error (errno, NULL, "cannot open zero fill device");
+ _dl_signal_error (errno, NULL, N_("cannot open zero fill device"));
}
}
#endif
/* Enter the new object in the list of loaded objects. */
l = _dl_new_object (realname, name, l_type, loader);
if (__builtin_expect (! l, 0))
- LOSE (ENOMEM, "cannot create shared object descriptor");
+ LOSE (ENOMEM, N_("cannot create shared object descriptor"));
l->l_opencount = 1;
/* Extract the remaining details we need from the ELF header
phdr = alloca (maplength);
__lseek (fd, SEEK_SET, header->e_phoff);
if (__libc_read (fd, (void *) phdr, maplength) != maplength)
- LOSE (errno, "cannot read file data");
+ LOSE (errno, N_("cannot read file data"));
}
{
/* A load command tells us to map in part of the file.
We record the load commands and process them all later. */
if (ph->p_align % _dl_pagesize != 0)
- LOSE (0, "ELF load command alignment not page-aligned");
+ LOSE (0, N_("ELF load command alignment not page-aligned"));
if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
- LOSE (0, "ELF load command address/offset not properly aligned");
+ LOSE (0,
+ N_("ELF load command address/offset not properly aligned"));
{
struct loadcmd *c = &loadcmds[nloadcmds++];
c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
/* Dag nab it. */
if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
_dl_pagesize, c->prot|PROT_WRITE) < 0)
- LOSE (errno, "cannot change memory protections");
+ LOSE (errno, N_("cannot change memory protections"));
}
memset ((void *) zero, 0, zeropage - zero);
if ((c->prot & PROT_WRITE) == 0)
c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
ANONFD, 0);
if (mapat == MAP_FAILED)
- LOSE (errno, "cannot map zero-fill pages");
+ LOSE (errno, N_("cannot map zero-fill pages"));
}
}
ElfW(Phdr) *newp = (ElfW(Phdr) *) malloc (header->e_phnum
* sizeof (ElfW(Phdr)));
if (newp == NULL)
- LOSE (ENOMEM, "cannot allocate memory for program header");
+ LOSE (ENOMEM, N_("cannot allocate memory for program header"));
l->l_phdr = memcpy (newp, phdr,
(header->e_phnum * sizeof (ElfW(Phdr))));
if (l->l_ld == 0)
{
if (type == ET_DYN)
- LOSE (0, "object file has no dynamic section");
+ LOSE (0, N_("object file has no dynamic section"));
}
else
(ElfW(Addr)) l->l_ld += l->l_addr;
(struct link_map **) malloc (sizeof (struct link_map *));
if (l->l_symbolic_searchlist.r_list == NULL)
- LOSE (ENOMEM, "cannot create searchlist");
+ LOSE (ENOMEM, N_("cannot create searchlist"));
l->l_symbolic_searchlist.r_list[0] = l;
l->l_symbolic_searchlist.r_nlist = 1;
if ((name_copy = local_strdup (name)) == NULL
|| (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
_dl_signal_error (ENOMEM, name,
- "cannot create shared object descriptor");
+ N_("cannot create shared object descriptor"));
/* We use an opencount of 0 as a sign for the faked entry.
Since the descriptor is initialized with zero we do not
have do this here.
return l;
}
else
- _dl_signal_error (errno, name, "cannot open shared object file");
+ _dl_signal_error (errno, name, N_("cannot open shared object file"));
}
return _dl_map_object_from_fd (name, fd, realname, loader, type);
{
if (*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
/* We could find no value for a strong reference. */
+ /* XXX We cannot translate the messages. */
_dl_signal_cerror (0, (reference_name && reference_name[0]
? reference_name
: (_dl_argv[0] ?: "<main program>")),
{
/* Oh, oh. The file named in the relocation entry does not
contain the needed symbol. */
+ /* XXX We cannot translate the message. */
_dl_signal_cerror (0, (reference_name && reference_name[0]
? reference_name
: (_dl_argv[0] ?: "<main program>")),
{
if (*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
/* We could find no value for a strong reference. */
+ /* XXX We cannot translate the message. */
_dl_signal_cerror (0, (reference_name && reference_name[0]
? reference_name
: (_dl_argv[0] ?: "<main program>")),
char buf[sizeof undefined_msg + len];
__mempcpy (__mempcpy (buf, undefined_msg, sizeof undefined_msg - 1),
undef_name, len + 1);
+ /* XXX We cannot translate the messages. */
_dl_signal_cerror (0, (reference_name && reference_name[0]
? reference_name
: (_dl_argv[0] ?: "<main program>")), buf);
if (__libc_enable_secure)
/* This is an error. */
_dl_signal_error (0, "dlopen",
- "DST not allowed in SUID/SGID programs");
+ N_("DST not allowed in SUID/SGID programs"));
/* We have to find out from which object the caller is calling.
Find the highest-addressed object that ADDRESS is not below. */
/* If the substitution failed don't try to load. */
if (*new_file == '\0')
_dl_signal_error (0, "dlopen",
- "empty dynamic string token substitution");
+ N_("empty dynamic string token substitution"));
/* Now we have a new file name. */
file = new_file;
_dl_global_scope_alloc = 0;
nomem:
_dl_signal_error (ENOMEM, new->l_libname->name,
- "cannot extend global scope");
+ N_("cannot extend global scope"));
return;
}
_dl_open (const char *file, int mode, const void *caller)
{
struct dl_open_args args;
- char *errstring;
+ const char *objname;
+ const char *errstring;
int errcode;
if ((mode & RTLD_BINDING_MASK) == 0)
/* One of the flags must be set. */
- _dl_signal_error (EINVAL, file, _("invalid mode for dlopen()"));
+ _dl_signal_error (EINVAL, file, N_("invalid mode for dlopen()"));
/* Make sure we are alone. */
__libc_lock_lock (_dl_load_lock);
args.mode = mode;
args.caller = caller;
args.map = NULL;
- errcode = _dl_catch_error (&errstring, dl_open_worker, &args);
+ errcode = _dl_catch_error (&objname, &errstring, dl_open_worker, &args);
#ifndef MAP_COPY
/* We must munmap() the cache file. */
/* Make a local copy of the error string so that we can release the
memory allocated for it. */
local_errstring = strdupa (errstring);
- free (errstring);
+ free ((char *) errstring);
/* Reraise the error. */
- _dl_signal_error (errcode, NULL, local_errstring);
+ _dl_signal_error (errcode, objname, local_errstring);
}
return args.map;
Boston, MA 02111-1307, USA. */
#include <errno.h>
+#include <libintl.h>
#include <stdlib.h>
#include <unistd.h>
#include <ldsodefs.h>
& ~(_dl_pagesize - 1)));
if (__mprotect (mapstart, mapend - mapstart,
PROT_READ|PROT_WRITE) < 0)
- _dl_signal_error (errno, l->l_name,
- "cannot make segment writable for relocation");
+ _dl_signal_error (errno, l->l_name, N_("\
+cannot make segment writable for relocation"));
}
}
if (__mprotect (mapstart, mapend - mapstart, prot) < 0)
_dl_signal_error (errno, l->l_name,
- "can't restore segment prot after reloc");
+ N_("can't restore segment prot after reloc"));
#ifdef CLEAR_CACHE
CLEAR_CACHE (mapstart, mapend);
extern const char _itoa_lower_digits[];
if (plt)
{
- char msg[] = "unexpected PLT reloc type 0x??";
+ /* XXX We cannot translate the message. */
+ static char msg[] = "unexpected PLT reloc type 0x??";
msg[sizeof msg - 3] = DIGIT(type >> 4);
msg[sizeof msg - 2] = DIGIT(type);
_dl_signal_error (0, map->l_name, msg);
}
else
{
- char msg[] = "unexpected reloc type 0x??";
+ /* XXX We cannot translate the message. */
+ static char msg[] = "unexpected reloc type 0x??";
msg[sizeof msg - 3] = DIGIT(type >> 4);
msg[sizeof msg - 2] = DIGIT(type);
_dl_signal_error (0, map->l_name, msg);
rtld.c and dl-sysdep.c in ways appropriate to bootstrap dynamic linking. */
#include <errno.h>
+#include <libintl.h>
#include <stdlib.h>
#include <unistd.h>
#include <ldsodefs.h>
/* XXX We don't try to find the capabilities in this case. */
result = (struct r_strlenpair *) malloc (sizeof (*result));
if (result == NULL)
- _dl_signal_error (ENOMEM, NULL, "cannot create capability list");
+ _dl_signal_error (ENOMEM, NULL, N_("cannot create capability list"));
result[0].str = (char *) result; /* Does not really matter. */
result[0].len = 0;
else
{
if (! match)
- _dl_signal_error (0, NULL, _("\
+ _dl_signal_error (0, NULL, N_("\
RTLD_NEXT used in code not dynamically loaded"));
l = match;
match = l;
if (! match)
- _dl_signal_error (0, NULL, _("\
+ _dl_signal_error (0, NULL, N_("\
RTLD_NEXT used in code not dynamically loaded"));
l = match;
#include <elf.h>
#include <errno.h>
+#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <ldsodefs.h>
object was linked against another version of this file. We
only print a message if verbose output is requested. */
if (verbose)
+ /* XXX We cannot translate the messages. */
_dl_signal_cerror (0, map->l_name,
make_string ("\
no version information available (required by ",
{
char buf[20];
buf[sizeof (buf) - 1] = '\0';
+ /* XXX We cannot translate the message. */
_dl_signal_error (0, map->l_name,
make_string ("unsupported version ",
_itoa_word (def->vd_version,
if (__builtin_expect (weak, 1))
{
if (verbose)
+ /* XXX We cannot translate the message. */
_dl_signal_cerror (0, map->l_name,
make_string ("weak version `", string,
"' not found (required by ", name,
return 0;
}
+ /* XXX We cannot translate the message. */
_dl_signal_cerror (0, map->l_name,
make_string ("version `", string,
"' not found (required by ", name, ")"));
{
char buf[20];
buf[sizeof (buf) - 1] = '\0';
+ /* XXX We cannot translate the message. */
_dl_signal_error (0, (*map->l_name ? map->l_name : _dl_argv[0]),
make_string ("unsupported version ",
_itoa_word (ent->vn_version,
if (__builtin_expect (map->l_versions == NULL, 0))
{
_dl_signal_error (ENOMEM, (*map->l_name ? map->l_name : _dl_argv[0]),
- "cannot allocate version reference table");
+ N_("cannot allocate version reference table"));
result = 1;
}
else
if (__builtin_expect (mode, normal) == verify)
{
- char *err_str = NULL;
+ const char *objname;
+ const char *err_str = NULL;
struct map_args args;
args.str = _dl_argv[0];
- (void) _dl_catch_error (&err_str, map_doit, &args);
- if (err_str != NULL)
+ (void) _dl_catch_error (&objname, &err_str, map_doit, &args);
+ if (__builtin_expect (err_str != NULL, 0))
{
- free (err_str);
+ free ((char *) err_str);
_exit (EXIT_FAILURE);
}
}
extern void *_dl_vsym (void *handle, const char *name, const char *version,
void *who)
internal_function;
-
+
/* Call OPERATE, catching errors from `dl_signal_error'. If there is no
error, *ERRSTRING is set to null. If there is an error, *ERRSTRING is
set to a string constructed from the strings passed to _dl_signal_error,
- and the error code passed is the return value. ERRSTRING if nonzero
+ and the error code passed is the return value and *OBJNAME is set to
+ the object name which experienced the problems. ERRSTRING if nonzero
points to a malloc'ed string which the caller has to free after use.
ARGS is passed as argument to OPERATE. */
-extern int _dl_catch_error (char **errstring,
+extern int _dl_catch_error (const char **objname, const char **errstring,
void (*operate) (void *),
void *args)
internal_function;
zero; OBJECT is the name of the problematical shared object, or null if
it is a general problem; ERRSTRING is a string describing the specific
problem. */
-extern void _dl_signal_error (int errcode,
- const char *object,
+extern void _dl_signal_error (int errcode, const char *object,
const char *errstring)
internal_function
__attribute__ ((__noreturn__));
projects / platform / upstream / glibc.git / commitdiff