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