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