b2f5ad7a1c4ccc45e89b0d1bd23856a2ab45e260
[kopensolaris-gnu/glibc.git] / elf / dl-load.c
1 /* Map in a shared object's segments from the file.
2    Copyright (C) 1995,96,97,98,99,2000 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 Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    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    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <elf.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <libintl.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <ldsodefs.h>
28 #include <sys/mman.h>
29 #include <sys/param.h>
30 #include <sys/stat.h>
31 #include <sys/types.h>
32 #include "dynamic-link.h"
33 #include <stdio-common/_itoa.h>
34
35 #include <dl-dst.h>
36
37 /* On some systems, no flag bits are given to specify file mapping.  */
38 #ifndef MAP_FILE
39 # define MAP_FILE       0
40 #endif
41
42 /* The right way to map in the shared library files is MAP_COPY, which
43    makes a virtual copy of the data at the time of the mmap call; this
44    guarantees the mapped pages will be consistent even if the file is
45    overwritten.  Some losing VM systems like Linux's lack MAP_COPY.  All we
46    get is MAP_PRIVATE, which copies each page when it is modified; this
47    means if the file is overwritten, we may at some point get some pages
48    from the new version after starting with pages from the old version.  */
49 #ifndef MAP_COPY
50 # define MAP_COPY       MAP_PRIVATE
51 #endif
52
53 /* Some systems link their relocatable objects for another base address
54    than 0.  We want to know the base address for these such that we can
55    subtract this address from the segment addresses during mapping.
56    This results in a more efficient address space usage.  Defaults to
57    zero for almost all systems.  */
58 #ifndef MAP_BASE_ADDR
59 # define MAP_BASE_ADDR(l)       0
60 #endif
61
62
63 #include <endian.h>
64 #if BYTE_ORDER == BIG_ENDIAN
65 # define byteorder ELFDATA2MSB
66 #elif BYTE_ORDER == LITTLE_ENDIAN
67 # define byteorder ELFDATA2LSB
68 #else
69 # error "Unknown BYTE_ORDER " BYTE_ORDER
70 # define byteorder ELFDATANONE
71 #endif
72
73 #define STRING(x) __STRING (x)
74
75 #ifdef MAP_ANON
76 /* The fd is not examined when using MAP_ANON.  */
77 # define ANONFD -1
78 #else
79 int _dl_zerofd = -1;
80 # define ANONFD _dl_zerofd
81 #endif
82
83 /* Handle situations where we have a preferred location in memory for
84    the shared objects.  */
85 #ifdef ELF_PREFERRED_ADDRESS_DATA
86 ELF_PREFERRED_ADDRESS_DATA;
87 #endif
88 #ifndef ELF_PREFERRED_ADDRESS
89 # define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
90 #endif
91 #ifndef ELF_FIXED_ADDRESS
92 # define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)
93 #endif
94
95 size_t _dl_pagesize;
96
97 extern const char *_dl_platform;
98 extern size_t _dl_platformlen;
99
100 /* This is the decomposed LD_LIBRARY_PATH search path.  */
101 static struct r_search_path_struct env_path_list;
102
103 /* List of the hardware capabilities we might end up using.  */
104 static const struct r_strlenpair *capstr;
105 static size_t ncapstr;
106 static size_t max_capstrlen;
107
108 const unsigned char _dl_pf_to_prot[8] =
109 {
110   [0] = PROT_NONE,
111   [PF_R] = PROT_READ,
112   [PF_W] = PROT_WRITE,
113   [PF_R | PF_W] = PROT_READ | PROT_WRITE,
114   [PF_X] = PROT_EXEC,
115   [PF_R | PF_X] = PROT_READ | PROT_EXEC,
116   [PF_W | PF_X] = PROT_WRITE | PROT_EXEC,
117   [PF_R | PF_W | PF_X] = PROT_READ | PROT_WRITE | PROT_EXEC
118 };
119
120
121 /* Get the generated information about the trusted directories.  */
122 #include "trusted-dirs.h"
123
124 static const char system_dirs[] = SYSTEM_DIRS;
125 static const size_t system_dirs_len[] =
126 {
127   SYSTEM_DIRS_LEN
128 };
129 #define nsystem_dirs_len \
130   (sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))
131
132
133 /* Local version of `strdup' function.  */
134 static inline char *
135 local_strdup (const char *s)
136 {
137   size_t len = strlen (s) + 1;
138   void *new = malloc (len);
139
140   if (new == NULL)
141     return NULL;
142
143   return (char *) memcpy (new, s, len);
144 }
145
146
147 size_t
148 _dl_dst_count (const char *name, int is_path)
149 {
150   const char *const start = name;
151   size_t cnt = 0;
152
153   do
154     {
155       size_t len = 1;
156
157       /* $ORIGIN is not expanded for SUID/GUID programs.
158
159          Note that it is no bug that the strings in the first two `strncmp'
160          calls are longer than the sequence which is actually tested.  */
161       if ((((strncmp (&name[1], "ORIGIN}", 6) == 0
162              && (!__libc_enable_secure
163                  || ((name[7] == '\0' || (is_path && name[7] == ':'))
164                      && (name == start || (is_path && name[-1] == ':'))))
165              && (len = 7) != 0)
166             || (strncmp (&name[1], "PLATFORM}", 8) == 0 && (len = 9) != 0))
167            && (name[len] == '\0' || name[len] == '/'
168                || (is_path && name[len] == ':')))
169           || (name[1] == '{'
170               && ((strncmp (&name[2], "ORIGIN}", 7) == 0
171                    && (!__libc_enable_secure
172                        || ((name[9] == '\0' || (is_path && name[9] == ':'))
173                            && (name == start || (is_path && name[-1] == ':'))))
174                    && (len = 9) != 0)
175                   || (strncmp (&name[2], "PLATFORM}", 9) == 0
176                       && (len = 11) != 0))))
177         ++cnt;
178
179       name = strchr (name + len, '$');
180     }
181   while (name != NULL);
182
183   return cnt;
184 }
185
186
187 char *
188 _dl_dst_substitute (struct link_map *l, const char *name, char *result,
189                     int is_path)
190 {
191   const char *const start = name;
192   char *last_elem, *wp;
193
194   /* Now fill the result path.  While copying over the string we keep
195      track of the start of the last path element.  When we come accross
196      a DST we copy over the value or (if the value is not available)
197      leave the entire path element out.  */
198   last_elem = wp = result;
199
200   do
201     {
202       if (*name == '$')
203         {
204           const char *repl;
205           size_t len;
206
207           /* Note that it is no bug that the strings in the first two `strncmp'
208              calls are longer than the sequence which is actually tested.  */
209           if ((((strncmp (&name[1], "ORIGIN}", 6) == 0 && (len = 7) != 0)
210                 || (strncmp (&name[1], "PLATFORM}", 8) == 0 && (len = 9) != 0))
211                && (name[len] == '\0' || name[len] == '/'
212                    || (is_path && name[len] == ':')))
213               || (name[1] == '{'
214                   && ((strncmp (&name[2], "ORIGIN}", 7) == 0 && (len = 9) != 0)
215                       || (strncmp (&name[2], "PLATFORM}", 9) == 0
216                           && (len = 11) != 0))))
217             {
218               repl = ((len == 7 || name[2] == 'O')
219                       ? (__libc_enable_secure
220                          && ((name[len] != '\0'
221                               && (!is_path || name[len] != ':'))
222                              || (name != start
223                                  && (!is_path || name[-1] != ':')))
224                          ? NULL : l->l_origin)
225                       : _dl_platform);
226
227               if (repl != NULL && repl != (const char *) -1)
228                 {
229                   wp = __stpcpy (wp, repl);
230                   name += len;
231                 }
232               else
233                 {
234                   /* We cannot use this path element, the value of the
235                      replacement is unknown.  */
236                   wp = last_elem;
237                   name += len;
238                   while (*name != '\0' && (!is_path || *name != ':'))
239                     ++name;
240                 }
241             }
242           else
243             /* No DST we recognize.  */
244             *wp++ = *name++;
245         }
246       else if (is_path && *name == ':')
247         {
248           *wp++ = *name++;
249           last_elem = wp;
250         }
251       else
252         *wp++ = *name++;
253     }
254   while (*name != '\0');
255
256   *wp = '\0';
257
258   return result;
259 }
260
261
262 /* Return copy of argument with all recognized dynamic string tokens
263    ($ORIGIN and $PLATFORM for now) replaced.  On some platforms it
264    might not be possible to determine the path from which the object
265    belonging to the map is loaded.  In this case the path element
266    containing $ORIGIN is left out.  */
267 static char *
268 expand_dynamic_string_token (struct link_map *l, const char *s)
269 {
270   /* We make two runs over the string.  First we determine how large the
271      resulting string is and then we copy it over.  Since this is now
272      frequently executed operation we are looking here not for performance
273      but rather for code size.  */
274   size_t cnt;
275   size_t total;
276   char *result;
277
278   /* Determine the number of DST elements.  */
279   cnt = DL_DST_COUNT (s, 1);
280
281   /* If we do not have to replace anything simply copy the string.  */
282   if (cnt == 0)
283     return local_strdup (s);
284
285   /* Determine the length of the substituted string.  */
286   total = DL_DST_REQUIRED (l, s, strlen (s), cnt);
287
288   /* Allocate the necessary memory.  */
289   result = (char *) malloc (total + 1);
290   if (result == NULL)
291     return NULL;
292
293   return DL_DST_SUBSTITUTE (l, s, result, 1);
294 }
295
296
297 /* Add `name' to the list of names for a particular shared object.
298    `name' is expected to have been allocated with malloc and will
299    be freed if the shared object already has this name.
300    Returns false if the object already had this name.  */
301 static void
302 internal_function
303 add_name_to_object (struct link_map *l, const char *name)
304 {
305   struct libname_list *lnp, *lastp;
306   struct libname_list *newname;
307   size_t name_len;
308
309   lastp = NULL;
310   for (lnp = l->l_libname; lnp != NULL; lastp = lnp, lnp = lnp->next)
311     if (strcmp (name, lnp->name) == 0)
312       return;
313
314   name_len = strlen (name) + 1;
315   newname = (struct libname_list *) malloc (sizeof *newname + name_len);
316   if (newname == NULL)
317     {
318       /* No more memory.  */
319       _dl_signal_error (ENOMEM, name, N_("cannot allocate name record"));
320       return;
321     }
322   /* The object should have a libname set from _dl_new_object.  */
323   assert (lastp != NULL);
324
325   newname->name = memcpy (newname + 1, name, name_len);
326   newname->next = NULL;
327   newname->dont_free = 0;
328   lastp->next = newname;
329 }
330
331 /* All known directories in sorted order.  */
332 struct r_search_path_elem *_dl_all_dirs;
333
334 /* All directories after startup.  */
335 struct r_search_path_elem *_dl_init_all_dirs;
336
337 /* Standard search directories.  */
338 static struct r_search_path_struct rtld_search_dirs;
339
340 static size_t max_dirnamelen;
341
342 static inline struct r_search_path_elem **
343 fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
344               int check_trusted, const char *what, const char *where)
345 {
346   char *cp;
347   size_t nelems = 0;
348
349   while ((cp = __strsep (&rpath, sep)) != NULL)
350     {
351       struct r_search_path_elem *dirp;
352       size_t len = strlen (cp);
353
354       /* `strsep' can pass an empty string.  This has to be
355          interpreted as `use the current directory'. */
356       if (len == 0)
357         {
358           static const char curwd[] = "./";
359           cp = (char *) curwd;
360         }
361
362       /* Remove trailing slashes (except for "/").  */
363       while (len > 1 && cp[len - 1] == '/')
364         --len;
365
366       /* Now add one if there is none so far.  */
367       if (len > 0 && cp[len - 1] != '/')
368         cp[len++] = '/';
369
370       /* See if this directory is already known.  */
371       for (dirp = _dl_all_dirs; dirp != NULL; dirp = dirp->next)
372         if (dirp->dirnamelen == len && memcmp (cp, dirp->dirname, len) == 0)
373           break;
374
375       if (dirp != NULL)
376         {
377           /* It is available, see whether it's on our own list.  */
378           size_t cnt;
379           for (cnt = 0; cnt < nelems; ++cnt)
380             if (result[cnt] == dirp)
381               break;
382
383           if (cnt == nelems)
384             result[nelems++] = dirp;
385         }
386       else
387         {
388           size_t cnt;
389           enum r_dir_status init_val;
390           size_t where_len = where ? strlen (where) + 1 : 0;
391
392           /* It's a new directory.  Create an entry and add it.  */
393           dirp = (struct r_search_path_elem *)
394             malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status)
395                     + where_len + len + 1);
396           if (dirp == NULL)
397             _dl_signal_error (ENOMEM, NULL,
398                               N_("cannot create cache for search path"));
399
400           dirp->dirname = ((char *) dirp + sizeof (*dirp)
401                            + ncapstr * sizeof (enum r_dir_status));
402           memcpy ((char *) dirp->dirname, cp, len + 1);
403           dirp->dirnamelen = len;
404
405           if (len > max_dirnamelen)
406             max_dirnamelen = len;
407
408           /* Make sure we don't use untrusted directories if we run SUID.  */
409           if (__builtin_expect (check_trusted, 0))
410             {
411               const char *trun = system_dirs;
412               size_t idx;
413
414               /* By default we don't trust anything.  */
415               init_val = nonexisting;
416
417               /* All trusted directories must be complete names.  */
418               if (cp[0] == '/')
419                 {
420                   for (idx = 0; idx < nsystem_dirs_len; ++idx)
421                     {
422                       if (len == system_dirs_len[idx]
423                           && memcmp (trun, cp, len) == 0)
424                         /* Found it.  */
425                         break;
426
427                       trun += system_dirs_len[idx] + 1;
428                     }
429
430                   if (idx < nsystem_dirs_len)
431                     /* It's a trusted directory so allow checking for it.  */
432                     init_val = unknown;
433                 }
434             }
435           else
436             /* We don't have to check for trusted directories and can
437                accept everything.  We have to make sure all the
438                relative directories are never ignored.  The current
439                directory might change and all our saved information
440                would be void.  */
441             init_val = cp[0] != '/' ? existing : unknown;
442
443           for (cnt = 0; cnt < ncapstr; ++cnt)
444             dirp->status[cnt] = init_val;
445
446           dirp->what = what;
447           if (__builtin_expect (where != NULL, 1))
448             dirp->where = memcpy ((char *) dirp + sizeof (*dirp) + len + 1
449                                   + ncapstr * sizeof (enum r_dir_status),
450                                   where, where_len);
451           else
452             dirp->where = NULL;
453
454           dirp->next = _dl_all_dirs;
455           _dl_all_dirs = dirp;
456
457           /* Put it in the result array.  */
458           result[nelems++] = dirp;
459         }
460     }
461
462   /* Terminate the array.  */
463   result[nelems] = NULL;
464
465   return result;
466 }
467
468
469 static void
470 internal_function
471 decompose_rpath (struct r_search_path_struct *sps,
472                  const char *rpath, struct link_map *l, const char *what)
473 {
474   /* Make a copy we can work with.  */
475   const char *where = l->l_name;
476   char *copy;
477   char *cp;
478   struct r_search_path_elem **result;
479   size_t nelems;
480
481   /* First see whether we must forget the RUNPATH and RPATH from this
482      object.  */
483   if (__builtin_expect (_dl_inhibit_rpath != NULL, 0) && !__libc_enable_secure)
484     {
485       const char *found = strstr (_dl_inhibit_rpath, where);
486       if (found != NULL)
487         {
488           size_t len = strlen (where);
489           if ((found == _dl_inhibit_rpath || found[-1] == ':')
490               && (found[len] == '\0' || found[len] == ':'))
491             {
492               /* This object is on the list of objects for which the
493                  RUNPATH and RPATH must not be used.  */
494               result = (struct r_search_path_elem **)
495                 malloc (sizeof (*result));
496               if (result == NULL)
497                 _dl_signal_error (ENOMEM, NULL,
498                                   N_("cannot create cache for search path"));
499               result[0] = NULL;
500
501               sps->dirs = result;
502               sps->malloced = 1;
503
504               return;
505             }
506         }
507     }
508
509   /* Make a writable copy.  At the same time expand possible dynamic
510      string tokens.  */
511   copy = expand_dynamic_string_token (l, rpath);
512   if (copy == NULL)
513     _dl_signal_error (ENOMEM, NULL, N_("cannot create RUNPATH/RPATH copy"));
514
515   /* Count the number of necessary elements in the result array.  */
516   nelems = 0;
517   for (cp = copy; *cp != '\0'; ++cp)
518     if (*cp == ':')
519       ++nelems;
520
521   /* Allocate room for the result.  NELEMS + 1 is an upper limit for the
522      number of necessary entries.  */
523   result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
524                                                   * sizeof (*result));
525   if (result == NULL)
526     _dl_signal_error (ENOMEM, NULL, N_("cannot create cache for search path"));
527
528   fillin_rpath (copy, result, ":", 0, what, where);
529
530   /* Free the copied RPATH string.  `fillin_rpath' make own copies if
531      necessary.  */
532   free (copy);
533
534   sps->dirs = result;
535   /* The caller will change this value if we haven't used a real malloc.  */
536   sps->malloced = 1;
537 }
538
539
540 void
541 internal_function
542 _dl_init_paths (const char *llp)
543 {
544   size_t idx;
545   const char *strp;
546   struct r_search_path_elem *pelem, **aelem;
547   size_t round_size;
548 #ifdef SHARED
549   struct link_map *l;
550 #endif
551
552   /* Fill in the information about the application's RPATH and the
553      directories addressed by the LD_LIBRARY_PATH environment variable.  */
554
555   /* Get the capabilities.  */
556   capstr = _dl_important_hwcaps (_dl_platform, _dl_platformlen,
557                                  &ncapstr, &max_capstrlen);
558
559   /* First set up the rest of the default search directory entries.  */
560   aelem = rtld_search_dirs.dirs = (struct r_search_path_elem **)
561     malloc ((nsystem_dirs_len + 1) * sizeof (struct r_search_path_elem *));
562   if (rtld_search_dirs.dirs == NULL)
563     _dl_signal_error (ENOMEM, NULL, N_("cannot create search path array"));
564
565   round_size = ((2 * sizeof (struct r_search_path_elem) - 1
566                  + ncapstr * sizeof (enum r_dir_status))
567                 / sizeof (struct r_search_path_elem));
568
569   rtld_search_dirs.dirs[0] = (struct r_search_path_elem *)
570     malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
571             * round_size * sizeof (struct r_search_path_elem));
572   if (rtld_search_dirs.dirs[0] == NULL)
573     _dl_signal_error (ENOMEM, NULL, N_("cannot create cache for search path"));
574
575   rtld_search_dirs.malloced = 0;
576   pelem = _dl_all_dirs = rtld_search_dirs.dirs[0];
577   strp = system_dirs;
578   idx = 0;
579
580   do
581     {
582       size_t cnt;
583
584       *aelem++ = pelem;
585
586       pelem->what = "system search path";
587       pelem->where = NULL;
588
589       pelem->dirname = strp;
590       pelem->dirnamelen = system_dirs_len[idx];
591       strp += system_dirs_len[idx] + 1;
592
593       /* System paths must be absolute.  */
594       assert (pelem->dirname[0] == '/');
595       for (cnt = 0; cnt < ncapstr; ++cnt)
596         pelem->status[cnt] = unknown;
597
598       pelem->next = (++idx == nsystem_dirs_len ? NULL : (pelem + round_size));
599
600       pelem += round_size;
601     }
602   while (idx < nsystem_dirs_len);
603
604   max_dirnamelen = SYSTEM_DIRS_MAX_LEN;
605   *aelem = NULL;
606
607 #ifdef SHARED
608   /* This points to the map of the main object.  */
609   l = _dl_loaded;
610   if (l != NULL)
611     {
612       assert (l->l_type != lt_loaded);
613
614       if (l->l_info[DT_RUNPATH])
615         {
616           /* Allocate room for the search path and fill in information
617              from RUNPATH.  */
618           decompose_rpath (&l->l_runpath_dirs,
619                            (const void *) (D_PTR (l, l_info[DT_STRTAB])
620                                            + l->l_info[DT_RUNPATH]->d_un.d_val),
621                            l, "RUNPATH");
622
623           /* The RPATH is ignored.  */
624           l->l_rpath_dirs.dirs = (void *) -1;
625         }
626       else
627         {
628           l->l_runpath_dirs.dirs = (void *) -1;
629
630           if (l->l_info[DT_RPATH])
631             {
632               /* Allocate room for the search path and fill in information
633                  from RPATH.  */
634               decompose_rpath (&l->l_rpath_dirs,
635                                (const void *) (D_PTR (l, l_info[DT_STRTAB])
636                                                + l->l_info[DT_RPATH]->d_un.d_val),
637                                l, "RPATH");
638               l->l_rpath_dirs.malloced = 0;
639             }
640           else
641             l->l_rpath_dirs.dirs = (void *) -1;
642         }
643     }
644 #endif  /* SHARED */
645
646   if (llp != NULL && *llp != '\0')
647     {
648       size_t nllp;
649       const char *cp = llp;
650
651       /* Decompose the LD_LIBRARY_PATH contents.  First determine how many
652          elements it has.  */
653       nllp = 1;
654       while (*cp)
655         {
656           if (*cp == ':' || *cp == ';')
657             ++nllp;
658           ++cp;
659         }
660
661       env_path_list.dirs = (struct r_search_path_elem **)
662         malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
663       if (env_path_list.dirs == NULL)
664         _dl_signal_error (ENOMEM, NULL,
665                           N_("cannot create cache for search path"));
666
667       (void) fillin_rpath (strdupa (llp), env_path_list.dirs, ":;",
668                            __libc_enable_secure, "LD_LIBRARY_PATH", NULL);
669
670       if (env_path_list.dirs[0] == NULL)
671         {
672           free (env_path_list.dirs);
673           env_path_list.dirs = (void *) -1;
674         }
675
676       env_path_list.malloced = 0;
677     }
678   else
679     env_path_list.dirs = (void *) -1;
680
681   /* Remember the last search directory added at startup.  */
682   _dl_init_all_dirs = _dl_all_dirs;
683 }
684
685
686 /* Think twice before changing anything in this function.  It is placed
687    here and prepared using the `alloca' magic to prevent it from being
688    inlined.  The function is only called in case of an error.  But then
689    performance does not count.  The function used to be "inlinable" and
690    the compiled did so all the time.  This increased the code size for
691    absolutely no good reason.  */
692 #define LOSE(code, s) lose (code, fd, name, realname, l, s)
693 static void
694 __attribute__ ((noreturn))
695 lose (int code, int fd, const char *name, char *realname, struct link_map *l,
696       const char *msg)
697 {
698   /* The use of `alloca' here looks ridiculous but it helps.  The goal
699      is to avoid the function from being inlined.  There is no official
700      way to do this so we use this trick.  gcc never inlines functions
701      which use `alloca'.  */
702   int *a = alloca (sizeof (int));
703   a[0] = fd;
704   (void) __close (a[0]);
705   if (l != NULL)
706     {
707       /* Remove the stillborn object from the list and free it.  */
708       if (l->l_prev)
709         l->l_prev->l_next = l->l_next;
710       if (l->l_next)
711         l->l_next->l_prev = l->l_prev;
712       --_dl_nloaded;
713       free (l);
714     }
715   free (realname);
716   _dl_signal_error (code, name, msg);
717 }
718
719
720 /* Map in the shared object NAME, actually located in REALNAME, and already
721    opened on FD.  */
722
723 #ifndef EXTERNAL_MAP_FROM_FD
724 static
725 #endif
726 struct link_map *
727 _dl_map_object_from_fd (const char *name, int fd, char *realname,
728                         struct link_map *loader, int l_type, int mode)
729 {
730   /* This is the expected ELF header.  */
731 #define ELF32_CLASS ELFCLASS32
732 #define ELF64_CLASS ELFCLASS64
733 #ifndef VALID_ELF_HEADER
734 # define VALID_ELF_HEADER(hdr,exp,size) (memcmp (hdr, exp, size) == 0)
735 # define VALID_ELF_OSABI(osabi)         (osabi == ELFOSABI_SYSV)
736 # define VALID_ELF_ABIVERSION(ver)      (ver == 0)
737 #endif
738   static const unsigned char expected[EI_PAD] =
739   {
740     [EI_MAG0] = ELFMAG0,
741     [EI_MAG1] = ELFMAG1,
742     [EI_MAG2] = ELFMAG2,
743     [EI_MAG3] = ELFMAG3,
744     [EI_CLASS] = ELFW(CLASS),
745     [EI_DATA] = byteorder,
746     [EI_VERSION] = EV_CURRENT,
747     [EI_OSABI] = ELFOSABI_SYSV,
748     [EI_ABIVERSION] = 0
749   };
750   struct link_map *l = NULL;
751
752   inline caddr_t map_segment (ElfW(Addr) mapstart, size_t len,
753                               int prot, int fixed, off_t offset)
754     {
755       caddr_t mapat = __mmap ((caddr_t) mapstart, len, prot,
756                               fixed|MAP_COPY|MAP_FILE,
757                               fd, offset);
758       if (mapat == MAP_FAILED)
759         LOSE (errno, N_("failed to map segment from shared object"));
760       return mapat;
761     }
762
763   const ElfW(Ehdr) *header;
764   const ElfW(Phdr) *phdr;
765   const ElfW(Phdr) *ph;
766   size_t maplength;
767   int type;
768   char *readbuf;
769   ssize_t readlength;
770   struct stat64 st;
771
772   /* Get file information.  */
773   if (__fxstat64 (_STAT_VER, fd, &st) < 0)
774     LOSE (errno, N_("cannot stat shared object"));
775
776   /* Look again to see if the real name matched another already loaded.  */
777   for (l = _dl_loaded; l; l = l->l_next)
778     if (l->l_ino == st.st_ino && l->l_dev == st.st_dev)
779       {
780         /* The object is already loaded.
781            Just bump its reference count and return it.  */
782         __close (fd);
783
784         /* If the name is not in the list of names for this object add
785            it.  */
786         free (realname);
787         add_name_to_object (l, name);
788         ++l->l_opencount;
789         return l;
790       }
791
792   if (mode & RTLD_NOLOAD)
793     /* We are not supposed to load the object unless it is already
794        loaded.  So return now.  */
795     return NULL;
796
797   /* Print debugging message.  */
798   if (__builtin_expect (_dl_debug_files, 0))
799     _dl_debug_message (1, "file=", name, ";  generating link map\n", NULL);
800
801   /* Read the header directly.  */
802   readbuf = alloca (_dl_pagesize);
803   readlength = __libc_read (fd, readbuf, _dl_pagesize);
804   if (readlength < (ssize_t) sizeof (*header))
805     LOSE (errno, N_("cannot read file data"));
806   header = (void *) readbuf;
807
808   /* Check the header for basic validity.  */
809   if (__builtin_expect (!VALID_ELF_HEADER (header->e_ident, expected, EI_PAD),
810                         0))
811     {
812       /* Something is wrong.  */
813       if (*(Elf32_Word *) &header->e_ident !=
814 #if BYTE_ORDER == LITTLE_ENDIAN
815           ((ELFMAG0 << (EI_MAG0 * 8)) |
816            (ELFMAG1 << (EI_MAG1 * 8)) |
817            (ELFMAG2 << (EI_MAG2 * 8)) |
818            (ELFMAG3 << (EI_MAG3 * 8)))
819 #else
820           ((ELFMAG0 << (EI_MAG3 * 8)) |
821            (ELFMAG1 << (EI_MAG2 * 8)) |
822            (ELFMAG2 << (EI_MAG1 * 8)) |
823            (ELFMAG3 << (EI_MAG0 * 8)))
824 #endif
825           )
826         LOSE (0, N_("invalid ELF header"));
827       if (header->e_ident[EI_CLASS] != ELFW(CLASS))
828         {
829           if (__ELF_NATIVE_CLASS == 32)
830             LOSE (0, N_("ELF file class not 32-bit"));
831           else
832             LOSE (0, N_("ELF file class not 64-bit"));
833         }
834       if (header->e_ident[EI_DATA] != byteorder)
835         {
836           if (BYTE_ORDER == BIG_ENDIAN)
837             LOSE (0, "ELF file data encoding not big-endian");
838           else
839             LOSE (0, "ELF file data encoding not little-endian");
840         }
841       if (header->e_ident[EI_VERSION] != EV_CURRENT)
842         LOSE (0, N_("ELF file version ident does not match current one"));
843       /* XXX We should be able so set system specific versions which are
844          allowed here.  */
845       if (!VALID_ELF_OSABI (header->e_ident[EI_OSABI]))
846         LOSE (0, N_("ELF file OS ABI invalid."));
847       if (!VALID_ELF_ABIVERSION (header->e_ident[EI_ABIVERSION]))
848         LOSE (0, N_("ELF file ABI version invalid."));
849       LOSE (0, N_("internal error"));
850     }
851
852   if (__builtin_expect (header->e_version, EV_CURRENT) != EV_CURRENT)
853     LOSE (0, N_("ELF file version does not match current one"));
854   if (! __builtin_expect (elf_machine_matches_host (header), 1))
855     LOSE (0, N_("ELF file machine architecture does not match"));
856   if (__builtin_expect (header->e_phentsize, sizeof (ElfW(Phdr)))
857       != sizeof (ElfW(Phdr)))
858     LOSE (0, N_("ELF file's phentsize not the expected size"));
859
860 #ifndef MAP_ANON
861 # define MAP_ANON 0
862   if (_dl_zerofd == -1)
863     {
864       _dl_zerofd = _dl_sysdep_open_zero_fill ();
865       if (_dl_zerofd == -1)
866         {
867           __close (fd);
868           _dl_signal_error (errno, NULL, N_("cannot open zero fill device"));
869         }
870     }
871 #endif
872
873   /* Enter the new object in the list of loaded objects.  */
874   l = _dl_new_object (realname, name, l_type, loader);
875   if (__builtin_expect (! l, 0))
876     LOSE (ENOMEM, N_("cannot create shared object descriptor"));
877   l->l_opencount = 1;
878
879   /* Extract the remaining details we need from the ELF header
880      and then read in the program header table.  */
881   l->l_entry = header->e_entry;
882   type = header->e_type;
883   l->l_phnum = header->e_phnum;
884
885   maplength = header->e_phnum * sizeof (ElfW(Phdr));
886   if (header->e_phoff + maplength <= readlength)
887     phdr = (void *) (readbuf + header->e_phoff);
888   else
889     {
890       phdr = alloca (maplength);
891       __lseek (fd, SEEK_SET, header->e_phoff);
892       if (__libc_read (fd, (void *) phdr, maplength) != maplength)
893         LOSE (errno, N_("cannot read file data"));
894     }
895
896   {
897     /* Scan the program header table, collecting its load commands.  */
898     struct loadcmd
899       {
900         ElfW(Addr) mapstart, mapend, dataend, allocend;
901         off_t mapoff;
902         int prot;
903       } loadcmds[l->l_phnum], *c;
904     size_t nloadcmds = 0;
905
906     /* The struct is initialized to zero so this is not necessary:
907     l->l_ld = 0;
908     l->l_phdr = 0;
909     l->l_addr = 0; */
910     for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
911       switch (ph->p_type)
912         {
913           /* These entries tell us where to find things once the file's
914              segments are mapped in.  We record the addresses it says
915              verbatim, and later correct for the run-time load address.  */
916         case PT_DYNAMIC:
917           l->l_ld = (void *) ph->p_vaddr;
918           l->l_ldnum = ph->p_memsz / sizeof (ElfW(Dyn));
919           break;
920         case PT_PHDR:
921           l->l_phdr = (void *) ph->p_vaddr;
922           break;
923
924         case PT_LOAD:
925           /* A load command tells us to map in part of the file.
926              We record the load commands and process them all later.  */
927           if (ph->p_align % _dl_pagesize != 0)
928             LOSE (0, N_("ELF load command alignment not page-aligned"));
929           if ((ph->p_vaddr - ph->p_offset) % ph->p_align)
930             LOSE (0,
931                   N_("ELF load command address/offset not properly aligned"));
932           {
933             struct loadcmd *c = &loadcmds[nloadcmds++];
934             c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
935             c->mapend = ((ph->p_vaddr + ph->p_filesz + _dl_pagesize - 1)
936                          & ~(_dl_pagesize - 1));
937             c->dataend = ph->p_vaddr + ph->p_filesz;
938             c->allocend = ph->p_vaddr + ph->p_memsz;
939             c->mapoff = ph->p_offset & ~(ph->p_align - 1);
940
941             /* Optimize a common case.  */
942             if ((PF_R | PF_W | PF_X) == 7
943                 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7)
944               c->prot = _dl_pf_to_prot[ph->p_flags & (PF_R | PF_W | PF_X)];
945             else
946               {
947                 c->prot = 0;
948                 if (ph->p_flags & PF_R)
949                   c->prot |= PROT_READ;
950                 if (ph->p_flags & PF_W)
951                   c->prot |= PROT_WRITE;
952                 if (ph->p_flags & PF_X)
953                   c->prot |= PROT_EXEC;
954               }
955             break;
956           }
957         }
958
959     /* Now process the load commands and map segments into memory.  */
960     c = loadcmds;
961
962     /* Length of the sections to be loaded.  */
963     maplength = loadcmds[nloadcmds - 1].allocend - c->mapstart;
964
965     if (type == ET_DYN || type == ET_REL)
966       {
967         /* This is a position-independent shared object.  We can let the
968            kernel map it anywhere it likes, but we must have space for all
969            the segments in their specified positions relative to the first.
970            So we map the first segment without MAP_FIXED, but with its
971            extent increased to cover all the segments.  Then we remove
972            access from excess portion, and there is known sufficient space
973            there to remap from the later segments.
974
975            As a refinement, sometimes we have an address that we would
976            prefer to map such objects at; but this is only a preference,
977            the OS can do whatever it likes. */
978         ElfW(Addr) mappref;
979         mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
980                    - MAP_BASE_ADDR (l));
981
982         /* Remember which part of the address space this object uses.  */
983         l->l_map_start = (ElfW(Addr)) map_segment (mappref, maplength, c->prot,
984                                                    0, c->mapoff);
985         l->l_map_end = l->l_map_start + maplength;
986         l->l_addr = l->l_map_start - c->mapstart;
987
988         /* Change protection on the excess portion to disallow all access;
989            the portions we do not remap later will be inaccessible as if
990            unallocated.  Then jump into the normal segment-mapping loop to
991            handle the portion of the segment past the end of the file
992            mapping.  */
993         __mprotect ((caddr_t) (l->l_addr + c->mapend),
994                     loadcmds[nloadcmds - 1].allocend - c->mapend,
995                     0);
996
997         goto postmap;
998       }
999     else
1000       {
1001         /* This object is loaded at a fixed address.  This must never
1002            happen for objects loaded with dlopen().  */
1003         if (mode & __RTLD_DLOPEN)
1004           {
1005             LOSE (0, N_("cannot dynamically load executable"));
1006           }
1007
1008         /* Notify ELF_PREFERRED_ADDRESS that we have to load this one
1009            fixed.  */
1010         ELF_FIXED_ADDRESS (loader, c->mapstart);
1011       }
1012
1013     /* Remember which part of the address space this object uses.  */
1014     l->l_map_start = c->mapstart + l->l_addr;
1015     l->l_map_end = l->l_map_start + maplength;
1016
1017     while (c < &loadcmds[nloadcmds])
1018       {
1019         if (c->mapend > c->mapstart)
1020           /* Map the segment contents from the file.  */
1021           map_segment (l->l_addr + c->mapstart, c->mapend - c->mapstart,
1022                        c->prot, MAP_FIXED, c->mapoff);
1023
1024       postmap:
1025         if (l->l_phdr == 0
1026             && c->mapoff <= header->e_phoff
1027             && (c->mapend - c->mapstart + c->mapoff
1028                 >= header->e_phoff + header->e_phnum * sizeof (ElfW(Phdr))))
1029           /* Found the program header in this segment.  */
1030           l->l_phdr = (void *) (c->mapstart + header->e_phoff - c->mapoff);
1031
1032         if (c->allocend > c->dataend)
1033           {
1034             /* Extra zero pages should appear at the end of this segment,
1035                after the data mapped from the file.   */
1036             ElfW(Addr) zero, zeroend, zeropage;
1037
1038             zero = l->l_addr + c->dataend;
1039             zeroend = l->l_addr + c->allocend;
1040             zeropage = (zero + _dl_pagesize - 1) & ~(_dl_pagesize - 1);
1041
1042             if (zeroend < zeropage)
1043               /* All the extra data is in the last page of the segment.
1044                  We can just zero it.  */
1045               zeropage = zeroend;
1046
1047             if (zeropage > zero)
1048               {
1049                 /* Zero the final part of the last page of the segment.  */
1050                 if ((c->prot & PROT_WRITE) == 0)
1051                   {
1052                     /* Dag nab it.  */
1053                     if (__mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
1054                                     _dl_pagesize, c->prot|PROT_WRITE) < 0)
1055                       LOSE (errno, N_("cannot change memory protections"));
1056                   }
1057                 memset ((void *) zero, 0, zeropage - zero);
1058                 if ((c->prot & PROT_WRITE) == 0)
1059                   __mprotect ((caddr_t) (zero & ~(_dl_pagesize - 1)),
1060                               _dl_pagesize, c->prot);
1061               }
1062
1063             if (zeroend > zeropage)
1064               {
1065                 /* Map the remaining zero pages in from the zero fill FD.  */
1066                 caddr_t mapat;
1067                 mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
1068                                 c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
1069                                 ANONFD, 0);
1070                 if (mapat == MAP_FAILED)
1071                   LOSE (errno, N_("cannot map zero-fill pages"));
1072               }
1073           }
1074
1075         ++c;
1076       }
1077
1078     if (l->l_phdr == NULL)
1079       {
1080         /* The program header is not contained in any of the segmenst.
1081            We have to allocate memory ourself and copy it over from
1082            out temporary place.  */
1083         ElfW(Phdr) *newp = (ElfW(Phdr) *) malloc (header->e_phnum
1084                                                   * sizeof (ElfW(Phdr)));
1085         if (newp == NULL)
1086           LOSE (ENOMEM, N_("cannot allocate memory for program header"));
1087
1088         l->l_phdr = memcpy (newp, phdr,
1089                             (header->e_phnum * sizeof (ElfW(Phdr))));
1090         l->l_phdr_allocated = 1;
1091       }
1092     else
1093       /* Adjust the PT_PHDR value by the runtime load address.  */
1094       (ElfW(Addr)) l->l_phdr += l->l_addr;
1095   }
1096
1097   /* We are done mapping in the file.  We no longer need the descriptor.  */
1098   __close (fd);
1099
1100   if (l->l_type == lt_library && type == ET_EXEC)
1101     l->l_type = lt_executable;
1102
1103   if (l->l_ld == 0)
1104     {
1105       if (type == ET_DYN)
1106         LOSE (0, N_("object file has no dynamic section"));
1107     }
1108   else
1109     (ElfW(Addr)) l->l_ld += l->l_addr;
1110
1111   l->l_entry += l->l_addr;
1112
1113   if (__builtin_expect (_dl_debug_files, 0))
1114     {
1115       const size_t nibbles = sizeof (void *) * 2;
1116       char buf1[nibbles + 1];
1117       char buf2[nibbles + 1];
1118       char buf3[nibbles + 1];
1119
1120       buf1[nibbles] = '\0';
1121       buf2[nibbles] = '\0';
1122       buf3[nibbles] = '\0';
1123
1124       memset (buf1, '0', nibbles);
1125       memset (buf2, '0', nibbles);
1126       memset (buf3, '0', nibbles);
1127       _itoa_word ((unsigned long int) l->l_ld, &buf1[nibbles], 16, 0);
1128       _itoa_word ((unsigned long int) l->l_addr, &buf2[nibbles], 16, 0);
1129       _itoa_word (maplength, &buf3[nibbles], 16, 0);
1130
1131       _dl_debug_message (1, "  dynamic: 0x", buf1, "  base: 0x", buf2,
1132                          "   size: 0x", buf3, "\n", NULL);
1133       memset (buf1, '0', nibbles);
1134       memset (buf2, '0', nibbles);
1135       memset (buf3, ' ', nibbles);
1136       _itoa_word ((unsigned long int) l->l_entry, &buf1[nibbles], 16, 0);
1137       _itoa_word ((unsigned long int) l->l_phdr, &buf2[nibbles], 16, 0);
1138       _itoa_word (l->l_phnum, &buf3[nibbles], 10, 0);
1139       _dl_debug_message (1, "    entry: 0x", buf1, "  phdr: 0x", buf2,
1140                          "  phnum:   ", buf3, "\n\n", NULL);
1141     }
1142
1143   elf_get_dynamic_info (l);
1144
1145   /* Make sure we are dlopen()ing an object which has the DF_1_NOOPEN
1146      flag set.  */
1147   if (__builtin_expect (l->l_flags_1 & DF_1_NOOPEN, 0)
1148       && (mode & __RTLD_DLOPEN))
1149     {
1150       /* Remove from the module list.  */
1151       assert (l->l_next == NULL);
1152 #ifndef SHARED
1153       if (l->l_prev == NULL)
1154         /* No other module loaded.  */
1155         _dl_loaded = NULL;
1156       else
1157 #endif
1158         l->l_prev->l_next = NULL;
1159       --_dl_nloaded;
1160
1161       /* We are not supposed to load this object.  Free all resources.  */
1162       __munmap ((void *) l->l_map_start, l->l_map_end - l->l_map_start);
1163
1164       free (l->l_libname);
1165
1166       if (l->l_phdr_allocated)
1167         free ((void *) l->l_phdr);
1168
1169       free (l);
1170
1171       _dl_signal_error (0, name, N_("shared object cannot be dlopen()ed"));
1172     }
1173
1174   if (l->l_info[DT_HASH])
1175     _dl_setup_hash (l);
1176
1177   /* If this object has DT_SYMBOLIC set modify now its scope.  We don't
1178      have to do this for the main map.  */
1179   if (__builtin_expect (l->l_info[DT_SYMBOLIC] != NULL, 0)
1180            && &l->l_searchlist != l->l_scope[0])
1181     {
1182       /* Create an appropriate searchlist.  It contains only this map.
1183
1184          XXX This is the definition of DT_SYMBOLIC in SysVr4.  The old
1185          GNU ld.so implementation had a different interpretation which
1186          is more reasonable.  We are prepared to add this possibility
1187          back as part of a GNU extension of the ELF format.  */
1188       l->l_symbolic_searchlist.r_list =
1189         (struct link_map **) malloc (sizeof (struct link_map *));
1190
1191       if (l->l_symbolic_searchlist.r_list == NULL)
1192         LOSE (ENOMEM, N_("cannot create searchlist"));
1193
1194       l->l_symbolic_searchlist.r_list[0] = l;
1195       l->l_symbolic_searchlist.r_nlist = 1;
1196       l->l_symbolic_searchlist.r_duplist = l->l_symbolic_searchlist.r_list;
1197       l->l_symbolic_searchlist.r_nduplist = 1;
1198
1199       /* Now move the existing entries one back.  */
1200       memmove (&l->l_scope[1], &l->l_scope[0],
1201                sizeof (l->l_scope) - sizeof (l->l_scope[0]));
1202
1203       /* Now add the new entry.  */
1204       l->l_scope[0] = &l->l_symbolic_searchlist;
1205     }
1206
1207   /* Finally the file information.  */
1208   l->l_dev = st.st_dev;
1209   l->l_ino = st.st_ino;
1210
1211   return l;
1212 }
1213 \f
1214 /* Print search path.  */
1215 static void
1216 print_search_path (struct r_search_path_elem **list,
1217                    const char *what, const char *name)
1218 {
1219   char buf[max_dirnamelen + max_capstrlen];
1220   int first = 1;
1221
1222   _dl_debug_message (1, " search path=", NULL);
1223
1224   while (*list != NULL && (*list)->what == what) /* Yes, ==.  */
1225     {
1226       char *endp = __mempcpy (buf, (*list)->dirname, (*list)->dirnamelen);
1227       size_t cnt;
1228
1229       for (cnt = 0; cnt < ncapstr; ++cnt)
1230         if ((*list)->status[cnt] != nonexisting)
1231           {
1232             char *cp = __mempcpy (endp, capstr[cnt].str, capstr[cnt].len);
1233             if (cp == buf || (cp == buf + 1 && buf[0] == '/'))
1234               cp[0] = '\0';
1235             else
1236               cp[-1] = '\0';
1237             _dl_debug_message (0, first ? "" : ":", buf, NULL);
1238             first = 0;
1239           }
1240
1241       ++list;
1242     }
1243
1244   if (name != NULL)
1245     _dl_debug_message (0, "\t\t(", what, " from file ",
1246                         name[0] ? name : _dl_argv[0], ")\n", NULL);
1247   else
1248     _dl_debug_message (0, "\t\t(", what, ")\n", NULL);
1249 }
1250 \f
1251 /* Try to open NAME in one of the directories in *DIRSP.
1252    Return the fd, or -1.  If successful, fill in *REALNAME
1253    with the malloc'd full directory name.  If it turns out
1254    that none of the directories in *DIRSP exists, *DIRSP is
1255    replaced with (void *) -1, and the old value is free()d
1256    if MAY_FREE_DIRS is true.  */
1257
1258 static int
1259 open_path (const char *name, size_t namelen, int preloaded,
1260            struct r_search_path_struct *sps, char **realname)
1261 {
1262   struct r_search_path_elem **dirs = sps->dirs;
1263   char *buf;
1264   int fd = -1;
1265   const char *current_what = NULL;
1266   int any = 0;
1267
1268   buf = alloca (max_dirnamelen + max_capstrlen + namelen);
1269   do
1270     {
1271       struct r_search_path_elem *this_dir = *dirs;
1272       size_t buflen = 0;
1273       size_t cnt;
1274       char *edp;
1275
1276       /* If we are debugging the search for libraries print the path
1277          now if it hasn't happened now.  */
1278       if (__builtin_expect (_dl_debug_libs, 0)
1279           && current_what != this_dir->what)
1280         {
1281           current_what = this_dir->what;
1282           print_search_path (dirs, current_what, this_dir->where);
1283         }
1284
1285       edp = (char *) __mempcpy (buf, this_dir->dirname, this_dir->dirnamelen);
1286       for (cnt = 0; fd == -1 && cnt < ncapstr; ++cnt)
1287         {
1288           /* Skip this directory if we know it does not exist.  */
1289           if (this_dir->status[cnt] == nonexisting)
1290             continue;
1291
1292           buflen =
1293             ((char *) __mempcpy (__mempcpy (edp,
1294                                             capstr[cnt].str, capstr[cnt].len),
1295                                  name, namelen)
1296              - buf);
1297
1298           /* Print name we try if this is wanted.  */
1299           if (__builtin_expect (_dl_debug_libs, 0))
1300             _dl_debug_message (1, "  trying file=", buf, "\n", NULL);
1301
1302           fd = __open (buf, O_RDONLY);
1303           if (this_dir->status[cnt] == unknown)
1304             {
1305               if (fd != -1)
1306                 this_dir->status[cnt] = existing;
1307               else
1308                 {
1309                   /* We failed to open machine dependent library.  Let's
1310                      test whether there is any directory at all.  */
1311                   struct stat64 st;
1312
1313                   buf[buflen - namelen - 1] = '\0';
1314
1315                   if (__xstat64 (_STAT_VER, buf, &st) != 0
1316                       || ! S_ISDIR (st.st_mode))
1317                     /* The directory does not exist or it is no directory.  */
1318                     this_dir->status[cnt] = nonexisting;
1319                   else
1320                     this_dir->status[cnt] = existing;
1321                 }
1322             }
1323
1324           /* Remember whether we found any existing directory.  */
1325           any |= this_dir->status[cnt] == existing;
1326
1327           if (fd != -1 && preloaded && __libc_enable_secure)
1328             {
1329               /* This is an extra security effort to make sure nobody can
1330                  preload broken shared objects which are in the trusted
1331                  directories and so exploit the bugs.  */
1332               struct stat64 st;
1333
1334               if (__fxstat64 (_STAT_VER, fd, &st) != 0
1335                   || (st.st_mode & S_ISUID) == 0)
1336                 {
1337                   /* The shared object cannot be tested for being SUID
1338                      or this bit is not set.  In this case we must not
1339                      use this object.  */
1340                   __close (fd);
1341                   fd = -1;
1342                   /* We simply ignore the file, signal this by setting
1343                      the error value which would have been set by `open'.  */
1344                   errno = ENOENT;
1345                 }
1346             }
1347         }
1348
1349       if (fd != -1)
1350         {
1351           *realname = malloc (buflen);
1352           if (*realname != NULL)
1353             {
1354               memcpy (*realname, buf, buflen);
1355               return fd;
1356             }
1357           else
1358             {
1359               /* No memory for the name, we certainly won't be able
1360                  to load and link it.  */
1361               __close (fd);
1362               return -1;
1363             }
1364         }
1365       if (errno != ENOENT && errno != EACCES)
1366         /* The file exists and is readable, but something went wrong.  */
1367         return -1;
1368     }
1369   while (*++dirs != NULL);
1370
1371   /* Remove the whole path if none of the directories exists.  */
1372   if (! any)
1373     {
1374       /* Paths which were allocated using the minimal malloc() in ld.so
1375          must not be freed using the general free() in libc.  */
1376       if (sps->malloced)
1377         free (sps->dirs);
1378       sps->dirs = (void *) -1;
1379     }
1380
1381   return -1;
1382 }
1383
1384 /* Map in the shared object file NAME.  */
1385
1386 struct link_map *
1387 internal_function
1388 _dl_map_object (struct link_map *loader, const char *name, int preloaded,
1389                 int type, int trace_mode, int mode)
1390 {
1391   int fd;
1392   char *realname;
1393   char *name_copy;
1394   struct link_map *l;
1395
1396   /* Look for this name among those already loaded.  */
1397   for (l = _dl_loaded; l; l = l->l_next)
1398     {
1399       /* If the requested name matches the soname of a loaded object,
1400          use that object.  Elide this check for names that have not
1401          yet been opened.  */
1402       if (l->l_opencount <= 0)
1403         continue;
1404       if (!_dl_name_match_p (name, l))
1405         {
1406           const char *soname;
1407
1408           if (l->l_info[DT_SONAME] == NULL)
1409             continue;
1410
1411           soname = (const void *) (D_PTR (l, l_info[DT_STRTAB])
1412                                    + l->l_info[DT_SONAME]->d_un.d_val);
1413           if (strcmp (name, soname) != 0)
1414             continue;
1415
1416           /* We have a match on a new name -- cache it.  */
1417           add_name_to_object (l, soname);
1418         }
1419
1420       /* We have a match -- bump the reference count and return it.  */
1421       ++l->l_opencount;
1422       return l;
1423     }
1424
1425   /* Display information if we are debugging.  */
1426   if (__builtin_expect (_dl_debug_files, 0) && loader != NULL)
1427     _dl_debug_message (1, "\nfile=", name, ";  needed by ",
1428                        loader->l_name[0] ? loader->l_name : _dl_argv[0],
1429                        "\n", NULL);
1430
1431   if (strchr (name, '/') == NULL)
1432     {
1433       /* Search for NAME in several places.  */
1434
1435       size_t namelen = strlen (name) + 1;
1436
1437       if (__builtin_expect (_dl_debug_libs, 0))
1438         _dl_debug_message (1, "find library=", name, "; searching\n", NULL);
1439
1440       fd = -1;
1441
1442       /* When the object has the RUNPATH information we don't use any
1443          RPATHs.  */
1444       if (loader == NULL || loader->l_info[DT_RUNPATH] == NULL)
1445         {
1446           /* First try the DT_RPATH of the dependent object that caused NAME
1447              to be loaded.  Then that object's dependent, and on up.  */
1448           for (l = loader; fd == -1 && l; l = l->l_loader)
1449             {
1450               if (l->l_rpath_dirs.dirs == NULL)
1451                 {
1452                   if (l->l_info[DT_RPATH] == NULL)
1453                     /* There is no path.  */
1454                     l->l_rpath_dirs.dirs = (void *) -1;
1455                   else
1456                     {
1457                       /* Make sure the cache information is available.  */
1458                       size_t ptrval = (D_PTR (l, l_info[DT_STRTAB])
1459                                        + l->l_info[DT_RPATH]->d_un.d_val);
1460                       decompose_rpath (&l->l_rpath_dirs,
1461                                        (const char *) ptrval, l, "RPATH");
1462
1463                       if (l->l_rpath_dirs.dirs != (void *) -1)
1464                         fd = open_path (name, namelen, preloaded,
1465                                         &l->l_rpath_dirs, &realname);
1466                     }
1467                 }
1468               else if (l->l_rpath_dirs.dirs != (void *) -1)
1469                 fd = open_path (name, namelen, preloaded, &l->l_rpath_dirs,
1470                                 &realname);
1471             }
1472
1473           /* If dynamically linked, try the DT_RPATH of the executable
1474              itself.  */
1475           l = _dl_loaded;
1476           if (fd == -1 && l && l->l_type != lt_loaded && l != loader
1477               && l->l_rpath_dirs.dirs != (void *) -1)
1478             fd = open_path (name, namelen, preloaded, &l->l_rpath_dirs,
1479                             &realname);
1480         }
1481
1482       /* Try the LD_LIBRARY_PATH environment variable.  */
1483       if (fd == -1 && env_path_list.dirs != (void *) -1)
1484         fd = open_path (name, namelen, preloaded, &env_path_list,
1485                         &realname);
1486
1487       /* Look at the RUNPATH informaiton for this binary.  */
1488       if (loader != NULL && loader->l_runpath_dirs.dirs != (void *) -1)
1489         {
1490           if (loader->l_runpath_dirs.dirs == NULL)
1491             {
1492               if (loader->l_info[DT_RUNPATH] == NULL)
1493                 /* No RUNPATH.  */
1494                 loader->l_runpath_dirs.dirs = (void *) -1;
1495               else
1496                 {
1497                   /* Make sure the cache information is available.  */
1498                   size_t ptrval = (D_PTR (loader, l_info[DT_STRTAB])
1499                                    + loader->l_info[DT_RUNPATH]->d_un.d_val);
1500                   decompose_rpath (&loader->l_runpath_dirs,
1501                                    (const char *) ptrval, loader, "RUNPATH");
1502
1503                   if (loader->l_runpath_dirs.dirs != (void *) -1)
1504                     fd = open_path (name, namelen, preloaded,
1505                                     &loader->l_runpath_dirs, &realname);
1506                 }
1507             }
1508           else if (loader->l_runpath_dirs.dirs != (void *) -1)
1509             fd = open_path (name, namelen, preloaded,
1510                             &loader->l_runpath_dirs, &realname);
1511         }
1512
1513       if (fd == -1)
1514         {
1515           /* Check the list of libraries in the file /etc/ld.so.cache,
1516              for compatibility with Linux's ldconfig program.  */
1517           extern const char *_dl_load_cache_lookup (const char *name);
1518           const char *cached = _dl_load_cache_lookup (name);
1519
1520 #ifdef SHARED
1521           l = loader ?: _dl_loaded;
1522 #else
1523           l = loader;
1524 #endif
1525
1526           if (cached)
1527             {
1528               /* If the loader has the DF_1_NODEFLIB flag set we must not
1529                  use a cache entry from any of these directories.  */
1530               if (l && __builtin_expect (l->l_flags_1 & DF_1_NODEFLIB, 0))
1531                 {
1532                   const char *dirp = system_dirs;
1533                   int cnt = 0;
1534
1535                   do
1536                     {
1537                       if (memcmp (cached, dirp, system_dirs_len[cnt]) == 0)
1538                         {
1539                           /* The prefix matches.  Don't use the entry.  */
1540                           cached = NULL;
1541                           break;
1542                         }
1543
1544                       dirp += system_dirs_len[cnt] + 1;
1545                       ++cnt;
1546                     }
1547                   while (cnt < nsystem_dirs_len);
1548                 }
1549
1550               if (cached)
1551                 {
1552                   fd = __open (cached, O_RDONLY);
1553                   if (fd != -1)
1554                     {
1555                       realname = local_strdup (cached);
1556                       if (realname == NULL)
1557                         {
1558                           __close (fd);
1559                           fd = -1;
1560                         }
1561                     }
1562                 }
1563             }
1564         }
1565
1566       /* Finally, try the default path.  */
1567       if (fd == -1
1568           && (l == NULL ||
1569               __builtin_expect (!(l->l_flags_1 & DF_1_NODEFLIB), 1))
1570           && rtld_search_dirs.dirs != (void *) -1)
1571         fd = open_path (name, namelen, preloaded, &rtld_search_dirs,
1572                         &realname);
1573
1574       /* Add another newline when we a tracing the library loading.  */
1575       if (__builtin_expect (_dl_debug_libs, 0))
1576         _dl_debug_message (1, "\n", NULL);
1577     }
1578   else
1579     {
1580       /* The path may contain dynamic string tokens.  */
1581       realname = (loader
1582                   ? expand_dynamic_string_token (loader, name)
1583                   : local_strdup (name));
1584       if (realname == NULL)
1585         fd = -1;
1586       else
1587         {
1588           fd = __open (realname, O_RDONLY);
1589           if (fd == -1)
1590             free (realname);
1591         }
1592     }
1593
1594   if (fd == -1)
1595     {
1596       if (trace_mode)
1597         {
1598           /* We haven't found an appropriate library.  But since we
1599              are only interested in the list of libraries this isn't
1600              so severe.  Fake an entry with all the information we
1601              have.  */
1602           static const Elf_Symndx dummy_bucket = STN_UNDEF;
1603
1604           /* Enter the new object in the list of loaded objects.  */
1605           if ((name_copy = local_strdup (name)) == NULL
1606               || (l = _dl_new_object (name_copy, name, type, loader)) == NULL)
1607             _dl_signal_error (ENOMEM, name,
1608                               N_("cannot create shared object descriptor"));
1609           /* We use an opencount of 0 as a sign for the faked entry.
1610              Since the descriptor is initialized with zero we do not
1611              have do this here.
1612           l->l_opencount = 0;
1613           l->l_reserved = 0; */
1614           l->l_buckets = &dummy_bucket;
1615           l->l_nbuckets = 1;
1616           l->l_relocated = 1;
1617
1618           return l;
1619         }
1620       else
1621         _dl_signal_error (errno, name, N_("cannot open shared object file"));
1622     }
1623
1624   return _dl_map_object_from_fd (name, fd, realname, loader, type, mode);
1625 }