1 /* Return error detail for failing <dlfcn.h> functions.
2 Copyright (C) 1995-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
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 <https://www.gnu.org/licenses/>. */
25 #include <libc-lock.h>
27 #include <libc-symbols.h>
29 #if !defined SHARED && IS_IN (libdl)
39 /* Type for storing results of dynamic loading actions. */
40 struct dl_action_result
46 const char *errstring
;
48 static struct dl_action_result last_result
;
49 static struct dl_action_result
*static_buf
;
51 /* This is the key for the thread specific memory. */
52 static __libc_key_t key
;
53 __libc_once_define (static, once
);
55 /* Destructor for the thread-specific data. */
56 static void init (void);
57 static void free_key_mem (void *mem
);
64 struct dl_action_result
*result
;
68 return _dlfcn_hook
->dlerror ();
71 /* If we have not yet initialized the buffer do it now. */
72 __libc_once (once
, init
);
74 /* Get error string. */
75 if (static_buf
!= NULL
)
79 /* init () has been run and we don't use the static buffer.
80 So we have a valid key. */
81 result
= (struct dl_action_result
*) __libc_getspecific (key
);
83 result
= &last_result
;
86 /* Test whether we already returned the string. */
87 if (result
->returned
!= 0)
89 /* We can now free the string. */
90 if (result
->errstring
!= NULL
)
92 if (strcmp (result
->errstring
, "out of memory") != 0)
93 free ((char *) result
->errstring
);
94 result
->errstring
= NULL
;
97 else if (result
->errstring
!= NULL
)
99 buf
= (char *) result
->errstring
;
101 if (result
->errcode
== 0)
102 n
= __asprintf (&buf
, "%s%s%s",
104 result
->objname
[0] == '\0' ? "" : ": ",
105 _(result
->errstring
));
107 n
= __asprintf (&buf
, "%s%s%s: %s",
109 result
->objname
[0] == '\0' ? "" : ": ",
110 _(result
->errstring
),
111 strerror (result
->errcode
));
114 /* We don't need the error string anymore. */
115 if (strcmp (result
->errstring
, "out of memory") != 0)
116 free ((char *) result
->errstring
);
117 result
->errstring
= buf
;
120 /* Mark the error as returned. */
121 result
->returned
= 1;
127 strong_alias (__dlerror
, dlerror
)
131 _dlerror_run (void (*operate
) (void *), void *args
)
133 struct dl_action_result
*result
;
135 /* If we have not yet initialized the buffer do it now. */
136 __libc_once (once
, init
);
138 /* Get error string and number. */
139 if (static_buf
!= NULL
)
143 /* We don't use the static buffer and so we have a key. Use it
144 to get the thread-specific buffer. */
145 result
= __libc_getspecific (key
);
148 result
= (struct dl_action_result
*) calloc (1, sizeof (*result
));
150 /* We are out of memory. Since this is no really critical
151 situation we carry on by using the global variable.
152 This might lead to conflicts between the threads but
153 they soon all will have memory problems. */
154 result
= &last_result
;
157 __libc_setspecific (key
, result
);
161 if (result
->errstring
!= NULL
)
163 /* Free the error string from the last failed command. This can
164 happen if `dlerror' was not run after an error was found. */
165 if (result
->malloced
)
166 free ((char *) result
->errstring
);
167 result
->errstring
= NULL
;
170 result
->errcode
= GLRO (dl_catch_error
) (&result
->objname
,
175 /* If no error we mark that no error string is available. */
176 result
->returned
= result
->errstring
== NULL
;
178 return result
->errstring
!= NULL
;
182 /* Initialize buffers for results. */
186 if (__libc_key_create (&key
, free_key_mem
))
187 /* Creating the key failed. This means something really went
188 wrong. In any case use a static buffer which is better than
190 static_buf
= &last_result
;
195 check_free (struct dl_action_result
*rec
)
197 if (rec
->errstring
!= NULL
198 && strcmp (rec
->errstring
, "out of memory") != 0)
200 /* We can free the string only if the allocation happened in the
201 C library used by the dynamic linker. This means, it is
202 always the C library in the base namespace. When we're statically
203 linked, the dynamic linker is part of the program and so always
204 uses the same C library we use here. */
206 struct link_map
*map
= NULL
;
208 if (_dl_addr (check_free
, &info
, &map
, NULL
) != 0 && map
->l_ns
== 0)
211 free ((char *) rec
->errstring
);
212 rec
->errstring
= NULL
;
219 __attribute__ ((destructor
))
222 check_free (&last_result
);
226 /* Free the thread specific data, this is done if a thread terminates. */
228 free_key_mem (void *mem
)
230 check_free ((struct dl_action_result
*) mem
);
233 __libc_setspecific (key
, NULL
);
238 /* Free the dlerror-related resources. */
240 __dlerror_main_freeres (void)
242 /* Free the global memory if used. */
243 check_free (&last_result
);
245 if (__libc_once_get (once
) && static_buf
== NULL
)
247 /* init () has been run and we don't use the static buffer.
248 So we have a valid key. */
250 /* Free the TSD memory if used. */
251 mem
= __libc_getspecific (key
);
257 struct dlfcn_hook
*_dlfcn_hook
__attribute__((nocommon
));
258 libdl_hidden_data_def (_dlfcn_hook
)
262 static struct dlfcn_hook _dlfcn_hooks
=
265 .dlclose
= __dlclose
,
268 .dlerror
= __dlerror
,
270 .dladdr1
= __dladdr1
,
276 __libc_register_dlfcn_hook (struct link_map
*map
)
278 struct dlfcn_hook
**hook
;
280 hook
= (struct dlfcn_hook
**) __libc_dlsym_private (map
, "_dlfcn_hook");
282 *hook
= &_dlfcn_hooks
;