Use MAP_ANON instead of MAP_ANONYMOUS.
[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 <setjmp.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <elf/ldsodefs.h>
25 #include <bits/libc-tsd.h>
26
27 /* This structure communicates state between _dl_catch_error and
28    _dl_signal_error.  */
29 struct catch
30   {
31     char *errstring;            /* Error detail filled in here.  */
32     jmp_buf env;                /* longjmp here on error.  */
33   };
34
35 /* Multiple threads at once can use the `_dl_catch_error' function.  The
36    calls can come from `_dl_map_object_deps', `_dlerror_run', or from
37    any of the libc functionality which loads dynamic objects (NSS, iconv).
38    Therefore we have to be prepared to save the state in thread-local
39    memory.  */
40
41 __libc_tsd_define (static, DL_ERROR)
42 #define tsd_getspecific()       __libc_tsd_get (DL_ERROR)
43 #define tsd_setspecific(data)   __libc_tsd_set (DL_ERROR, (data))
44
45
46 /* This points to a function which is called when an error is
47    received.  Unlike the handling of `catch' this function may return.
48    The arguments will be the `errstring' and `objname'.
49
50    Since this functionality is not used in normal programs (only in ld.so)
51    we do not care about multi-threaded programs here.  We keep this as a
52    global variable.  */
53 static receiver_fct receiver;
54
55
56 void
57 internal_function
58 _dl_signal_error (int errcode,
59                   const char *objname,
60                   const char *errstring)
61 {
62   struct catch *lcatch;
63
64   if (! errstring)
65     errstring = "DYNAMIC LINKER BUG!!!";
66
67   lcatch = tsd_getspecific ();
68   if (lcatch != NULL)
69     {
70       /* We are inside _dl_catch_error.  Return to it.  We have to
71          duplicate the error string since it might be allocated on the
72          stack.  */
73       size_t objname_len = objname ? strlen (objname) + 2 : 0;
74       size_t errstring_len = strlen (errstring) + 1;
75       lcatch->errstring = malloc (objname_len + errstring_len);
76       if (lcatch->errstring != NULL)
77         {
78           if (objname_len > 0)
79             {
80               memcpy (lcatch->errstring, objname, objname_len - 2);
81               memcpy (lcatch->errstring + objname_len - 2, ": ", 2);
82             }
83           memcpy (lcatch->errstring + objname_len, errstring, errstring_len);
84         }
85       longjmp (lcatch->env, errcode ?: -1);
86     }
87   else if (receiver)
88     {
89       /* We are inside _dl_receive_error.  Call the user supplied
90          handler and resume the work.  The receiver will still be
91          installed.  */
92       (*receiver) (errcode, objname, errstring);
93     }
94   else
95     {
96       /* Lossage while resolving the program's own symbols is always fatal.  */
97       char buffer[1024];
98       _dl_sysdep_fatal (_dl_argv[0] ?: "<program name unknown>",
99                         ": error in loading shared libraries: ",
100                         objname ?: "", objname && *objname ? ": " : "",
101                         errstring, errcode ? ": " : "",
102                         (errcode
103                          ? __strerror_r (errcode, buffer, sizeof buffer)
104                          : ""), "\n", NULL);
105     }
106 }
107
108 int
109 internal_function
110 _dl_catch_error (char **errstring,
111                  void (*operate) (void *),
112                  void *args)
113 {
114   int errcode;
115   struct catch *volatile old;
116   struct catch c;
117   /* We need not handle `receiver' since setting a `catch' is handled
118      before it.  */
119
120   /* Some systems (e.g., SPARC) handle constructors to local variables
121      inefficient.  So we initialize `c' by hand.  */
122   c.errstring = NULL;
123
124   old = tsd_getspecific ();
125   errcode = setjmp (c.env);
126   if (errcode == 0)
127     {
128       tsd_setspecific (&c);
129       (*operate) (args);
130       tsd_setspecific (old);
131       *errstring = NULL;
132       return 0;
133     }
134
135   /* We get here only if we longjmp'd out of OPERATE.  */
136   tsd_setspecific (old);
137   *errstring = c.errstring;
138   return errcode == -1 ? 0 : errcode;
139 }
140
141 void
142 internal_function
143 _dl_receive_error (receiver_fct fct, void (*operate) (void *), void *args)
144 {
145   struct catch *old_catch;
146   receiver_fct old_receiver;
147
148   old_catch = tsd_getspecific ();
149   old_receiver = receiver;
150
151   /* Set the new values.  */
152   tsd_setspecific (NULL);
153   receiver = fct;
154
155   (*operate) (args);
156
157   tsd_setspecific (old_catch);
158   receiver = old_receiver;
159 }