1/* Return error detail for failing <dlfcn.h> functions.
2 Copyright (C) 1995-2016 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 Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the 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 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <dlfcn.h>
20#include <libintl.h>
21#include <stdbool.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <libc-lock.h>
26#include <ldsodefs.h>
27
28#if !defined SHARED && IS_IN (libdl)
29
30char *
31dlerror (void)
32{
33 return __dlerror ();
34}
35
36#else
37
38/* Type for storing results of dynamic loading actions. */
39struct dl_action_result
40 {
41 int errcode;
42 int returned;
43 bool malloced;
44 const char *objname;
45 const char *errstring;
46 };
47static struct dl_action_result last_result;
48static struct dl_action_result *static_buf;
49
50/* This is the key for the thread specific memory. */
51static __libc_key_t key;
52__libc_once_define (static, once);
53
54/* Destructor for the thread-specific data. */
55static void init (void);
56static void free_key_mem (void *mem);
57
58
59char *
60__dlerror (void)
61{
62 char *buf = NULL;
63 struct dl_action_result *result;
64
65# ifdef SHARED
66 if (__glibc_unlikely (_dlfcn_hook != NULL))
67 return _dlfcn_hook->dlerror ();
68# endif
69
70 /* If we have not yet initialized the buffer do it now. */
71 __libc_once (once, init);
72
73 /* Get error string. */
74 result = (struct dl_action_result *) __libc_getspecific (key);
75 if (result == NULL)
76 result = &last_result;
77
78 /* Test whether we already returned the string. */
79 if (result->returned != 0)
80 {
81 /* We can now free the string. */
82 if (result->errstring != NULL)
83 {
84 if (strcmp (result->errstring, "out of memory") != 0)
85 free ((char *) result->errstring);
86 result->errstring = NULL;
87 }
88 }
89 else if (result->errstring != NULL)
90 {
91 buf = (char *) result->errstring;
92 int n;
93 if (result->errcode == 0)
94 n = __asprintf (&buf, "%s%s%s",
95 result->objname,
96 result->objname[0] == '\0' ? "" : ": ",
97 _(result->errstring));
98 else
99 n = __asprintf (&buf, "%s%s%s: %s",
100 result->objname,
101 result->objname[0] == '\0' ? "" : ": ",
102 _(result->errstring),
103 strerror (result->errcode));
104 if (n != -1)
105 {
106 /* We don't need the error string anymore. */
107 if (strcmp (result->errstring, "out of memory") != 0)
108 free ((char *) result->errstring);
109 result->errstring = buf;
110 }
111
112 /* Mark the error as returned. */
113 result->returned = 1;
114 }
115
116 return buf;
117}
118# ifdef SHARED
119strong_alias (__dlerror, dlerror)
120# endif
121
122int
123internal_function
124_dlerror_run (void (*operate) (void *), void *args)
125{
126 struct dl_action_result *result;
127
128 /* If we have not yet initialized the buffer do it now. */
129 __libc_once (once, init);
130
131 /* Get error string and number. */
132 if (static_buf != NULL)
133 result = static_buf;
134 else
135 {
136 /* We don't use the static buffer and so we have a key. Use it
137 to get the thread-specific buffer. */
138 result = __libc_getspecific (key);
139 if (result == NULL)
140 {
141 result = (struct dl_action_result *) calloc (1, sizeof (*result));
142 if (result == NULL)
143 /* We are out of memory. Since this is no really critical
144 situation we carry on by using the global variable.
145 This might lead to conflicts between the threads but
146 they soon all will have memory problems. */
147 result = &last_result;
148 else
149 /* Set the tsd. */
150 __libc_setspecific (key, result);
151 }
152 }
153
154 if (result->errstring != NULL)
155 {
156 /* Free the error string from the last failed command. This can
157 happen if `dlerror' was not run after an error was found. */
158 if (result->malloced)
159 free ((char *) result->errstring);
160 result->errstring = NULL;
161 }
162
163 result->errcode = GLRO(dl_catch_error) (&result->objname, &result->errstring,
164 &result->malloced, operate, args);
165
166 /* If no error we mark that no error string is available. */
167 result->returned = result->errstring == NULL;
168
169 return result->errstring != NULL;
170}
171
172
173/* Initialize buffers for results. */
174static void
175init (void)
176{
177 if (__libc_key_create (&key, free_key_mem))
178 /* Creating the key failed. This means something really went
179 wrong. In any case use a static buffer which is better than
180 nothing. */
181 static_buf = &last_result;
182}
183
184
185static void
186check_free (struct dl_action_result *rec)
187{
188 if (rec->errstring != NULL
189 && strcmp (rec->errstring, "out of memory") != 0)
190 {
191 /* We can free the string only if the allocation happened in the
192 C library used by the dynamic linker. This means, it is
193 always the C library in the base namespace. When we're statically
194 linked, the dynamic linker is part of the program and so always
195 uses the same C library we use here. */
196#ifdef SHARED
197 struct link_map *map = NULL;
198 Dl_info info;
199 if (_dl_addr (check_free, &info, &map, NULL) != 0 && map->l_ns == 0)
200#endif
201 free ((char *) rec->errstring);
202 }
203}
204
205
206static void
207__attribute__ ((destructor))
208fini (void)
209{
210 check_free (&last_result);
211}
212
213
214/* Free the thread specific data, this is done if a thread terminates. */
215static void
216free_key_mem (void *mem)
217{
218 check_free ((struct dl_action_result *) mem);
219
220 free (mem);
221 __libc_setspecific (key, NULL);
222}
223
224# ifdef SHARED
225
226struct dlfcn_hook *_dlfcn_hook __attribute__((nocommon));
227libdl_hidden_data_def (_dlfcn_hook)
228
229# else
230
231static struct dlfcn_hook _dlfcn_hooks =
232 {
233 .dlopen = __dlopen,
234 .dlclose = __dlclose,
235 .dlsym = __dlsym,
236 .dlvsym = __dlvsym,
237 .dlerror = __dlerror,
238 .dladdr = __dladdr,
239 .dladdr1 = __dladdr1,
240 .dlinfo = __dlinfo,
241 .dlmopen = __dlmopen
242 };
243
244void
245__libc_register_dlfcn_hook (struct link_map *map)
246{
247 struct dlfcn_hook **hook;
248
249 hook = (struct dlfcn_hook **) __libc_dlsym_private (map, "_dlfcn_hook");
250 if (hook != NULL)
251 *hook = &_dlfcn_hooks;
252}
253# endif
254#endif
255