blob: 0c052e449ad87b8bd932b6eef12f164e6c01330e [file] [log] [blame]
lh9ed821d2023-04-07 01:36:19 -07001/* Map in a shared object's segments from the file.
2 Copyright (C) 1995-2015 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 <elf.h>
20#include <errno.h>
21#include <fcntl.h>
22#include <libintl.h>
23#include <stdbool.h>
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27#include <ldsodefs.h>
28#include <bits/wordsize.h>
29#include <sys/mman.h>
30#include <sys/param.h>
31#include <sys/stat.h>
32#include <sys/types.h>
33#include "dynamic-link.h"
34#include <abi-tag.h>
35#include <stackinfo.h>
36#include <caller.h>
37#include <sysdep.h>
38#include <stap-probe.h>
39
40#include <dl-dst.h>
41#include <dl-load.h>
42#include <dl-map-segments.h>
43#include <dl-unmap-segments.h>
44#include <dl-machine-reject-phdr.h>
45
46
47#include <endian.h>
48#if BYTE_ORDER == BIG_ENDIAN
49# define byteorder ELFDATA2MSB
50#elif BYTE_ORDER == LITTLE_ENDIAN
51# define byteorder ELFDATA2LSB
52#else
53# error "Unknown BYTE_ORDER " BYTE_ORDER
54# define byteorder ELFDATANONE
55#endif
56
57#define STRING(x) __STRING (x)
58
59
60int __stack_prot attribute_hidden attribute_relro
61#if _STACK_GROWS_DOWN && defined PROT_GROWSDOWN
62 = PROT_GROWSDOWN;
63#elif _STACK_GROWS_UP && defined PROT_GROWSUP
64 = PROT_GROWSUP;
65#else
66 = 0;
67#endif
68
69
70/* Type for the buffer we put the ELF header and hopefully the program
71 header. This buffer does not really have to be too large. In most
72 cases the program header follows the ELF header directly. If this
73 is not the case all bets are off and we can make the header
74 arbitrarily large and still won't get it read. This means the only
75 question is how large are the ELF and program header combined. The
76 ELF header 32-bit files is 52 bytes long and in 64-bit files is 64
77 bytes long. Each program header entry is again 32 and 56 bytes
78 long respectively. I.e., even with a file which has 10 program
79 header entries we only have to read 372B/624B respectively. Add to
80 this a bit of margin for program notes and reading 512B and 832B
81 for 32-bit and 64-bit files respecitvely is enough. If this
82 heuristic should really fail for some file the code in
83 `_dl_map_object_from_fd' knows how to recover. */
84struct filebuf
85{
86 ssize_t len;
87#if __WORDSIZE == 32
88# define FILEBUF_SIZE 512
89#else
90# define FILEBUF_SIZE 832
91#endif
92 char buf[FILEBUF_SIZE] __attribute__ ((aligned (__alignof (ElfW(Ehdr)))));
93};
94
95/* This is the decomposed LD_LIBRARY_PATH search path. */
96static struct r_search_path_struct env_path_list attribute_relro;
97
98/* List of the hardware capabilities we might end up using. */
99static const struct r_strlenpair *capstr attribute_relro;
100static size_t ncapstr attribute_relro;
101static size_t max_capstrlen attribute_relro;
102
103
104/* Get the generated information about the trusted directories. */
105#include "trusted-dirs.h"
106
107static const char system_dirs[] = SYSTEM_DIRS;
108static const size_t system_dirs_len[] =
109{
110 SYSTEM_DIRS_LEN
111};
112#define nsystem_dirs_len \
113 (sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))
114
115
116static bool
117is_trusted_path (const char *path, size_t len)
118{
119 const char *trun = system_dirs;
120
121 for (size_t idx = 0; idx < nsystem_dirs_len; ++idx)
122 {
123 if (len == system_dirs_len[idx] && memcmp (trun, path, len) == 0)
124 /* Found it. */
125 return true;
126
127 trun += system_dirs_len[idx] + 1;
128 }
129
130 return false;
131}
132
133
134static bool
135is_trusted_path_normalize (const char *path, size_t len)
136{
137 if (len == 0)
138 return false;
139
140 if (*path == ':')
141 {
142 ++path;
143 --len;
144 }
145
146 char *npath = (char *) alloca (len + 2);
147 char *wnp = npath;
148 while (*path != '\0')
149 {
150 if (path[0] == '/')
151 {
152 if (path[1] == '.')
153 {
154 if (path[2] == '.' && (path[3] == '/' || path[3] == '\0'))
155 {
156 while (wnp > npath && *--wnp != '/')
157 ;
158 path += 3;
159 continue;
160 }
161 else if (path[2] == '/' || path[2] == '\0')
162 {
163 path += 2;
164 continue;
165 }
166 }
167
168 if (wnp > npath && wnp[-1] == '/')
169 {
170 ++path;
171 continue;
172 }
173 }
174
175 *wnp++ = *path++;
176 }
177
178 if (wnp == npath || wnp[-1] != '/')
179 *wnp++ = '/';
180
181 const char *trun = system_dirs;
182
183 for (size_t idx = 0; idx < nsystem_dirs_len; ++idx)
184 {
185 if (wnp - npath >= system_dirs_len[idx]
186 && memcmp (trun, npath, system_dirs_len[idx]) == 0)
187 /* Found it. */
188 return true;
189
190 trun += system_dirs_len[idx] + 1;
191 }
192
193 return false;
194}
195
196
197static size_t
198is_dst (const char *start, const char *name, const char *str,
199 int is_path, int secure)
200{
201 size_t len;
202 bool is_curly = false;
203
204 if (name[0] == '{')
205 {
206 is_curly = true;
207 ++name;
208 }
209
210 len = 0;
211 while (name[len] == str[len] && name[len] != '\0')
212 ++len;
213
214 if (is_curly)
215 {
216 if (name[len] != '}')
217 return 0;
218
219 /* Point again at the beginning of the name. */
220 --name;
221 /* Skip over closing curly brace and adjust for the --name. */
222 len += 2;
223 }
224 else if (name[len] != '\0' && name[len] != '/'
225 && (!is_path || name[len] != ':'))
226 return 0;
227
228 if (__glibc_unlikely (secure)
229 && ((name[len] != '\0' && name[len] != '/'
230 && (!is_path || name[len] != ':'))
231 || (name != start + 1 && (!is_path || name[-2] != ':'))))
232 return 0;
233
234 return len;
235}
236
237
238size_t
239_dl_dst_count (const char *name, int is_path)
240{
241 const char *const start = name;
242 size_t cnt = 0;
243
244 do
245 {
246 size_t len;
247
248 /* $ORIGIN is not expanded for SUID/GUID programs (except if it
249 is $ORIGIN alone) and it must always appear first in path. */
250 ++name;
251 if ((len = is_dst (start, name, "ORIGIN", is_path,
252 __libc_enable_secure)) != 0
253 || (len = is_dst (start, name, "PLATFORM", is_path, 0)) != 0
254 || (len = is_dst (start, name, "LIB", is_path, 0)) != 0)
255 ++cnt;
256
257 name = strchr (name + len, '$');
258 }
259 while (name != NULL);
260
261 return cnt;
262}
263
264
265char *
266_dl_dst_substitute (struct link_map *l, const char *name, char *result,
267 int is_path)
268{
269 const char *const start = name;
270
271 /* Now fill the result path. While copying over the string we keep
272 track of the start of the last path element. When we come across
273 a DST we copy over the value or (if the value is not available)
274 leave the entire path element out. */
275 char *wp = result;
276 char *last_elem = result;
277 bool check_for_trusted = false;
278
279 do
280 {
281 if (__glibc_unlikely (*name == '$'))
282 {
283 const char *repl = NULL;
284 size_t len;
285
286 ++name;
287 if ((len = is_dst (start, name, "ORIGIN", is_path,
288 __libc_enable_secure)) != 0)
289 {
290 repl = l->l_origin;
291 check_for_trusted = (__libc_enable_secure
292 && l->l_type == lt_executable);
293 }
294 else if ((len = is_dst (start, name, "PLATFORM", is_path, 0)) != 0)
295 repl = GLRO(dl_platform);
296 else if ((len = is_dst (start, name, "LIB", is_path, 0)) != 0)
297 repl = DL_DST_LIB;
298
299 if (repl != NULL && repl != (const char *) -1)
300 {
301 wp = __stpcpy (wp, repl);
302 name += len;
303 }
304 else if (len > 1)
305 {
306 /* We cannot use this path element, the value of the
307 replacement is unknown. */
308 wp = last_elem;
309 name += len;
310 while (*name != '\0' && (!is_path || *name != ':'))
311 ++name;
312 /* Also skip following colon if this is the first rpath
313 element, but keep an empty element at the end. */
314 if (wp == result && is_path && *name == ':' && name[1] != '\0')
315 ++name;
316 }
317 else
318 /* No DST we recognize. */
319 *wp++ = '$';
320 }
321 else
322 {
323 *wp++ = *name++;
324 if (is_path && *name == ':')
325 {
326 /* In SUID/SGID programs, after $ORIGIN expansion the
327 normalized path must be rooted in one of the trusted
328 directories. */
329 if (__glibc_unlikely (check_for_trusted)
330 && !is_trusted_path_normalize (last_elem, wp - last_elem))
331 wp = last_elem;
332 else
333 last_elem = wp;
334
335 check_for_trusted = false;
336 }
337 }
338 }
339 while (*name != '\0');
340
341 /* In SUID/SGID programs, after $ORIGIN expansion the normalized
342 path must be rooted in one of the trusted directories. */
343 if (__glibc_unlikely (check_for_trusted)
344 && !is_trusted_path_normalize (last_elem, wp - last_elem))
345 wp = last_elem;
346
347 *wp = '\0';
348
349 return result;
350}
351
352
353/* Return copy of argument with all recognized dynamic string tokens
354 ($ORIGIN and $PLATFORM for now) replaced. On some platforms it
355 might not be possible to determine the path from which the object
356 belonging to the map is loaded. In this case the path element
357 containing $ORIGIN is left out. */
358static char *
359expand_dynamic_string_token (struct link_map *l, const char *s, int is_path)
360{
361 /* We make two runs over the string. First we determine how large the
362 resulting string is and then we copy it over. Since this is no
363 frequently executed operation we are looking here not for performance
364 but rather for code size. */
365 size_t cnt;
366 size_t total;
367 char *result;
368
369 /* Determine the number of DST elements. */
370 cnt = DL_DST_COUNT (s, is_path);
371
372 /* If we do not have to replace anything simply copy the string. */
373 if (__glibc_likely (cnt == 0))
374 return __strdup (s);
375
376 /* Determine the length of the substituted string. */
377 total = DL_DST_REQUIRED (l, s, strlen (s), cnt);
378
379 /* Allocate the necessary memory. */
380 result = (char *) malloc (total + 1);
381 if (result == NULL)
382 return NULL;
383
384 return _dl_dst_substitute (l, s, result, is_path);
385}
386
387
388/* Add `name' to the list of names for a particular shared object.
389 `name' is expected to have been allocated with malloc and will
390 be freed if the shared object already has this name.
391 Returns false if the object already had this name. */
392static void
393internal_function
394add_name_to_object (struct link_map *l, const char *name)
395{
396 struct libname_list *lnp, *lastp;
397 struct libname_list *newname;
398 size_t name_len;
399
400 lastp = NULL;
401 for (lnp = l->l_libname; lnp != NULL; lastp = lnp, lnp = lnp->next)
402 if (strcmp (name, lnp->name) == 0)
403 return;
404
405 name_len = strlen (name) + 1;
406 newname = (struct libname_list *) malloc (sizeof *newname + name_len);
407 if (newname == NULL)
408 {
409 /* No more memory. */
410 _dl_signal_error (ENOMEM, name, NULL, N_("cannot allocate name record"));
411 return;
412 }
413 /* The object should have a libname set from _dl_new_object. */
414 assert (lastp != NULL);
415
416 newname->name = memcpy (newname + 1, name, name_len);
417 newname->next = NULL;
418 newname->dont_free = 0;
419 lastp->next = newname;
420}
421
422/* Standard search directories. */
423static struct r_search_path_struct rtld_search_dirs attribute_relro;
424
425static size_t max_dirnamelen;
426
427static struct r_search_path_elem **
428fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
429 int check_trusted, const char *what, const char *where,
430 struct link_map *l)
431{
432 char *cp;
433 size_t nelems = 0;
434 char *to_free;
435
436 while ((cp = __strsep (&rpath, sep)) != NULL)
437 {
438 struct r_search_path_elem *dirp;
439
440 to_free = cp = expand_dynamic_string_token (l, cp, 1);
441
442 size_t len = strlen (cp);
443
444 /* `strsep' can pass an empty string. This has to be
445 interpreted as `use the current directory'. */
446 if (len == 0)
447 {
448 static const char curwd[] = "./";
449 cp = (char *) curwd;
450 }
451
452 /* Remove trailing slashes (except for "/"). */
453 while (len > 1 && cp[len - 1] == '/')
454 --len;
455
456 /* Now add one if there is none so far. */
457 if (len > 0 && cp[len - 1] != '/')
458 cp[len++] = '/';
459
460 /* Make sure we don't use untrusted directories if we run SUID. */
461 if (__glibc_unlikely (check_trusted) && !is_trusted_path (cp, len))
462 {
463 free (to_free);
464 continue;
465 }
466
467 /* See if this directory is already known. */
468 for (dirp = GL(dl_all_dirs); dirp != NULL; dirp = dirp->next)
469 if (dirp->dirnamelen == len && memcmp (cp, dirp->dirname, len) == 0)
470 break;
471
472 if (dirp != NULL)
473 {
474 /* It is available, see whether it's on our own list. */
475 size_t cnt;
476 for (cnt = 0; cnt < nelems; ++cnt)
477 if (result[cnt] == dirp)
478 break;
479
480 if (cnt == nelems)
481 result[nelems++] = dirp;
482 }
483 else
484 {
485 size_t cnt;
486 enum r_dir_status init_val;
487 size_t where_len = where ? strlen (where) + 1 : 0;
488
489 /* It's a new directory. Create an entry and add it. */
490 dirp = (struct r_search_path_elem *)
491 malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status)
492 + where_len + len + 1);
493 if (dirp == NULL)
494 _dl_signal_error (ENOMEM, NULL, NULL,
495 N_("cannot create cache for search path"));
496
497 dirp->dirname = ((char *) dirp + sizeof (*dirp)
498 + ncapstr * sizeof (enum r_dir_status));
499 *((char *) __mempcpy ((char *) dirp->dirname, cp, len)) = '\0';
500 dirp->dirnamelen = len;
501
502 if (len > max_dirnamelen)
503 max_dirnamelen = len;
504
505 /* We have to make sure all the relative directories are
506 never ignored. The current directory might change and
507 all our saved information would be void. */
508 init_val = cp[0] != '/' ? existing : unknown;
509 for (cnt = 0; cnt < ncapstr; ++cnt)
510 dirp->status[cnt] = init_val;
511
512 dirp->what = what;
513 if (__glibc_likely (where != NULL))
514 dirp->where = memcpy ((char *) dirp + sizeof (*dirp) + len + 1
515 + (ncapstr * sizeof (enum r_dir_status)),
516 where, where_len);
517 else
518 dirp->where = NULL;
519
520 dirp->next = GL(dl_all_dirs);
521 GL(dl_all_dirs) = dirp;
522
523 /* Put it in the result array. */
524 result[nelems++] = dirp;
525 }
526 free (to_free);
527 }
528
529 /* Terminate the array. */
530 result[nelems] = NULL;
531
532 return result;
533}
534
535
536static bool
537internal_function
538decompose_rpath (struct r_search_path_struct *sps,
539 const char *rpath, struct link_map *l, const char *what)
540{
541 /* Make a copy we can work with. */
542 const char *where = l->l_name;
543 char *copy;
544 char *cp;
545 struct r_search_path_elem **result;
546 size_t nelems;
547 /* Initialize to please the compiler. */
548 const char *errstring = NULL;
549
550 /* First see whether we must forget the RUNPATH and RPATH from this
551 object. */
552 if (__glibc_unlikely (GLRO(dl_inhibit_rpath) != NULL)
553 && !__libc_enable_secure)
554 {
555 const char *inhp = GLRO(dl_inhibit_rpath);
556
557 do
558 {
559 const char *wp = where;
560
561 while (*inhp == *wp && *wp != '\0')
562 {
563 ++inhp;
564 ++wp;
565 }
566
567 if (*wp == '\0' && (*inhp == '\0' || *inhp == ':'))
568 {
569 /* This object is on the list of objects for which the
570 RUNPATH and RPATH must not be used. */
571 sps->dirs = (void *) -1;
572 return false;
573 }
574
575 while (*inhp != '\0')
576 if (*inhp++ == ':')
577 break;
578 }
579 while (*inhp != '\0');
580 }
581
582 /* Make a writable copy. */
583 copy = __strdup (rpath);
584 if (copy == NULL)
585 {
586 errstring = N_("cannot create RUNPATH/RPATH copy");
587 goto signal_error;
588 }
589
590 /* Ignore empty rpaths. */
591 if (*copy == 0)
592 {
593 free (copy);
594 sps->dirs = (struct r_search_path_elem **) -1;
595 return false;
596 }
597
598 /* Count the number of necessary elements in the result array. */
599 nelems = 0;
600 for (cp = copy; *cp != '\0'; ++cp)
601 if (*cp == ':')
602 ++nelems;
603
604 /* Allocate room for the result. NELEMS + 1 is an upper limit for the
605 number of necessary entries. */
606 result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
607 * sizeof (*result));
608 if (result == NULL)
609 {
610 free (copy);
611 errstring = N_("cannot create cache for search path");
612 signal_error:
613 _dl_signal_error (ENOMEM, NULL, NULL, errstring);
614 }
615
616 fillin_rpath (copy, result, ":", 0, what, where, l);
617
618 /* Free the copied RPATH string. `fillin_rpath' make own copies if
619 necessary. */
620 free (copy);
621
622 sps->dirs = result;
623 /* The caller will change this value if we haven't used a real malloc. */
624 sps->malloced = 1;
625 return true;
626}
627
628/* Make sure cached path information is stored in *SP
629 and return true if there are any paths to search there. */
630static bool
631cache_rpath (struct link_map *l,
632 struct r_search_path_struct *sp,
633 int tag,
634 const char *what)
635{
636 if (sp->dirs == (void *) -1)
637 return false;
638
639 if (sp->dirs != NULL)
640 return true;
641
642 if (l->l_info[tag] == NULL)
643 {
644 /* There is no path. */
645 sp->dirs = (void *) -1;
646 return false;
647 }
648
649 /* Make sure the cache information is available. */
650 return decompose_rpath (sp, (const char *) (D_PTR (l, l_info[DT_STRTAB])
651 + l->l_info[tag]->d_un.d_val),
652 l, what);
653}
654
655
656void
657internal_function
658_dl_init_paths (const char *llp)
659{
660 size_t idx;
661 const char *strp;
662 struct r_search_path_elem *pelem, **aelem;
663 size_t round_size;
664 struct link_map __attribute__ ((unused)) *l = NULL;
665 /* Initialize to please the compiler. */
666 const char *errstring = NULL;
667
668 /* Fill in the information about the application's RPATH and the
669 directories addressed by the LD_LIBRARY_PATH environment variable. */
670
671 /* Get the capabilities. */
672 capstr = _dl_important_hwcaps (GLRO(dl_platform), GLRO(dl_platformlen),
673 &ncapstr, &max_capstrlen);
674
675 /* First set up the rest of the default search directory entries. */
676 aelem = rtld_search_dirs.dirs = (struct r_search_path_elem **)
677 malloc ((nsystem_dirs_len + 1) * sizeof (struct r_search_path_elem *));
678 if (rtld_search_dirs.dirs == NULL)
679 {
680 errstring = N_("cannot create search path array");
681 signal_error:
682 _dl_signal_error (ENOMEM, NULL, NULL, errstring);
683 }
684
685 round_size = ((2 * sizeof (struct r_search_path_elem) - 1
686 + ncapstr * sizeof (enum r_dir_status))
687 / sizeof (struct r_search_path_elem));
688
689 rtld_search_dirs.dirs[0] = (struct r_search_path_elem *)
690 malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
691 * round_size * sizeof (struct r_search_path_elem));
692 if (rtld_search_dirs.dirs[0] == NULL)
693 {
694 errstring = N_("cannot create cache for search path");
695 goto signal_error;
696 }
697
698 rtld_search_dirs.malloced = 0;
699 pelem = GL(dl_all_dirs) = rtld_search_dirs.dirs[0];
700 strp = system_dirs;
701 idx = 0;
702
703 do
704 {
705 size_t cnt;
706
707 *aelem++ = pelem;
708
709 pelem->what = "system search path";
710 pelem->where = NULL;
711
712 pelem->dirname = strp;
713 pelem->dirnamelen = system_dirs_len[idx];
714 strp += system_dirs_len[idx] + 1;
715
716 /* System paths must be absolute. */
717 assert (pelem->dirname[0] == '/');
718 for (cnt = 0; cnt < ncapstr; ++cnt)
719 pelem->status[cnt] = unknown;
720
721 pelem->next = (++idx == nsystem_dirs_len ? NULL : (pelem + round_size));
722
723 pelem += round_size;
724 }
725 while (idx < nsystem_dirs_len);
726
727 max_dirnamelen = SYSTEM_DIRS_MAX_LEN;
728 *aelem = NULL;
729
730#ifdef SHARED
731 /* This points to the map of the main object. */
732 l = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
733 if (l != NULL)
734 {
735 assert (l->l_type != lt_loaded);
736
737 if (l->l_info[DT_RUNPATH])
738 {
739 /* Allocate room for the search path and fill in information
740 from RUNPATH. */
741 decompose_rpath (&l->l_runpath_dirs,
742 (const void *) (D_PTR (l, l_info[DT_STRTAB])
743 + l->l_info[DT_RUNPATH]->d_un.d_val),
744 l, "RUNPATH");
745 /* During rtld init the memory is allocated by the stub malloc,
746 prevent any attempt to free it by the normal malloc. */
747 l->l_runpath_dirs.malloced = 0;
748
749 /* The RPATH is ignored. */
750 l->l_rpath_dirs.dirs = (void *) -1;
751 }
752 else
753 {
754 l->l_runpath_dirs.dirs = (void *) -1;
755
756 if (l->l_info[DT_RPATH])
757 {
758 /* Allocate room for the search path and fill in information
759 from RPATH. */
760 decompose_rpath (&l->l_rpath_dirs,
761 (const void *) (D_PTR (l, l_info[DT_STRTAB])
762 + l->l_info[DT_RPATH]->d_un.d_val),
763 l, "RPATH");
764 /* During rtld init the memory is allocated by the stub
765 malloc, prevent any attempt to free it by the normal
766 malloc. */
767 l->l_rpath_dirs.malloced = 0;
768 }
769 else
770 l->l_rpath_dirs.dirs = (void *) -1;
771 }
772 }
773#endif /* SHARED */
774
775 if (llp != NULL && *llp != '\0')
776 {
777 size_t nllp;
778 const char *cp = llp;
779 char *llp_tmp;
780
781#ifdef SHARED
782 /* Expand DSTs. */
783 size_t cnt = DL_DST_COUNT (llp, 1);
784 if (__glibc_likely (cnt == 0))
785 llp_tmp = strdupa (llp);
786 else
787 {
788 /* Determine the length of the substituted string. */
789 size_t total = DL_DST_REQUIRED (l, llp, strlen (llp), cnt);
790
791 /* Allocate the necessary memory. */
792 llp_tmp = (char *) alloca (total + 1);
793 llp_tmp = _dl_dst_substitute (l, llp, llp_tmp, 1);
794 }
795#else
796 llp_tmp = strdupa (llp);
797#endif
798
799 /* Decompose the LD_LIBRARY_PATH contents. First determine how many
800 elements it has. */
801 nllp = 1;
802 while (*cp)
803 {
804 if (*cp == ':' || *cp == ';')
805 ++nllp;
806 ++cp;
807 }
808
809 env_path_list.dirs = (struct r_search_path_elem **)
810 malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
811 if (env_path_list.dirs == NULL)
812 {
813 errstring = N_("cannot create cache for search path");
814 goto signal_error;
815 }
816
817 (void) fillin_rpath (llp_tmp, env_path_list.dirs, ":;",
818 __libc_enable_secure, "LD_LIBRARY_PATH",
819 NULL, l);
820
821 if (env_path_list.dirs[0] == NULL)
822 {
823 free (env_path_list.dirs);
824 env_path_list.dirs = (void *) -1;
825 }
826
827 env_path_list.malloced = 0;
828 }
829 else
830 env_path_list.dirs = (void *) -1;
831}
832
833
834static void
835__attribute__ ((noreturn, noinline))
836lose (int code, int fd, const char *name, char *realname, struct link_map *l,
837 const char *msg, struct r_debug *r, Lmid_t nsid)
838{
839 /* The file might already be closed. */
840 if (fd != -1)
841 (void) __close (fd);
842 if (l != NULL && l->l_origin != (char *) -1l)
843 free ((char *) l->l_origin);
844 free (l);
845 free (realname);
846
847 if (r != NULL)
848 {
849 r->r_state = RT_CONSISTENT;
850 _dl_debug_state ();
851 LIBC_PROBE (map_failed, 2, nsid, r);
852 }
853
854 _dl_signal_error (code, name, NULL, msg);
855}
856
857
858/* Map in the shared object NAME, actually located in REALNAME, and already
859 opened on FD. */
860
861#ifndef EXTERNAL_MAP_FROM_FD
862static
863#endif
864struct link_map *
865_dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
866 char *realname, struct link_map *loader, int l_type,
867 int mode, void **stack_endp, Lmid_t nsid)
868{
869 struct link_map *l = NULL;
870 const ElfW(Ehdr) *header;
871 const ElfW(Phdr) *phdr;
872 const ElfW(Phdr) *ph;
873 size_t maplength;
874 int type;
875 /* Initialize to keep the compiler happy. */
876 const char *errstring = NULL;
877 int errval = 0;
878 struct r_debug *r = _dl_debug_initialize (0, nsid);
879 bool make_consistent = false;
880
881 /* Get file information. */
882 struct r_file_id id;
883 if (__glibc_unlikely (!_dl_get_file_id (fd, &id)))
884 {
885 errstring = N_("cannot stat shared object");
886 call_lose_errno:
887 errval = errno;
888 call_lose:
889 lose (errval, fd, name, realname, l, errstring,
890 make_consistent ? r : NULL, nsid);
891 }
892
893 /* Look again to see if the real name matched another already loaded. */
894 for (l = GL(dl_ns)[nsid]._ns_loaded; l != NULL; l = l->l_next)
895 if (!l->l_removed && _dl_file_id_match_p (&l->l_file_id, &id))
896 {
897 /* The object is already loaded.
898 Just bump its reference count and return it. */
899 __close (fd);
900
901 /* If the name is not in the list of names for this object add
902 it. */
903 free (realname);
904 add_name_to_object (l, name);
905
906 return l;
907 }
908
909#ifdef SHARED
910 /* When loading into a namespace other than the base one we must
911 avoid loading ld.so since there can only be one copy. Ever. */
912 if (__glibc_unlikely (nsid != LM_ID_BASE)
913 && (_dl_file_id_match_p (&id, &GL(dl_rtld_map).l_file_id)
914 || _dl_name_match_p (name, &GL(dl_rtld_map))))
915 {
916 /* This is indeed ld.so. Create a new link_map which refers to
917 the real one for almost everything. */
918 l = _dl_new_object (realname, name, l_type, loader, mode, nsid);
919 if (l == NULL)
920 goto fail_new;
921
922 /* Refer to the real descriptor. */
923 l->l_real = &GL(dl_rtld_map);
924
925 /* No need to bump the refcount of the real object, ld.so will
926 never be unloaded. */
927 __close (fd);
928
929 /* Add the map for the mirrored object to the object list. */
930 _dl_add_to_namespace_list (l, nsid);
931
932 return l;
933 }
934#endif
935
936 if (mode & RTLD_NOLOAD)
937 {
938 /* We are not supposed to load the object unless it is already
939 loaded. So return now. */
940 free (realname);
941 __close (fd);
942 return NULL;
943 }
944
945 /* Print debugging message. */
946 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
947 _dl_debug_printf ("file=%s [%lu]; generating link map\n", name, nsid);
948
949 /* This is the ELF header. We read it in `open_verify'. */
950 header = (void *) fbp->buf;
951
952#ifndef MAP_ANON
953# define MAP_ANON 0
954 if (_dl_zerofd == -1)
955 {
956 _dl_zerofd = _dl_sysdep_open_zero_fill ();
957 if (_dl_zerofd == -1)
958 {
959 free (realname);
960 __close (fd);
961 _dl_signal_error (errno, NULL, NULL,
962 N_("cannot open zero fill device"));
963 }
964 }
965#endif
966
967 /* Signal that we are going to add new objects. */
968 if (r->r_state == RT_CONSISTENT)
969 {
970#ifdef SHARED
971 /* Auditing checkpoint: we are going to add new objects. */
972 if ((mode & __RTLD_AUDIT) == 0
973 && __glibc_unlikely (GLRO(dl_naudit) > 0))
974 {
975 struct link_map *head = GL(dl_ns)[nsid]._ns_loaded;
976 /* Do not call the functions for any auditing object. */
977 if (head->l_auditing == 0)
978 {
979 struct audit_ifaces *afct = GLRO(dl_audit);
980 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
981 {
982 if (afct->activity != NULL)
983 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_ADD);
984
985 afct = afct->next;
986 }
987 }
988 }
989#endif
990
991 /* Notify the debugger we have added some objects. We need to
992 call _dl_debug_initialize in a static program in case dynamic
993 linking has not been used before. */
994 r->r_state = RT_ADD;
995 _dl_debug_state ();
996 LIBC_PROBE (map_start, 2, nsid, r);
997 make_consistent = true;
998 }
999 else
1000 assert (r->r_state == RT_ADD);
1001
1002 /* Enter the new object in the list of loaded objects. */
1003 l = _dl_new_object (realname, name, l_type, loader, mode, nsid);
1004 if (__glibc_unlikely (l == NULL))
1005 {
1006#ifdef SHARED
1007 fail_new:
1008#endif
1009 errstring = N_("cannot create shared object descriptor");
1010 goto call_lose_errno;
1011 }
1012
1013 /* Extract the remaining details we need from the ELF header
1014 and then read in the program header table. */
1015 l->l_entry = header->e_entry;
1016 type = header->e_type;
1017 l->l_phnum = header->e_phnum;
1018
1019 maplength = header->e_phnum * sizeof (ElfW(Phdr));
1020 if (header->e_phoff + maplength <= (size_t) fbp->len)
1021 phdr = (void *) (fbp->buf + header->e_phoff);
1022 else
1023 {
1024 phdr = alloca (maplength);
1025 __lseek (fd, header->e_phoff, SEEK_SET);
1026 if ((size_t) __libc_read (fd, (void *) phdr, maplength) != maplength)
1027 {
1028 errstring = N_("cannot read file data");
1029 goto call_lose_errno;
1030 }
1031 }
1032
1033 /* On most platforms presume that PT_GNU_STACK is absent and the stack is
1034 * executable. Other platforms default to a nonexecutable stack and don't
1035 * need PT_GNU_STACK to do so. */
1036 uint_fast16_t stack_flags = DEFAULT_STACK_PERMS;
1037
1038 {
1039 /* Scan the program header table, collecting its load commands. */
1040 struct loadcmd loadcmds[l->l_phnum];
1041 size_t nloadcmds = 0;
1042 bool has_holes = false;
1043
1044 /* The struct is initialized to zero so this is not necessary:
1045 l->l_ld = 0;
1046 l->l_phdr = 0;
1047 l->l_addr = 0; */
1048 for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
1049 switch (ph->p_type)
1050 {
1051 /* These entries tell us where to find things once the file's
1052 segments are mapped in. We record the addresses it says
1053 verbatim, and later correct for the run-time load address. */
1054 case PT_DYNAMIC:
1055 l->l_ld = (void *) ph->p_vaddr;
1056 l->l_ldnum = ph->p_memsz / sizeof (ElfW(Dyn));
1057 break;
1058
1059 case PT_PHDR:
1060 l->l_phdr = (void *) ph->p_vaddr;
1061 break;
1062
1063 case PT_LOAD:
1064 /* A load command tells us to map in part of the file.
1065 We record the load commands and process them all later. */
1066 if (__glibc_unlikely ((ph->p_align & (GLRO(dl_pagesize) - 1)) != 0))
1067 {
1068 errstring = N_("ELF load command alignment not page-aligned");
1069 goto call_lose;
1070 }
1071 if (__glibc_unlikely (((ph->p_vaddr - ph->p_offset)
1072 & (ph->p_align - 1)) != 0))
1073 {
1074 errstring
1075 = N_("ELF load command address/offset not properly aligned");
1076 goto call_lose;
1077 }
1078
1079 struct loadcmd *c = &loadcmds[nloadcmds++];
1080 c->mapstart = ph->p_vaddr & ~(GLRO(dl_pagesize) - 1);
1081 c->mapend = ((ph->p_vaddr + ph->p_filesz + GLRO(dl_pagesize) - 1)
1082 & ~(GLRO(dl_pagesize) - 1));
1083 c->dataend = ph->p_vaddr + ph->p_filesz;
1084 c->allocend = ph->p_vaddr + ph->p_memsz;
1085 c->mapoff = ph->p_offset & ~(GLRO(dl_pagesize) - 1);
1086
1087 /* Determine whether there is a gap between the last segment
1088 and this one. */
1089 if (nloadcmds > 1 && c[-1].mapend != c->mapstart)
1090 has_holes = true;
1091
1092 /* Optimize a common case. */
1093#if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
1094 c->prot = (PF_TO_PROT
1095 >> ((ph->p_flags & (PF_R | PF_W | PF_X)) * 4)) & 0xf;
1096#else
1097 c->prot = 0;
1098 if (ph->p_flags & PF_R)
1099 c->prot |= PROT_READ;
1100 if (ph->p_flags & PF_W)
1101 c->prot |= PROT_WRITE;
1102 if (ph->p_flags & PF_X)
1103 c->prot |= PROT_EXEC;
1104#endif
1105 break;
1106
1107 case PT_TLS:
1108 if (ph->p_memsz == 0)
1109 /* Nothing to do for an empty segment. */
1110 break;
1111
1112 l->l_tls_blocksize = ph->p_memsz;
1113 l->l_tls_align = ph->p_align;
1114 if (ph->p_align == 0)
1115 l->l_tls_firstbyte_offset = 0;
1116 else
1117 l->l_tls_firstbyte_offset = ph->p_vaddr & (ph->p_align - 1);
1118 l->l_tls_initimage_size = ph->p_filesz;
1119 /* Since we don't know the load address yet only store the
1120 offset. We will adjust it later. */
1121 l->l_tls_initimage = (void *) ph->p_vaddr;
1122
1123 /* If not loading the initial set of shared libraries,
1124 check whether we should permit loading a TLS segment. */
1125 if (__glibc_likely (l->l_type == lt_library)
1126 /* If GL(dl_tls_dtv_slotinfo_list) == NULL, then rtld.c did
1127 not set up TLS data structures, so don't use them now. */
1128 || __glibc_likely (GL(dl_tls_dtv_slotinfo_list) != NULL))
1129 {
1130 /* Assign the next available module ID. */
1131 l->l_tls_modid = _dl_next_tls_modid ();
1132 break;
1133 }
1134
1135#ifdef SHARED
1136 if (l->l_prev == NULL || (mode & __RTLD_AUDIT) != 0)
1137 /* We are loading the executable itself when the dynamic linker
1138 was executed directly. The setup will happen later. */
1139 break;
1140
1141# ifdef _LIBC_REENTRANT
1142 /* In a static binary there is no way to tell if we dynamically
1143 loaded libpthread. */
1144 if (GL(dl_error_catch_tsd) == &_dl_initial_error_catch_tsd)
1145# endif
1146#endif
1147 {
1148 /* We have not yet loaded libpthread.
1149 We can do the TLS setup right now! */
1150
1151 void *tcb;
1152
1153 /* The first call allocates TLS bookkeeping data structures.
1154 Then we allocate the TCB for the initial thread. */
1155 if (__glibc_unlikely (_dl_tls_setup ())
1156 || __glibc_unlikely ((tcb = _dl_allocate_tls (NULL)) == NULL))
1157 {
1158 errval = ENOMEM;
1159 errstring = N_("\
1160cannot allocate TLS data structures for initial thread");
1161 goto call_lose;
1162 }
1163
1164 /* Now we install the TCB in the thread register. */
1165 errstring = TLS_INIT_TP (tcb);
1166 if (__glibc_likely (errstring == NULL))
1167 {
1168 /* Now we are all good. */
1169 l->l_tls_modid = ++GL(dl_tls_max_dtv_idx);
1170 break;
1171 }
1172
1173 /* The kernel is too old or somesuch. */
1174 errval = 0;
1175 _dl_deallocate_tls (tcb, 1);
1176 goto call_lose;
1177 }
1178
1179 /* Uh-oh, the binary expects TLS support but we cannot
1180 provide it. */
1181 errval = 0;
1182 errstring = N_("cannot handle TLS data");
1183 goto call_lose;
1184 break;
1185
1186 case PT_GNU_STACK:
1187 stack_flags = ph->p_flags;
1188 break;
1189
1190 case PT_GNU_RELRO:
1191 l->l_relro_addr = ph->p_vaddr;
1192 l->l_relro_size = ph->p_memsz;
1193 break;
1194 }
1195
1196 if (__glibc_unlikely (nloadcmds == 0))
1197 {
1198 /* This only happens for a bogus object that will be caught with
1199 another error below. But we don't want to go through the
1200 calculations below using NLOADCMDS - 1. */
1201 errstring = N_("object file has no loadable segments");
1202 goto call_lose;
1203 }
1204
1205 if (__glibc_unlikely (type != ET_DYN)
1206 && __glibc_unlikely ((mode & __RTLD_OPENEXEC) == 0))
1207 {
1208 /* This object is loaded at a fixed address. This must never
1209 happen for objects loaded with dlopen. */
1210 errstring = N_("cannot dynamically load executable");
1211 goto call_lose;
1212 }
1213
1214 /* Length of the sections to be loaded. */
1215 maplength = loadcmds[nloadcmds - 1].allocend - loadcmds[0].mapstart;
1216
1217 /* Now process the load commands and map segments into memory.
1218 This is responsible for filling in:
1219 l_map_start, l_map_end, l_addr, l_contiguous, l_text_end, l_phdr
1220 */
1221 errstring = _dl_map_segments (l, fd, header, type, loadcmds, nloadcmds,
1222 maplength, has_holes, loader);
1223 if (__glibc_unlikely (errstring != NULL))
1224 goto call_lose;
1225 }
1226
1227 if (l->l_ld == 0)
1228 {
1229 if (__glibc_unlikely (type == ET_DYN))
1230 {
1231 errstring = N_("object file has no dynamic section");
1232 goto call_lose;
1233 }
1234 }
1235 else
1236 l->l_ld = (ElfW(Dyn) *) ((ElfW(Addr)) l->l_ld + l->l_addr);
1237
1238 elf_get_dynamic_info (l, NULL);
1239
1240 /* Make sure we are not dlopen'ing an object that has the
1241 DF_1_NOOPEN flag set. */
1242 if (__glibc_unlikely (l->l_flags_1 & DF_1_NOOPEN)
1243 && (mode & __RTLD_DLOPEN))
1244 {
1245 /* We are not supposed to load this object. Free all resources. */
1246 _dl_unmap_segments (l);
1247
1248 if (!l->l_libname->dont_free)
1249 free (l->l_libname);
1250
1251 if (l->l_phdr_allocated)
1252 free ((void *) l->l_phdr);
1253
1254 errstring = N_("shared object cannot be dlopen()ed");
1255 goto call_lose;
1256 }
1257
1258 if (l->l_phdr == NULL)
1259 {
1260 /* The program header is not contained in any of the segments.
1261 We have to allocate memory ourself and copy it over from out
1262 temporary place. */
1263 ElfW(Phdr) *newp = (ElfW(Phdr) *) malloc (header->e_phnum
1264 * sizeof (ElfW(Phdr)));
1265 if (newp == NULL)
1266 {
1267 errstring = N_("cannot allocate memory for program header");
1268 goto call_lose_errno;
1269 }
1270
1271 l->l_phdr = memcpy (newp, phdr,
1272 (header->e_phnum * sizeof (ElfW(Phdr))));
1273 l->l_phdr_allocated = 1;
1274 }
1275 else
1276 /* Adjust the PT_PHDR value by the runtime load address. */
1277 l->l_phdr = (ElfW(Phdr) *) ((ElfW(Addr)) l->l_phdr + l->l_addr);
1278
1279 if (__glibc_unlikely ((stack_flags &~ GL(dl_stack_flags)) & PF_X))
1280 {
1281 if (__glibc_unlikely (__check_caller (RETURN_ADDRESS (0), allow_ldso) != 0))
1282 {
1283 errstring = N_("invalid caller");
1284 goto call_lose;
1285 }
1286
1287 /* The stack is presently not executable, but this module
1288 requires that it be executable. We must change the
1289 protection of the variable which contains the flags used in
1290 the mprotect calls. */
1291#ifdef SHARED
1292 if ((mode & (__RTLD_DLOPEN | __RTLD_AUDIT)) == __RTLD_DLOPEN)
1293 {
1294 const uintptr_t p = (uintptr_t) &__stack_prot & -GLRO(dl_pagesize);
1295 const size_t s = (uintptr_t) (&__stack_prot + 1) - p;
1296
1297 struct link_map *const m = &GL(dl_rtld_map);
1298 const uintptr_t relro_end = ((m->l_addr + m->l_relro_addr
1299 + m->l_relro_size)
1300 & -GLRO(dl_pagesize));
1301 if (__glibc_likely (p + s <= relro_end))
1302 {
1303 /* The variable lies in the region protected by RELRO. */
1304 if (__mprotect ((void *) p, s, PROT_READ|PROT_WRITE) < 0)
1305 {
1306 errstring = N_("cannot change memory protections");
1307 goto call_lose_errno;
1308 }
1309 __stack_prot |= PROT_READ|PROT_WRITE|PROT_EXEC;
1310 __mprotect ((void *) p, s, PROT_READ);
1311 }
1312 else
1313 __stack_prot |= PROT_READ|PROT_WRITE|PROT_EXEC;
1314 }
1315 else
1316#endif
1317 __stack_prot |= PROT_READ|PROT_WRITE|PROT_EXEC;
1318
1319#ifdef check_consistency
1320 check_consistency ();
1321#endif
1322
1323 errval = (*GL(dl_make_stack_executable_hook)) (stack_endp);
1324 if (errval)
1325 {
1326 errstring = N_("\
1327cannot enable executable stack as shared object requires");
1328 goto call_lose;
1329 }
1330 }
1331
1332 /* Adjust the address of the TLS initialization image. */
1333 if (l->l_tls_initimage != NULL)
1334 l->l_tls_initimage = (char *) l->l_tls_initimage + l->l_addr;
1335
1336 /* We are done mapping in the file. We no longer need the descriptor. */
1337 if (__glibc_unlikely (__close (fd) != 0))
1338 {
1339 errstring = N_("cannot close file descriptor");
1340 goto call_lose_errno;
1341 }
1342 /* Signal that we closed the file. */
1343 fd = -1;
1344
1345 /* If this is ET_EXEC, we should have loaded it as lt_executable. */
1346 assert (type != ET_EXEC || l->l_type == lt_executable);
1347
1348 l->l_entry += l->l_addr;
1349
1350 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
1351 _dl_debug_printf ("\
1352 dynamic: 0x%0*lx base: 0x%0*lx size: 0x%0*Zx\n\
1353 entry: 0x%0*lx phdr: 0x%0*lx phnum: %*u\n\n",
1354 (int) sizeof (void *) * 2,
1355 (unsigned long int) l->l_ld,
1356 (int) sizeof (void *) * 2,
1357 (unsigned long int) l->l_addr,
1358 (int) sizeof (void *) * 2, maplength,
1359 (int) sizeof (void *) * 2,
1360 (unsigned long int) l->l_entry,
1361 (int) sizeof (void *) * 2,
1362 (unsigned long int) l->l_phdr,
1363 (int) sizeof (void *) * 2, l->l_phnum);
1364
1365 /* Set up the symbol hash table. */
1366 _dl_setup_hash (l);
1367
1368 /* If this object has DT_SYMBOLIC set modify now its scope. We don't
1369 have to do this for the main map. */
1370 if ((mode & RTLD_DEEPBIND) == 0
1371 && __glibc_unlikely (l->l_info[DT_SYMBOLIC] != NULL)
1372 && &l->l_searchlist != l->l_scope[0])
1373 {
1374 /* Create an appropriate searchlist. It contains only this map.
1375 This is the definition of DT_SYMBOLIC in SysVr4. */
1376 l->l_symbolic_searchlist.r_list[0] = l;
1377 l->l_symbolic_searchlist.r_nlist = 1;
1378
1379 /* Now move the existing entries one back. */
1380 memmove (&l->l_scope[1], &l->l_scope[0],
1381 (l->l_scope_max - 1) * sizeof (l->l_scope[0]));
1382
1383 /* Now add the new entry. */
1384 l->l_scope[0] = &l->l_symbolic_searchlist;
1385 }
1386
1387 /* Remember whether this object must be initialized first. */
1388 if (l->l_flags_1 & DF_1_INITFIRST)
1389 GL(dl_initfirst) = l;
1390
1391 /* Finally the file information. */
1392 l->l_file_id = id;
1393
1394 /* When we profile the SONAME might be needed for something else but
1395 loading. Add it right away. */
1396 if (__glibc_unlikely (GLRO(dl_profile) != NULL)
1397 && l->l_info[DT_SONAME] != NULL)
1398 add_name_to_object (l, ((const char *) D_PTR (l, l_info[DT_STRTAB])
1399 + l->l_info[DT_SONAME]->d_un.d_val));
1400
1401#ifdef DL_AFTER_LOAD
1402 DL_AFTER_LOAD (l);
1403#endif
1404
1405 /* Now that the object is fully initialized add it to the object list. */
1406 _dl_add_to_namespace_list (l, nsid);
1407
1408#ifdef SHARED
1409 /* Auditing checkpoint: we have a new object. */
1410 if (__glibc_unlikely (GLRO(dl_naudit) > 0)
1411 && !GL(dl_ns)[l->l_ns]._ns_loaded->l_auditing)
1412 {
1413 struct audit_ifaces *afct = GLRO(dl_audit);
1414 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1415 {
1416 if (afct->objopen != NULL)
1417 {
1418 l->l_audit[cnt].bindflags
1419 = afct->objopen (l, nsid, &l->l_audit[cnt].cookie);
1420
1421 l->l_audit_any_plt |= l->l_audit[cnt].bindflags != 0;
1422 }
1423
1424 afct = afct->next;
1425 }
1426 }
1427#endif
1428
1429 return l;
1430}
1431
1432/* Print search path. */
1433static void
1434print_search_path (struct r_search_path_elem **list,
1435 const char *what, const char *name)
1436{
1437 char buf[max_dirnamelen + max_capstrlen];
1438 int first = 1;
1439
1440 _dl_debug_printf (" search path=");
1441
1442 while (*list != NULL && (*list)->what == what) /* Yes, ==. */
1443 {
1444 char *endp = __mempcpy (buf, (*list)->dirname, (*list)->dirnamelen);
1445 size_t cnt;
1446
1447 for (cnt = 0; cnt < ncapstr; ++cnt)
1448 if ((*list)->status[cnt] != nonexisting)
1449 {
1450 char *cp = __mempcpy (endp, capstr[cnt].str, capstr[cnt].len);
1451 if (cp == buf || (cp == buf + 1 && buf[0] == '/'))
1452 cp[0] = '\0';
1453 else
1454 cp[-1] = '\0';
1455
1456 _dl_debug_printf_c (first ? "%s" : ":%s", buf);
1457 first = 0;
1458 }
1459
1460 ++list;
1461 }
1462
1463 if (name != NULL)
1464 _dl_debug_printf_c ("\t\t(%s from file %s)\n", what,
1465 DSO_FILENAME (name));
1466 else
1467 _dl_debug_printf_c ("\t\t(%s)\n", what);
1468}
1469
1470/* Open a file and verify it is an ELF file for this architecture. We
1471 ignore only ELF files for other architectures. Non-ELF files and
1472 ELF files with different header information cause fatal errors since
1473 this could mean there is something wrong in the installation and the
1474 user might want to know about this. */
1475static int
1476open_verify (const char *name, struct filebuf *fbp, struct link_map *loader,
1477 int whatcode, int mode, bool *found_other_class, bool free_name)
1478{
1479 /* This is the expected ELF header. */
1480#define ELF32_CLASS ELFCLASS32
1481#define ELF64_CLASS ELFCLASS64
1482#ifndef VALID_ELF_HEADER
1483# define VALID_ELF_HEADER(hdr,exp,size) (memcmp (hdr, exp, size) == 0)
1484# define VALID_ELF_OSABI(osabi) (osabi == ELFOSABI_SYSV)
1485# define VALID_ELF_ABIVERSION(osabi,ver) (ver == 0)
1486#elif defined MORE_ELF_HEADER_DATA
1487 MORE_ELF_HEADER_DATA;
1488#endif
1489 static const unsigned char expected[EI_NIDENT] =
1490 {
1491 [EI_MAG0] = ELFMAG0,
1492 [EI_MAG1] = ELFMAG1,
1493 [EI_MAG2] = ELFMAG2,
1494 [EI_MAG3] = ELFMAG3,
1495 [EI_CLASS] = ELFW(CLASS),
1496 [EI_DATA] = byteorder,
1497 [EI_VERSION] = EV_CURRENT,
1498 [EI_OSABI] = ELFOSABI_SYSV,
1499 [EI_ABIVERSION] = 0
1500 };
1501 static const struct
1502 {
1503 ElfW(Word) vendorlen;
1504 ElfW(Word) datalen;
1505 ElfW(Word) type;
1506 char vendor[4];
1507 } expected_note = { 4, 16, 1, "GNU" };
1508 /* Initialize it to make the compiler happy. */
1509 const char *errstring = NULL;
1510 int errval = 0;
1511
1512#ifdef SHARED
1513 /* Give the auditing libraries a chance. */
1514 if (__glibc_unlikely (GLRO(dl_naudit) > 0) && whatcode != 0
1515 && loader->l_auditing == 0)
1516 {
1517 struct audit_ifaces *afct = GLRO(dl_audit);
1518 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1519 {
1520 if (afct->objsearch != NULL)
1521 {
1522 name = afct->objsearch (name, &loader->l_audit[cnt].cookie,
1523 whatcode);
1524 if (name == NULL)
1525 /* Ignore the path. */
1526 return -1;
1527 }
1528
1529 afct = afct->next;
1530 }
1531 }
1532#endif
1533
1534 /* Open the file. We always open files read-only. */
1535 int fd = __open (name, O_RDONLY | O_CLOEXEC);
1536 if (fd != -1)
1537 {
1538 ElfW(Ehdr) *ehdr;
1539 ElfW(Phdr) *phdr, *ph;
1540 ElfW(Word) *abi_note;
1541 unsigned int osversion;
1542 size_t maplength;
1543
1544 /* We successfully opened the file. Now verify it is a file
1545 we can use. */
1546 __set_errno (0);
1547 fbp->len = 0;
1548 assert (sizeof (fbp->buf) > sizeof (ElfW(Ehdr)));
1549 /* Read in the header. */
1550 do
1551 {
1552 ssize_t retlen = __libc_read (fd, fbp->buf + fbp->len,
1553 sizeof (fbp->buf) - fbp->len);
1554 if (retlen <= 0)
1555 break;
1556 fbp->len += retlen;
1557 }
1558 while (__glibc_unlikely (fbp->len < sizeof (ElfW(Ehdr))));
1559
1560 /* This is where the ELF header is loaded. */
1561 ehdr = (ElfW(Ehdr) *) fbp->buf;
1562
1563 /* Now run the tests. */
1564 if (__glibc_unlikely (fbp->len < (ssize_t) sizeof (ElfW(Ehdr))))
1565 {
1566 errval = errno;
1567 errstring = (errval == 0
1568 ? N_("file too short") : N_("cannot read file data"));
1569 call_lose:
1570 if (free_name)
1571 {
1572 char *realname = (char *) name;
1573 name = strdupa (realname);
1574 free (realname);
1575 }
1576 lose (errval, fd, name, NULL, NULL, errstring, NULL, 0);
1577 }
1578
1579 /* See whether the ELF header is what we expect. */
1580 if (__glibc_unlikely (! VALID_ELF_HEADER (ehdr->e_ident, expected,
1581 EI_ABIVERSION)
1582 || !VALID_ELF_ABIVERSION (ehdr->e_ident[EI_OSABI],
1583 ehdr->e_ident[EI_ABIVERSION])
1584 || memcmp (&ehdr->e_ident[EI_PAD],
1585 &expected[EI_PAD],
1586 EI_NIDENT - EI_PAD) != 0))
1587 {
1588 /* Something is wrong. */
1589 const Elf32_Word *magp = (const void *) ehdr->e_ident;
1590 if (*magp !=
1591#if BYTE_ORDER == LITTLE_ENDIAN
1592 ((ELFMAG0 << (EI_MAG0 * 8)) |
1593 (ELFMAG1 << (EI_MAG1 * 8)) |
1594 (ELFMAG2 << (EI_MAG2 * 8)) |
1595 (ELFMAG3 << (EI_MAG3 * 8)))
1596#else
1597 ((ELFMAG0 << (EI_MAG3 * 8)) |
1598 (ELFMAG1 << (EI_MAG2 * 8)) |
1599 (ELFMAG2 << (EI_MAG1 * 8)) |
1600 (ELFMAG3 << (EI_MAG0 * 8)))
1601#endif
1602 )
1603 errstring = N_("invalid ELF header");
1604 else if (ehdr->e_ident[EI_CLASS] != ELFW(CLASS))
1605 {
1606 /* This is not a fatal error. On architectures where
1607 32-bit and 64-bit binaries can be run this might
1608 happen. */
1609 *found_other_class = true;
1610 goto close_and_out;
1611 }
1612 else if (ehdr->e_ident[EI_DATA] != byteorder)
1613 {
1614 if (BYTE_ORDER == BIG_ENDIAN)
1615 errstring = N_("ELF file data encoding not big-endian");
1616 else
1617 errstring = N_("ELF file data encoding not little-endian");
1618 }
1619 else if (ehdr->e_ident[EI_VERSION] != EV_CURRENT)
1620 errstring
1621 = N_("ELF file version ident does not match current one");
1622 /* XXX We should be able so set system specific versions which are
1623 allowed here. */
1624 else if (!VALID_ELF_OSABI (ehdr->e_ident[EI_OSABI]))
1625 errstring = N_("ELF file OS ABI invalid");
1626 else if (!VALID_ELF_ABIVERSION (ehdr->e_ident[EI_OSABI],
1627 ehdr->e_ident[EI_ABIVERSION]))
1628 errstring = N_("ELF file ABI version invalid");
1629 else if (memcmp (&ehdr->e_ident[EI_PAD], &expected[EI_PAD],
1630 EI_NIDENT - EI_PAD) != 0)
1631 errstring = N_("nonzero padding in e_ident");
1632 else
1633 /* Otherwise we don't know what went wrong. */
1634 errstring = N_("internal error");
1635
1636 goto call_lose;
1637 }
1638
1639 if (__glibc_unlikely (ehdr->e_version != EV_CURRENT))
1640 {
1641 errstring = N_("ELF file version does not match current one");
1642 goto call_lose;
1643 }
1644 if (! __glibc_likely (elf_machine_matches_host (ehdr)))
1645 goto close_and_out;
1646 else if (__glibc_unlikely (ehdr->e_type != ET_DYN
1647 && ehdr->e_type != ET_EXEC))
1648 {
1649 errstring = N_("only ET_DYN and ET_EXEC can be loaded");
1650 goto call_lose;
1651 }
1652 else if (__glibc_unlikely (ehdr->e_type == ET_EXEC
1653 && (mode & __RTLD_OPENEXEC) == 0))
1654 {
1655 /* BZ #16634. It is an error to dlopen ET_EXEC (unless
1656 __RTLD_OPENEXEC is explicitly set). We return error here
1657 so that code in _dl_map_object_from_fd does not try to set
1658 l_tls_modid for this module. */
1659
1660 errstring = N_("cannot dynamically load executable");
1661 goto call_lose;
1662 }
1663 else if (__glibc_unlikely (ehdr->e_phentsize != sizeof (ElfW(Phdr))))
1664 {
1665 errstring = N_("ELF file's phentsize not the expected size");
1666 goto call_lose;
1667 }
1668
1669 maplength = ehdr->e_phnum * sizeof (ElfW(Phdr));
1670 if (ehdr->e_phoff + maplength <= (size_t) fbp->len)
1671 phdr = (void *) (fbp->buf + ehdr->e_phoff);
1672 else
1673 {
1674 phdr = alloca (maplength);
1675 __lseek (fd, ehdr->e_phoff, SEEK_SET);
1676 if ((size_t) __libc_read (fd, (void *) phdr, maplength) != maplength)
1677 {
1678 read_error:
1679 errval = errno;
1680 errstring = N_("cannot read file data");
1681 goto call_lose;
1682 }
1683 }
1684
1685 if (__glibc_unlikely (elf_machine_reject_phdr_p
1686 (phdr, ehdr->e_phnum, fbp->buf, fbp->len,
1687 loader, fd)))
1688 goto close_and_out;
1689
1690 /* Check .note.ABI-tag if present. */
1691 for (ph = phdr; ph < &phdr[ehdr->e_phnum]; ++ph)
1692 if (ph->p_type == PT_NOTE && ph->p_filesz >= 32 && ph->p_align >= 4)
1693 {
1694 ElfW(Addr) size = ph->p_filesz;
1695
1696 if (ph->p_offset + size <= (size_t) fbp->len)
1697 abi_note = (void *) (fbp->buf + ph->p_offset);
1698 else
1699 {
1700 abi_note = alloca (size);
1701 __lseek (fd, ph->p_offset, SEEK_SET);
1702 if (__libc_read (fd, (void *) abi_note, size) != size)
1703 goto read_error;
1704 }
1705
1706 while (memcmp (abi_note, &expected_note, sizeof (expected_note)))
1707 {
1708#define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
1709 ElfW(Addr) note_size = 3 * sizeof (ElfW(Word))
1710 + ROUND (abi_note[0])
1711 + ROUND (abi_note[1]);
1712
1713 if (size - 32 < note_size)
1714 {
1715 size = 0;
1716 break;
1717 }
1718 size -= note_size;
1719 abi_note = (void *) abi_note + note_size;
1720 }
1721
1722 if (size == 0)
1723 continue;
1724
1725 osversion = (abi_note[5] & 0xff) * 65536
1726 + (abi_note[6] & 0xff) * 256
1727 + (abi_note[7] & 0xff);
1728 if (abi_note[4] != __ABI_TAG_OS
1729 || (GLRO(dl_osversion) && GLRO(dl_osversion) < osversion))
1730 {
1731 close_and_out:
1732 __close (fd);
1733 __set_errno (ENOENT);
1734 fd = -1;
1735 }
1736
1737 break;
1738 }
1739 }
1740
1741 return fd;
1742}
1743
1744/* Try to open NAME in one of the directories in *DIRSP.
1745 Return the fd, or -1. If successful, fill in *REALNAME
1746 with the malloc'd full directory name. If it turns out
1747 that none of the directories in *DIRSP exists, *DIRSP is
1748 replaced with (void *) -1, and the old value is free()d
1749 if MAY_FREE_DIRS is true. */
1750
1751static int
1752open_path (const char *name, size_t namelen, int mode,
1753 struct r_search_path_struct *sps, char **realname,
1754 struct filebuf *fbp, struct link_map *loader, int whatcode,
1755 bool *found_other_class)
1756{
1757 struct r_search_path_elem **dirs = sps->dirs;
1758 char *buf;
1759 int fd = -1;
1760 const char *current_what = NULL;
1761 int any = 0;
1762
1763 if (__glibc_unlikely (dirs == NULL))
1764 /* We're called before _dl_init_paths when loading the main executable
1765 given on the command line when rtld is run directly. */
1766 return -1;
1767
1768 buf = alloca (max_dirnamelen + max_capstrlen + namelen);
1769 do
1770 {
1771 struct r_search_path_elem *this_dir = *dirs;
1772 size_t buflen = 0;
1773 size_t cnt;
1774 char *edp;
1775 int here_any = 0;
1776 int err;
1777
1778 /* If we are debugging the search for libraries print the path
1779 now if it hasn't happened now. */
1780 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS)
1781 && current_what != this_dir->what)
1782 {
1783 current_what = this_dir->what;
1784 print_search_path (dirs, current_what, this_dir->where);
1785 }
1786
1787 edp = (char *) __mempcpy (buf, this_dir->dirname, this_dir->dirnamelen);
1788 for (cnt = 0; fd == -1 && cnt < ncapstr; ++cnt)
1789 {
1790 /* Skip this directory if we know it does not exist. */
1791 if (this_dir->status[cnt] == nonexisting)
1792 continue;
1793
1794 buflen =
1795 ((char *) __mempcpy (__mempcpy (edp, capstr[cnt].str,
1796 capstr[cnt].len),
1797 name, namelen)
1798 - buf);
1799
1800 /* Print name we try if this is wanted. */
1801 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
1802 _dl_debug_printf (" trying file=%s\n", buf);
1803
1804 fd = open_verify (buf, fbp, loader, whatcode, mode,
1805 found_other_class, false);
1806 if (this_dir->status[cnt] == unknown)
1807 {
1808 if (fd != -1)
1809 this_dir->status[cnt] = existing;
1810 /* Do not update the directory information when loading
1811 auditing code. We must try to disturb the program as
1812 little as possible. */
1813 else if (loader == NULL
1814 || GL(dl_ns)[loader->l_ns]._ns_loaded->l_auditing == 0)
1815 {
1816 /* We failed to open machine dependent library. Let's
1817 test whether there is any directory at all. */
1818 struct stat64 st;
1819
1820 buf[buflen - namelen - 1] = '\0';
1821
1822 if (__xstat64 (_STAT_VER, buf, &st) != 0
1823 || ! S_ISDIR (st.st_mode))
1824 /* The directory does not exist or it is no directory. */
1825 this_dir->status[cnt] = nonexisting;
1826 else
1827 this_dir->status[cnt] = existing;
1828 }
1829 }
1830
1831 /* Remember whether we found any existing directory. */
1832 here_any |= this_dir->status[cnt] != nonexisting;
1833
1834 if (fd != -1 && __glibc_unlikely (mode & __RTLD_SECURE)
1835 && __libc_enable_secure)
1836 {
1837 /* This is an extra security effort to make sure nobody can
1838 preload broken shared objects which are in the trusted
1839 directories and so exploit the bugs. */
1840 struct stat64 st;
1841
1842 if (__fxstat64 (_STAT_VER, fd, &st) != 0
1843 || (st.st_mode & S_ISUID) == 0)
1844 {
1845 /* The shared object cannot be tested for being SUID
1846 or this bit is not set. In this case we must not
1847 use this object. */
1848 __close (fd);
1849 fd = -1;
1850 /* We simply ignore the file, signal this by setting
1851 the error value which would have been set by `open'. */
1852 errno = ENOENT;
1853 }
1854 }
1855 }
1856
1857 if (fd != -1)
1858 {
1859 *realname = (char *) malloc (buflen);
1860 if (*realname != NULL)
1861 {
1862 memcpy (*realname, buf, buflen);
1863 return fd;
1864 }
1865 else
1866 {
1867 /* No memory for the name, we certainly won't be able
1868 to load and link it. */
1869 __close (fd);
1870 return -1;
1871 }
1872 }
1873 if (here_any && (err = errno) != ENOENT && err != EACCES)
1874 /* The file exists and is readable, but something went wrong. */
1875 return -1;
1876
1877 /* Remember whether we found anything. */
1878 any |= here_any;
1879 }
1880 while (*++dirs != NULL);
1881
1882 /* Remove the whole path if none of the directories exists. */
1883 if (__glibc_unlikely (! any))
1884 {
1885 /* Paths which were allocated using the minimal malloc() in ld.so
1886 must not be freed using the general free() in libc. */
1887 if (sps->malloced)
1888 free (sps->dirs);
1889
1890 /* rtld_search_dirs and env_path_list are attribute_relro, therefore
1891 avoid writing into it. */
1892 if (sps != &rtld_search_dirs && sps != &env_path_list)
1893 sps->dirs = (void *) -1;
1894 }
1895
1896 return -1;
1897}
1898
1899/* Map in the shared object file NAME. */
1900
1901struct link_map *
1902internal_function
1903_dl_map_object (struct link_map *loader, const char *name,
1904 int type, int trace_mode, int mode, Lmid_t nsid)
1905{
1906 int fd;
1907 char *realname;
1908 char *name_copy;
1909 struct link_map *l;
1910 struct filebuf fb;
1911
1912 assert (nsid >= 0);
1913 assert (nsid < GL(dl_nns));
1914
1915 /* Look for this name among those already loaded. */
1916 for (l = GL(dl_ns)[nsid]._ns_loaded; l; l = l->l_next)
1917 {
1918 /* If the requested name matches the soname of a loaded object,
1919 use that object. Elide this check for names that have not
1920 yet been opened. */
1921 if (__glibc_unlikely ((l->l_faked | l->l_removed) != 0))
1922 continue;
1923 if (!_dl_name_match_p (name, l))
1924 {
1925 const char *soname;
1926
1927 if (__glibc_likely (l->l_soname_added)
1928 || l->l_info[DT_SONAME] == NULL)
1929 continue;
1930
1931 soname = ((const char *) D_PTR (l, l_info[DT_STRTAB])
1932 + l->l_info[DT_SONAME]->d_un.d_val);
1933 if (strcmp (name, soname) != 0)
1934 continue;
1935
1936 /* We have a match on a new name -- cache it. */
1937 add_name_to_object (l, soname);
1938 l->l_soname_added = 1;
1939 }
1940
1941 /* We have a match. */
1942 return l;
1943 }
1944
1945 /* Display information if we are debugging. */
1946 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES)
1947 && loader != NULL)
1948 _dl_debug_printf ((mode & __RTLD_CALLMAP) == 0
1949 ? "\nfile=%s [%lu]; needed by %s [%lu]\n"
1950 : "\nfile=%s [%lu]; dynamically loaded by %s [%lu]\n",
1951 name, nsid, DSO_FILENAME (loader->l_name), loader->l_ns);
1952
1953#ifdef SHARED
1954 /* Give the auditing libraries a chance to change the name before we
1955 try anything. */
1956 if (__glibc_unlikely (GLRO(dl_naudit) > 0)
1957 && (loader == NULL || loader->l_auditing == 0))
1958 {
1959 struct audit_ifaces *afct = GLRO(dl_audit);
1960 for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
1961 {
1962 if (afct->objsearch != NULL)
1963 {
1964 name = afct->objsearch (name, &loader->l_audit[cnt].cookie,
1965 LA_SER_ORIG);
1966 if (name == NULL)
1967 {
1968 /* Do not try anything further. */
1969 fd = -1;
1970 goto no_file;
1971 }
1972 }
1973
1974 afct = afct->next;
1975 }
1976 }
1977#endif
1978
1979 /* Will be true if we found a DSO which is of the other ELF class. */
1980 bool found_other_class = false;
1981
1982 if (strchr (name, '/') == NULL)
1983 {
1984 /* Search for NAME in several places. */
1985
1986 size_t namelen = strlen (name) + 1;
1987
1988 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
1989 _dl_debug_printf ("find library=%s [%lu]; searching\n", name, nsid);
1990
1991 fd = -1;
1992
1993 /* When the object has the RUNPATH information we don't use any
1994 RPATHs. */
1995 if (loader == NULL || loader->l_info[DT_RUNPATH] == NULL)
1996 {
1997 /* This is the executable's map (if there is one). Make sure that
1998 we do not look at it twice. */
1999 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
2000 bool did_main_map = false;
2001
2002 /* First try the DT_RPATH of the dependent object that caused NAME
2003 to be loaded. Then that object's dependent, and on up. */
2004 for (l = loader; l; l = l->l_loader)
2005 if (cache_rpath (l, &l->l_rpath_dirs, DT_RPATH, "RPATH"))
2006 {
2007 fd = open_path (name, namelen, mode,
2008 &l->l_rpath_dirs,
2009 &realname, &fb, loader, LA_SER_RUNPATH,
2010 &found_other_class);
2011 if (fd != -1)
2012 break;
2013
2014 did_main_map |= l == main_map;
2015 }
2016
2017 /* If dynamically linked, try the DT_RPATH of the executable
2018 itself. NB: we do this for lookups in any namespace. */
2019 if (fd == -1 && !did_main_map
2020 && main_map != NULL && main_map->l_type != lt_loaded
2021 && cache_rpath (main_map, &main_map->l_rpath_dirs, DT_RPATH,
2022 "RPATH"))
2023 fd = open_path (name, namelen, mode,
2024 &main_map->l_rpath_dirs,
2025 &realname, &fb, loader ?: main_map, LA_SER_RUNPATH,
2026 &found_other_class);
2027 }
2028
2029 /* Try the LD_LIBRARY_PATH environment variable. */
2030 if (fd == -1 && env_path_list.dirs != (void *) -1)
2031 fd = open_path (name, namelen, mode, &env_path_list,
2032 &realname, &fb,
2033 loader ?: GL(dl_ns)[LM_ID_BASE]._ns_loaded,
2034 LA_SER_LIBPATH, &found_other_class);
2035
2036 /* Look at the RUNPATH information for this binary. */
2037 if (fd == -1 && loader != NULL
2038 && cache_rpath (loader, &loader->l_runpath_dirs,
2039 DT_RUNPATH, "RUNPATH"))
2040 fd = open_path (name, namelen, mode,
2041 &loader->l_runpath_dirs, &realname, &fb, loader,
2042 LA_SER_RUNPATH, &found_other_class);
2043
2044#ifdef USE_LDCONFIG
2045 if (fd == -1
2046 && (__glibc_likely ((mode & __RTLD_SECURE) == 0)
2047 || ! __libc_enable_secure)
2048 && __glibc_likely (GLRO(dl_inhibit_cache) == 0))
2049 {
2050 /* Check the list of libraries in the file /etc/ld.so.cache,
2051 for compatibility with Linux's ldconfig program. */
2052 char *cached = _dl_load_cache_lookup (name);
2053
2054 if (cached != NULL)
2055 {
2056 // XXX Correct to unconditionally default to namespace 0?
2057 l = (loader
2058 ?: GL(dl_ns)[LM_ID_BASE]._ns_loaded
2059# ifdef SHARED
2060 ?: &GL(dl_rtld_map)
2061# endif
2062 );
2063
2064 /* If the loader has the DF_1_NODEFLIB flag set we must not
2065 use a cache entry from any of these directories. */
2066 if (__glibc_unlikely (l->l_flags_1 & DF_1_NODEFLIB))
2067 {
2068 const char *dirp = system_dirs;
2069 unsigned int cnt = 0;
2070
2071 do
2072 {
2073 if (memcmp (cached, dirp, system_dirs_len[cnt]) == 0)
2074 {
2075 /* The prefix matches. Don't use the entry. */
2076 free (cached);
2077 cached = NULL;
2078 break;
2079 }
2080
2081 dirp += system_dirs_len[cnt] + 1;
2082 ++cnt;
2083 }
2084 while (cnt < nsystem_dirs_len);
2085 }
2086
2087 if (cached != NULL)
2088 {
2089 fd = open_verify (cached,
2090 &fb, loader ?: GL(dl_ns)[nsid]._ns_loaded,
2091 LA_SER_CONFIG, mode, &found_other_class,
2092 false);
2093 if (__glibc_likely (fd != -1))
2094 realname = cached;
2095 else
2096 free (cached);
2097 }
2098 }
2099 }
2100#endif
2101
2102 /* Finally, try the default path. */
2103 if (fd == -1
2104 && ((l = loader ?: GL(dl_ns)[nsid]._ns_loaded) == NULL
2105 || __glibc_likely (!(l->l_flags_1 & DF_1_NODEFLIB)))
2106 && rtld_search_dirs.dirs != (void *) -1)
2107 fd = open_path (name, namelen, mode, &rtld_search_dirs,
2108 &realname, &fb, l, LA_SER_DEFAULT, &found_other_class);
2109
2110 /* Add another newline when we are tracing the library loading. */
2111 if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
2112 _dl_debug_printf ("\n");
2113 }
2114 else
2115 {
2116 /* The path may contain dynamic string tokens. */
2117 realname = (loader
2118 ? expand_dynamic_string_token (loader, name, 0)
2119 : __strdup (name));
2120 if (realname == NULL)
2121 fd = -1;
2122 else
2123 {
2124 fd = open_verify (realname, &fb,
2125 loader ?: GL(dl_ns)[nsid]._ns_loaded, 0, mode,
2126 &found_other_class, true);
2127 if (__glibc_unlikely (fd == -1))
2128 free (realname);
2129 }
2130 }
2131
2132#ifdef SHARED
2133 no_file:
2134#endif
2135 /* In case the LOADER information has only been provided to get to
2136 the appropriate RUNPATH/RPATH information we do not need it
2137 anymore. */
2138 if (mode & __RTLD_CALLMAP)
2139 loader = NULL;
2140
2141 if (__glibc_unlikely (fd == -1))
2142 {
2143 if (trace_mode
2144 && __glibc_likely ((GLRO(dl_debug_mask) & DL_DEBUG_PRELINK) == 0))
2145 {
2146 /* We haven't found an appropriate library. But since we
2147 are only interested in the list of libraries this isn't
2148 so severe. Fake an entry with all the information we
2149 have. */
2150 static const Elf_Symndx dummy_bucket = STN_UNDEF;
2151
2152 /* Allocate a new object map. */
2153 if ((name_copy = __strdup (name)) == NULL
2154 || (l = _dl_new_object (name_copy, name, type, loader,
2155 mode, nsid)) == NULL)
2156 {
2157 free (name_copy);
2158 _dl_signal_error (ENOMEM, name, NULL,
2159 N_("cannot create shared object descriptor"));
2160 }
2161 /* Signal that this is a faked entry. */
2162 l->l_faked = 1;
2163 /* Since the descriptor is initialized with zero we do not
2164 have do this here.
2165 l->l_reserved = 0; */
2166 l->l_buckets = &dummy_bucket;
2167 l->l_nbuckets = 1;
2168 l->l_relocated = 1;
2169
2170 /* Enter the object in the object list. */
2171 _dl_add_to_namespace_list (l, nsid);
2172
2173 return l;
2174 }
2175 else if (found_other_class)
2176 _dl_signal_error (0, name, NULL,
2177 ELFW(CLASS) == ELFCLASS32
2178 ? N_("wrong ELF class: ELFCLASS64")
2179 : N_("wrong ELF class: ELFCLASS32"));
2180 else
2181 _dl_signal_error (errno, name, NULL,
2182 N_("cannot open shared object file"));
2183 }
2184
2185 void *stack_end = __libc_stack_end;
2186 return _dl_map_object_from_fd (name, fd, &fb, realname, loader, type, mode,
2187 &stack_end, nsid);
2188}
2189
2190struct add_path_state
2191{
2192 bool counting;
2193 unsigned int idx;
2194 Dl_serinfo *si;
2195 char *allocptr;
2196};
2197
2198static void
2199add_path (struct add_path_state *p, const struct r_search_path_struct *sps,
2200 unsigned int flags)
2201{
2202 if (sps->dirs != (void *) -1)
2203 {
2204 struct r_search_path_elem **dirs = sps->dirs;
2205 do
2206 {
2207 const struct r_search_path_elem *const r = *dirs++;
2208 if (p->counting)
2209 {
2210 p->si->dls_cnt++;
2211 p->si->dls_size += MAX (2, r->dirnamelen);
2212 }
2213 else
2214 {
2215 Dl_serpath *const sp = &p->si->dls_serpath[p->idx++];
2216 sp->dls_name = p->allocptr;
2217 if (r->dirnamelen < 2)
2218 *p->allocptr++ = r->dirnamelen ? '/' : '.';
2219 else
2220 p->allocptr = __mempcpy (p->allocptr,
2221 r->dirname, r->dirnamelen - 1);
2222 *p->allocptr++ = '\0';
2223 sp->dls_flags = flags;
2224 }
2225 }
2226 while (*dirs != NULL);
2227 }
2228}
2229
2230void
2231internal_function
2232_dl_rtld_di_serinfo (struct link_map *loader, Dl_serinfo *si, bool counting)
2233{
2234 if (counting)
2235 {
2236 si->dls_cnt = 0;
2237 si->dls_size = 0;
2238 }
2239
2240 struct add_path_state p =
2241 {
2242 .counting = counting,
2243 .idx = 0,
2244 .si = si,
2245 .allocptr = (char *) &si->dls_serpath[si->dls_cnt]
2246 };
2247
2248# define add_path(p, sps, flags) add_path(p, sps, 0) /* XXX */
2249
2250 /* When the object has the RUNPATH information we don't use any RPATHs. */
2251 if (loader->l_info[DT_RUNPATH] == NULL)
2252 {
2253 /* First try the DT_RPATH of the dependent object that caused NAME
2254 to be loaded. Then that object's dependent, and on up. */
2255
2256 struct link_map *l = loader;
2257 do
2258 {
2259 if (cache_rpath (l, &l->l_rpath_dirs, DT_RPATH, "RPATH"))
2260 add_path (&p, &l->l_rpath_dirs, XXX_RPATH);
2261 l = l->l_loader;
2262 }
2263 while (l != NULL);
2264
2265 /* If dynamically linked, try the DT_RPATH of the executable itself. */
2266 if (loader->l_ns == LM_ID_BASE)
2267 {
2268 l = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
2269 if (l != NULL && l->l_type != lt_loaded && l != loader)
2270 if (cache_rpath (l, &l->l_rpath_dirs, DT_RPATH, "RPATH"))
2271 add_path (&p, &l->l_rpath_dirs, XXX_RPATH);
2272 }
2273 }
2274
2275 /* Try the LD_LIBRARY_PATH environment variable. */
2276 add_path (&p, &env_path_list, XXX_ENV);
2277
2278 /* Look at the RUNPATH information for this binary. */
2279 if (cache_rpath (loader, &loader->l_runpath_dirs, DT_RUNPATH, "RUNPATH"))
2280 add_path (&p, &loader->l_runpath_dirs, XXX_RUNPATH);
2281
2282 /* XXX
2283 Here is where ld.so.cache gets checked, but we don't have
2284 a way to indicate that in the results for Dl_serinfo. */
2285
2286 /* Finally, try the default path. */
2287 if (!(loader->l_flags_1 & DF_1_NODEFLIB))
2288 add_path (&p, &rtld_search_dirs, XXX_default);
2289
2290 if (counting)
2291 /* Count the struct size before the string area, which we didn't
2292 know before we completed dls_cnt. */
2293 si->dls_size += (char *) &si->dls_serpath[si->dls_cnt] - (char *) si;
2294}