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