1 | /* Handle symbol and library versioning. |
2 | Copyright (C) 1997-2017 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 | |
49 | static inline struct link_map * |
50 | __attribute ((always_inline)) |
51 | find_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 | |
72 | static int |
73 | internal_function |
74 | match_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 ("\ |
87 | checking 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 ("\ |
100 | no 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 | |
171 | int |
172 | internal_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 | |
377 | int |
378 | internal_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 | |