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