(last_object_name): Removed.
[kopensolaris-gnu/glibc.git] / elf / dl-error.c
1 /* Error handling for runtime dynamic linker.
2    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <link.h>
21 #include <setjmp.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 /* This is the internal function we use to generate the error string.  */
27 extern char *_strerror_internal __P ((int, char *, size_t));
28
29 /* This structure communicates state between _dl_catch_error and
30    _dl_signal_error.  */
31 struct catch
32   {
33     char *errstring;            /* Error detail filled in here.  */
34     const char *objname;
35     jmp_buf env;                /* longjmp here on error.  */
36   };
37
38 /* This points to such a structure during a call to _dl_catch_error.
39    During implicit startup and run-time work for needed shared libraries,
40    this is null.  */
41 static struct catch *catch;
42
43 /* This points to a function which is called when an error is
44    received.  Unlike the handling of `catch' this function may return.
45    The arguments will be the `errstring' and `objname'.  */
46 static receiver_fct receiver;
47
48
49 void
50 _dl_signal_error (int errcode,
51                   const char *objname,
52                   const char *errstring)
53 {
54   if (! errstring)
55     errstring = "DYNAMIC LINKER BUG!!!";
56
57   if (catch)
58     {
59       /* We are inside _dl_catch_error.  Return to it.  We have to
60          duplicate the error string since it might be allocated on the
61          stack.  */
62       size_t len = strlen (errstring) + 1;
63       catch->errstring = malloc (len);
64       if (catch->errstring != NULL)
65         memcpy (catch->errstring, errstring, len);
66       catch->objname = objname;
67       longjmp (catch->env, errcode ?: -1);
68     }
69   else if (receiver)
70     {
71       /* We are inside _dl_receive_error.  Call the user supplied
72          handler and resume the work.  The receiver will still be
73          installed.  */
74       (*receiver) (errcode, objname, errstring);
75     }
76   else
77     {
78       /* Lossage while resolving the program's own symbols is always fatal.  */
79       char buffer[1024];
80       _dl_sysdep_fatal (_dl_argv[0] ?: "<program name unknown>",
81                         ": error in loading shared libraries: ",
82                         objname ?: "", objname && *objname ? ": " : "",
83                         errstring, errcode ? ": " : "",
84                         (errcode
85                          ? _strerror_internal (errcode, buffer, sizeof buffer)
86                          : ""), "\n", NULL);
87     }
88 }
89
90 int
91 _dl_catch_error (char **errstring,
92                  const char **objname,
93                  void (*operate) (void *),
94                  void *args)
95 {
96   int errcode;
97   struct catch *old, c;
98   /* We need not handle `receiver' since setting a `catch' is handled
99      before it.  */
100
101   /* Some systems (e.g., SPARC) handle constructors to local variables
102      inefficient.  So we initialize `c' by hand.  */
103   c.errstring = NULL;
104   c.objname   = NULL;
105
106   old = catch;
107   errcode = setjmp (c.env);
108   if (errcode == 0)
109     {
110       catch = &c;
111       (*operate) (args);
112       catch = old;
113       *errstring = NULL;
114       *objname = NULL;
115       return 0;
116     }
117
118   /* We get here only if we longjmp'd out of OPERATE.  */
119   catch = old;
120   *errstring = c.errstring;
121   *objname = c.objname;
122   return errcode == -1 ? 0 : errcode;
123 }
124
125 void
126 _dl_receive_error (receiver_fct fct, void (*operate) (void *), void *args)
127 {
128   struct catch *old_catch;
129   receiver_fct old_receiver;
130
131   old_catch = catch;
132   old_receiver = receiver;
133
134   /* Set the new values.  */
135   catch = NULL;
136   receiver = fct;
137
138   (*operate) (args);
139
140   catch = old_catch;
141   receiver = old_receiver;
142 }