1/* Handle symbol and library versioning.
2 Copyright (C) 1997-2016 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
19
20#include <elf.h>
21#include <errno.h>
22#include <libintl.h>
23#include <stdlib.h>
24#include <string.h>
25#include <ldsodefs.h>
26#include <_itoa.h>
27
28#include <assert.h>
29
30
31#define make_string(string, rest...) \
32 ({ \
33 const char *all[] = { string, ## rest }; \
34 size_t len, cnt; \
35 char *result, *cp; \
36 \
37 len = 1; \
38 for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt) \
39 len += strlen (all[cnt]); \
40 \
41 cp = result = alloca (len); \
42 for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt) \
43 cp = __stpcpy (cp, all[cnt]); \
44 \
45 result; \
46 })
47
48
49static inline struct link_map *
50__attribute ((always_inline))
51find_needed (const char *name, struct link_map *map)
52{
53 struct link_map *tmap;
54 unsigned int n;
55
56 for (tmap = GL(dl_ns)[map->l_ns]._ns_loaded; tmap != NULL;
57 tmap = tmap->l_next)
58 if (_dl_name_match_p (name, tmap))
59 return tmap;
60
61 /* The required object is not in the global scope, look to see if it is
62 a dependency of the current object. */
63 for (n = 0; n < map->l_searchlist.r_nlist; n++)
64 if (_dl_name_match_p (name, map->l_searchlist.r_list[n]))
65 return map->l_searchlist.r_list[n];
66
67 /* Should never happen. */
68 return NULL;
69}
70
71
72static int
73internal_function
74match_symbol (const char *name, Lmid_t ns, ElfW(Word) hash, const char *string,
75 struct link_map *map, int verbose, int weak)
76{
77 const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
78 ElfW(Addr) def_offset;
79 ElfW(Verdef) *def;
80 /* Initialize to make the compiler happy. */
81 const char *errstring = NULL;
82 int result = 0;
83
84 /* Display information about what we are doing while debugging. */
85 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_VERSIONS))
86 _dl_debug_printf ("\
87checking for version `%s' in file %s [%lu] required by file %s [%lu]\n",
88 string, DSO_FILENAME (map->l_name),
89 map->l_ns, name, ns);
90
91 if (__glibc_unlikely (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL))
92 {
93 /* The file has no symbol versioning. I.e., the dependent
94 object was linked against another version of this file. We
95 only print a message if verbose output is requested. */
96 if (verbose)
97 {
98 /* XXX We cannot translate the messages. */
99 errstring = make_string ("\
100no version information available (required by ", name, ")");
101 goto call_cerror;
102 }
103 return 0;
104 }
105
106 def_offset = map->l_info[VERSYMIDX (DT_VERDEF)]->d_un.d_ptr;
107 assert (def_offset != 0);
108
109 def = (ElfW(Verdef) *) ((char *) map->l_addr + def_offset);
110 while (1)
111 {
112 /* Currently the version number of the definition entry is 1.
113 Make sure all we see is this version. */
114 if (__builtin_expect (def->vd_version, 1) != 1)
115 {
116 char buf[20];
117 buf[sizeof (buf) - 1] = '\0';
118 /* XXX We cannot translate the message. */
119 errstring = make_string ("unsupported version ",
120 _itoa (def->vd_version,
121 &buf[sizeof (buf) - 1], 10, 0),
122 " of Verdef record");
123 result = 1;
124 goto call_cerror;
125 }
126
127 /* Compare the hash values. */
128 if (hash == def->vd_hash)
129 {
130 ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
131
132 /* To be safe, compare the string as well. */
133 if (__builtin_expect (strcmp (string, strtab + aux->vda_name), 0)
134 == 0)
135 /* Bingo! */
136 return 0;
137 }
138
139 /* If no more definitions we failed to find what we want. */
140 if (def->vd_next == 0)
141 break;
142
143 /* Next definition. */
144 def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
145 }
146
147 /* Symbol not found. If it was a weak reference it is not fatal. */
148 if (__glibc_likely (weak))
149 {
150 if (verbose)
151 {
152 /* XXX We cannot translate the message. */
153 errstring = make_string ("weak version `", string,
154 "' not found (required by ", name, ")");
155 goto call_cerror;
156 }
157 return 0;
158 }
159
160 /* XXX We cannot translate the message. */
161 errstring = make_string ("version `", string, "' not found (required by ",
162 name, ")");
163 result = 1;
164 call_cerror:
165 _dl_signal_cerror (0, DSO_FILENAME (map->l_name),
166 N_("version lookup error"), errstring);
167 return result;
168}
169
170
171int
172internal_function
173_dl_check_map_versions (struct link_map *map, int verbose, int trace_mode)
174{
175 int result = 0;
176 const char *strtab;
177 /* Pointer to section with needed versions. */
178 ElfW(Dyn) *dyn;
179 /* Pointer to dynamic section with definitions. */
180 ElfW(Dyn) *def;
181 /* We need to find out which is the highest version index used
182 in a dependecy. */
183 unsigned int ndx_high = 0;
184 /* Initialize to make the compiler happy. */
185 const char *errstring = NULL;
186 int errval = 0;
187
188 /* If we don't have a string table, we must be ok. */
189 if (map->l_info[DT_STRTAB] == NULL)
190 return 0;
191 strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
192
193 dyn = map->l_info[VERSYMIDX (DT_VERNEED)];
194 def = map->l_info[VERSYMIDX (DT_VERDEF)];
195
196 if (dyn != NULL)
197 {
198 /* This file requires special versions from its dependencies. */
199 ElfW(Verneed) *ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
200
201 /* Currently the version number of the needed entry is 1.
202 Make sure all we see is this version. */
203 if (__builtin_expect (ent->vn_version, 1) != 1)
204 {
205 char buf[20];
206 buf[sizeof (buf) - 1] = '\0';
207 /* XXX We cannot translate the message. */
208 errstring = make_string ("unsupported version ",
209 _itoa (ent->vn_version,
210 &buf[sizeof (buf) - 1], 10, 0),
211 " of Verneed record\n");
212 call_error:
213 _dl_signal_error (errval, DSO_FILENAME (map->l_name),
214 NULL, errstring);
215 }
216
217 while (1)
218 {
219 ElfW(Vernaux) *aux;
220 struct link_map *needed = find_needed (strtab + ent->vn_file, map);
221
222 /* If NEEDED is NULL this means a dependency was not found
223 and no stub entry was created. This should never happen. */
224 assert (needed != NULL);
225
226 /* Make sure this is no stub we created because of a missing
227 dependency. */
228 if (__builtin_expect (! trace_mode, 1)
229 || ! __builtin_expect (needed->l_faked, 0))
230 {
231 /* NEEDED is the map for the file we need. Now look for the
232 dependency symbols. */
233 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
234 while (1)
235 {
236 /* Match the symbol. */
237 result |= match_symbol (DSO_FILENAME (map->l_name),
238 map->l_ns, aux->vna_hash,
239 strtab + aux->vna_name,
240 needed->l_real, verbose,
241 aux->vna_flags & VER_FLG_WEAK);
242
243 /* Compare the version index. */
244 if ((unsigned int) (aux->vna_other & 0x7fff) > ndx_high)
245 ndx_high = aux->vna_other & 0x7fff;
246
247 if (aux->vna_next == 0)
248 /* No more symbols. */
249 break;
250
251 /* Next symbol. */
252 aux = (ElfW(Vernaux) *) ((char *) aux + aux->vna_next);
253 }
254 }
255
256 if (ent->vn_next == 0)
257 /* No more dependencies. */
258 break;
259
260 /* Next dependency. */
261 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
262 }
263 }
264
265 /* We also must store the names of the defined versions. Determine
266 the maximum index here as well.
267
268 XXX We could avoid the loop by just taking the number of definitions
269 as an upper bound of new indeces. */
270 if (def != NULL)
271 {
272 ElfW(Verdef) *ent;
273 ent = (ElfW(Verdef) *) (map->l_addr + def->d_un.d_ptr);
274 while (1)
275 {
276 if ((unsigned int) (ent->vd_ndx & 0x7fff) > ndx_high)
277 ndx_high = ent->vd_ndx & 0x7fff;
278
279 if (ent->vd_next == 0)
280 /* No more definitions. */
281 break;
282
283 ent = (ElfW(Verdef) *) ((char *) ent + ent->vd_next);
284 }
285 }
286
287 if (ndx_high > 0)
288 {
289 /* Now we are ready to build the array with the version names
290 which can be indexed by the version index in the VERSYM
291 section. */
292 map->l_versions = (struct r_found_version *)
293 calloc (ndx_high + 1, sizeof (*map->l_versions));
294 if (__glibc_unlikely (map->l_versions == NULL))
295 {
296 errstring = N_("cannot allocate version reference table");
297 errval = ENOMEM;
298 goto call_error;
299 }
300
301 /* Store the number of available symbols. */
302 map->l_nversions = ndx_high + 1;
303
304 /* Compute the pointer to the version symbols. */
305 map->l_versyms = (void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
306
307 if (dyn != NULL)
308 {
309 ElfW(Verneed) *ent;
310 ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
311 while (1)
312 {
313 ElfW(Vernaux) *aux;
314 aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
315 while (1)
316 {
317 ElfW(Half) ndx = aux->vna_other & 0x7fff;
318 /* In trace mode, dependencies may be missing. */
319 if (__glibc_likely (ndx < map->l_nversions))
320 {
321 map->l_versions[ndx].hash = aux->vna_hash;
322 map->l_versions[ndx].hidden = aux->vna_other & 0x8000;
323 map->l_versions[ndx].name = &strtab[aux->vna_name];
324 map->l_versions[ndx].filename = &strtab[ent->vn_file];
325 }
326
327 if (aux->vna_next == 0)
328 /* No more symbols. */
329 break;
330
331 /* Advance to next symbol. */
332 aux = (ElfW(Vernaux) *) ((char *) aux + aux->vna_next);
333 }
334
335 if (ent->vn_next == 0)
336 /* No more dependencies. */
337 break;
338
339 /* Advance to next dependency. */
340 ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
341 }
342 }
343
344 /* And insert the defined versions. */
345 if (def != NULL)
346 {
347 ElfW(Verdef) *ent;
348 ent = (ElfW(Verdef) *) (map->l_addr + def->d_un.d_ptr);
349 while (1)
350 {
351 ElfW(Verdaux) *aux;
352 aux = (ElfW(Verdaux) *) ((char *) ent + ent->vd_aux);
353
354 if ((ent->vd_flags & VER_FLG_BASE) == 0)
355 {
356 /* The name of the base version should not be
357 available for matching a versioned symbol. */
358 ElfW(Half) ndx = ent->vd_ndx & 0x7fff;
359 map->l_versions[ndx].hash = ent->vd_hash;
360 map->l_versions[ndx].name = &strtab[aux->vda_name];
361 map->l_versions[ndx].filename = NULL;
362 }
363
364 if (ent->vd_next == 0)
365 /* No more definitions. */
366 break;
367
368 ent = (ElfW(Verdef) *) ((char *) ent + ent->vd_next);
369 }
370 }
371 }
372
373 return result;
374}
375
376
377int
378internal_function
379_dl_check_all_versions (struct link_map *map, int verbose, int trace_mode)
380{
381 struct link_map *l;
382 int result = 0;
383
384 for (l = map; l != NULL; l = l->l_next)
385 result |= (! l->l_faked
386 && _dl_check_map_versions (l, verbose, trace_mode));
387
388 return result;
389}
390