ldso/ldso/ldso.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Program to load an ELF binary on a linux system, and run it
   4  * after resolving ELF shared library symbols
   5  *
   6  * Copyright (C) 2005 by Joakim Tjernlund
   7  * Copyright (C) 2000-2004 by Erik Andersen <andersen@codepoet.org>
   8  * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald,
   9  *                              David Engel, Hongjiu Lu and Mitch D'Souza
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. The name of the above contributors may not be
  17  *    used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include "ldso.h"
  34 #include "unsecvars.h"
  35
  36 /* Pull in common debug code */
  37 #include "dl-debug.c"
  38
  39 #define ALLOW_ZERO_PLTGOT
  40
  41 /* Pull in the value of _dl_progname */
  42 #include LDSO_ELFINTERP
  43
  44 /* Global variables used within the shared library loader */
  45 char *_dl_library_path         = 0;     /* Where we look for libraries */
  46 char *_dl_preload              = 0;     /* Things to be loaded before the libs */
  47 char *_dl_ldsopath             = 0;     /* Location of the shared lib loader */
  48 int _dl_secure                 = 1;     /* Are we dealing with setuid stuff? */
  49 int _dl_errno                  = 0;     /* We can't use the real errno in ldso */
  50 size_t _dl_pagesize            = 0;     /* Store the page size for use later */
  51 struct r_debug *_dl_debug_addr = NULL;  /* Used to communicate with the gdb debugger */
  52 void *(*_dl_malloc_function) (size_t size) = NULL;
  53
  54 #ifdef __SUPPORT_LD_DEBUG__
  55 char *_dl_debug           = 0;
  56 char *_dl_debug_symbols   = 0;
  57 char *_dl_debug_move      = 0;
  58 char *_dl_debug_reloc     = 0;
  59 char *_dl_debug_detail    = 0;
  60 char *_dl_debug_nofixups  = 0;
  61 char *_dl_debug_bindings  = 0;
  62 int   _dl_debug_file      = 2;
  63 #endif
  64
  65 /* Needed for standalone execution. */
  66 unsigned long attribute_hidden _dl_skip_args = 0;
  67 const char *_dl_progname = UCLIBC_LDSO;      /* The name of the executable being run */
  68 #include "dl-startup.c"
  69 /* Forward function declarations */
  70 static int _dl_suid_ok(void);
  71
  72 /*
  73  * This stub function is used by some debuggers.  The idea is that they
  74  * can set an internal breakpoint on it, so that we are notified when the
  75  * address mapping is changed in some way.
  76  */
  77 void _dl_debug_state(void);
  78 void _dl_debug_state()
  79 {
  80 }
  81
  82 static unsigned char *_dl_malloc_addr = 0;      /* Lets _dl_malloc use the already allocated memory page */
  83 static unsigned char *_dl_mmap_zero   = 0;      /* Also used by _dl_malloc */
  84
  85 static struct elf_resolve **init_fini_list;
  86 static unsigned int nlist; /* # items in init_fini_list */
  87 extern void _start(void);
  88
  89 #ifdef __UCLIBC_HAS_SSP__
  90 # include <dl-osinfo.h>
  91 uintptr_t stack_chk_guard;
  92 # ifndef THREAD_SET_STACK_GUARD
  93 /* Only exported for architectures that don't store the stack guard canary
  94  * in local thread area.  */
  95 uintptr_t __stack_chk_guard attribute_relro;
  96 #  ifdef __UCLIBC_HAS_SSP_COMPAT__
  97 strong_alias(__stack_chk_guard,__guard)
  98 #  endif
  99 # elif __UCLIBC_HAS_SSP_COMPAT__
 100 uintptr_t __guard attribute_relro;
 101 # endif
 102 #endif
 103
 104 static void _dl_run_array_forward(unsigned long array, unsigned long size,
 105                                   DL_LOADADDR_TYPE loadaddr)
 106 {
 107         if (array != 0) {
 108                 unsigned int j;
 109                 unsigned int jm;
 110                 ElfW(Addr) *addrs;
 111                 jm = size / sizeof (ElfW(Addr));
 112                 addrs = (ElfW(Addr) *) DL_RELOC_ADDR (array, loadaddr);
 113                 for (j = 0; j < jm; ++j) {
 114                         void (*dl_elf_func) (void);
 115                         dl_elf_func = (void (*)(void)) DL_RELOC_ADDR (addrs[j],
 116                                                                       loadaddr);
 117                         (*dl_elf_func) ();
 118                 }
 119         }
 120 }
 121
 122 void _dl_run_init_array(struct elf_resolve *tpnt);
 123 void _dl_run_init_array(struct elf_resolve *tpnt)
 124 {
 125         _dl_run_array_forward(tpnt->dynamic_info[DT_INIT_ARRAY],
 126                               tpnt->dynamic_info[DT_INIT_ARRAYSZ],
 127                               tpnt->loadaddr);
 128 }
 129
 130 void _dl_app_init_array(void);
 131 void _dl_app_init_array(void)
 132 {
 133         _dl_run_init_array(_dl_loaded_modules);
 134 }
 135
 136 void _dl_run_fini_array(struct elf_resolve *tpnt);
 137 void _dl_run_fini_array(struct elf_resolve *tpnt)
 138 {
 139         if (tpnt->dynamic_info[DT_FINI_ARRAY]) {
 140                 ElfW(Addr) *array = (ElfW(Addr) *) DL_RELOC_ADDR (tpnt->dynamic_info[DT_FINI_ARRAY],
 141                                                                   tpnt->loadaddr);
 142                 unsigned int i = (tpnt->dynamic_info[DT_FINI_ARRAYSZ] / sizeof(ElfW(Addr)));
 143                 while (i-- > 0) {
 144                         void (*dl_elf_func) (void);
 145                         dl_elf_func = (void (*)(void)) DL_RELOC_ADDR (array[i],
 146                                                                       tpnt->loadaddr);
 147                         (*dl_elf_func) ();
 148                 }
 149         }
 150 }
 151
 152 void _dl_app_fini_array(void);
 153 void _dl_app_fini_array(void)
 154 {
 155         _dl_run_fini_array(_dl_loaded_modules);
 156 }
 157
 158 static void __attribute__ ((destructor)) __attribute_used__ _dl_fini(void)
 159 {
 160         int i;
 161         struct elf_resolve * tpnt;
 162
 163         for (i = 0; i < nlist; ++i) {
 164                 tpnt = init_fini_list[i];
 165                 if (tpnt->init_flag & FINI_FUNCS_CALLED)
 166                         continue;
 167                 tpnt->init_flag |= FINI_FUNCS_CALLED;
 168                 _dl_run_fini_array(tpnt);
 169                 if (tpnt->dynamic_info[DT_FINI]) {
 170                         void (*dl_elf_func) (void);
 171
 172                         dl_elf_func = (void (*)(void)) DL_RELOC_ADDR (tpnt->dynamic_info[DT_FINI],
 173                                                                       tpnt->loadaddr);
 174                         _dl_if_debug_dprint("\ncalling FINI: %s\n\n", tpnt->libname);
 175                         (*dl_elf_func) ();
 176                 }
 177         }
 178 }
 179
 180 void _dl_get_ready_to_run(struct elf_resolve *tpnt, DL_LOADADDR_TYPE load_addr,
 181                           ElfW(auxv_t) auxvt[AT_EGID + 1], char **envp,
 182                           char **argv)
 183 {
 184         ElfW(Phdr) *ppnt;
 185         ElfW(Dyn) *dpnt;
 186         char *lpntstr;
 187         unsigned int i;
 188         int unlazy = 0, trace_loaded_objects = 0;
 189         struct dyn_elf *rpnt;
 190         struct elf_resolve *tcurr;
 191         struct elf_resolve *tpnt1;
 192         struct elf_resolve app_tpnt_tmp;
 193         struct elf_resolve *app_tpnt = &app_tpnt_tmp;
 194         struct r_debug *debug_addr;
 195         unsigned long *lpnt;
 196         unsigned long *_dl_envp;                /* The environment address */
 197         ElfW(Addr) relro_addr = 0;
 198         size_t relro_size = 0;
 199
 200         /* Wahoo!!! We managed to make a function call!  Get malloc
 201          * setup so we can use _dl_dprintf() to print debug noise
 202          * instead of the SEND_STDERR macros used in dl-startup.c */
 203
 204         _dl_memset(app_tpnt, 0x00, sizeof(*app_tpnt));
 205
 206         /* Store the page size for later use */
 207         _dl_pagesize = (auxvt[AT_PAGESZ].a_un.a_val) ? (size_t) auxvt[AT_PAGESZ].a_un.a_val : PAGE_SIZE;
 208         /* Make it so _dl_malloc can use the page of memory we have already
 209          * allocated.  We shouldn't need to grab any more memory.  This must
 210          * be first since things like _dl_dprintf() use _dl_malloc()...
 211          */
 212         _dl_malloc_addr = (unsigned char *)_dl_pagesize;
 213         _dl_mmap_zero = 0;
 214
 215         /* Wahoo!!! */
 216         _dl_debug_early("Cool, ldso survived making function calls\n");
 217
 218         /* Now we have done the mandatory linking of some things.  We are now
 219          * free to start using global variables, since these things have all
 220          * been fixed up by now.  Still no function calls outside of this
 221          * library, since the dynamic resolver is not yet ready.
 222          */
 223         if (argv[0]) {
 224                 _dl_progname = argv[0];
 225         }
 226
 227         if (_start == (void *) auxvt[AT_ENTRY].a_un.a_val) {
 228                 _dl_dprintf(_dl_debug_file, "Standalone execution is not supported yet\n");
 229                 _dl_exit(1);
 230         }
 231
 232         /* Start to build the tables of the modules that are required for
 233          * this beast to run.  We start with the basic executable, and then
 234          * go from there.  Eventually we will run across ourself, and we
 235          * will need to properly deal with that as well.
 236          */
 237         rpnt = NULL;
 238         if (_dl_getenv("LD_BIND_NOW", envp))
 239                 unlazy = RTLD_NOW;
 240
 241         /* Now we need to figure out what kind of options are selected.
 242          * Note that for SUID programs we ignore the settings in
 243          * LD_LIBRARY_PATH.
 244          */
 245         if ((auxvt[AT_UID].a_un.a_val == (size_t)-1 && _dl_suid_ok()) ||
 246             (auxvt[AT_UID].a_un.a_val != (size_t)-1 &&
 247              auxvt[AT_UID].a_un.a_val == auxvt[AT_EUID].a_un.a_val &&
 248              auxvt[AT_GID].a_un.a_val == auxvt[AT_EGID].a_un.a_val)) {
 249                 _dl_secure = 0;
 250                 _dl_preload = _dl_getenv("LD_PRELOAD", envp);
 251                 _dl_library_path = _dl_getenv("LD_LIBRARY_PATH", envp);
 252         } else {
 253                 static const char unsecure_envvars[] =
 254 #ifdef EXTRA_UNSECURE_ENVVARS
 255                         EXTRA_UNSECURE_ENVVARS
 256 #endif
 257                         UNSECURE_ENVVARS;
 258                 const char *nextp;
 259                 _dl_secure = 1;
 260
 261                 nextp = unsecure_envvars;
 262                 do {
 263                         _dl_unsetenv (nextp, envp);
 264                         /* We could use rawmemchr but this need not be fast.  */
 265                         nextp = (char *) _dl_strchr(nextp, '\0') + 1;
 266                 } while (*nextp != '\0');
 267                 _dl_preload = NULL;
 268                 _dl_library_path = NULL;
 269                 /* SUID binaries can be exploited if they do LAZY relocation. */
 270                 unlazy = RTLD_NOW;
 271         }
 272
 273         /* sjhill: your TLS init should go before this */
 274 #ifdef __UCLIBC_HAS_SSP__
 275         /* Set up the stack checker's canary.  */
 276         stack_chk_guard = _dl_setup_stack_chk_guard ();
 277 # ifdef THREAD_SET_STACK_GUARD
 278         THREAD_SET_STACK_GUARD (stack_chk_guard);
 279 #  ifdef __UCLIBC_HAS_SSP_COMPAT__
 280         __guard = stack_chk_guard;
 281 #  endif
 282 # else
 283         __stack_chk_guard = stack_chk_guard;
 284 # endif
 285 #endif
 286
 287         /* At this point we are now free to examine the user application,
 288          * and figure out which libraries are supposed to be called.  Until
 289          * we have this list, we will not be completely ready for dynamic
 290          * linking.
 291          */
 292
 293         /* Find the runtime load address of the main executable.  This may be
 294          * different from what the ELF header says for ET_DYN/PIE executables.
 295          */
 296         {
 297                 unsigned int idx;
 298                 ElfW(Phdr) *phdr = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
 299
 300                 for (idx = 0; idx < auxvt[AT_PHNUM].a_un.a_val; idx++, phdr++)
 301                         if (phdr->p_type == PT_PHDR) {
 302                                 DL_INIT_LOADADDR_PROG (app_tpnt->loadaddr, (ElfW(Addr)) (auxvt[AT_PHDR].a_un.a_val - ppnt->p_vaddr));
 303                                 break;
 304                         }
 305
 306                 if (DL_LOADADDR_BASE (app_tpnt->loadaddr))
 307                         _dl_debug_early("Position Independent Executable: "
 308                                         "app_tpnt->loadaddr=%x\n", DL_LOADADDR_BASE (app_tpnt->loadaddr));
 309         }
 310
 311         /*
 312          * This is used by gdb to locate the chain of shared libraries that are
 313          * currently loaded.
 314          */
 315         debug_addr = _dl_malloc(sizeof(struct r_debug));
 316         _dl_memset(debug_addr, 0, sizeof(struct r_debug));
 317
 318         ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
 319         for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
 320                 if (ppnt->p_type == PT_GNU_RELRO) {
 321                         relro_addr = ppnt->p_vaddr;
 322                         relro_size = ppnt->p_memsz;
 323                 }
 324                 if (ppnt->p_type == PT_DYNAMIC) {
 325                         dpnt = (ElfW(Dyn) *) DL_RELOC_ADDR (ppnt->p_vaddr, app_tpnt->loadaddr);
 326                         _dl_parse_dynamic_info(dpnt, app_tpnt->dynamic_info, debug_addr, app_tpnt->loadaddr);
 327 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
 328                         /* Ugly, ugly.  We need to call mprotect to change the
 329                          * protection of the text pages so that we can do the
 330                          * dynamic linking.  We can set the protection back
 331                          * again once we are done.
 332                          */
 333                         _dl_debug_early("calling mprotect on the application program\n");
 334                         /* Now cover the application program. */
 335                         if (app_tpnt->dynamic_info[DT_TEXTREL]) {
 336                                 ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
 337                                 for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
 338                                         if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W)) {
 339                                                 void *base =  DL_RELOC_ADDR (ppnt->p_vaddr & PAGE_ALIGN, app_tpnt->loadaddr);
 340                                                 _dl_mprotect(base, (ppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) ppnt->p_filesz,
 341                                                              PROT_READ | PROT_WRITE | PROT_EXEC);
 342                                         }
 343                                 }
 344                         }
 345 #endif
 346
 347 #ifndef ALLOW_ZERO_PLTGOT
 348                         /* make sure it's really there. */
 349                         if (app_tpnt->dynamic_info[DT_PLTGOT] == 0)
 350                                 continue;
 351 #endif
 352                         /* OK, we have what we need - slip this one into the list. */
 353                         app_tpnt = _dl_add_elf_hash_table(_dl_progname, app_tpnt->loadaddr,
 354                                                           app_tpnt->dynamic_info,
 355                                                           (unsigned long) DL_RELOC_ADDR (ppnt->p_vaddr, app_tpnt->loadaddr),
 356                                                           ppnt->p_filesz);
 357                         _dl_loaded_modules->libtype = elf_executable;
 358                         _dl_loaded_modules->ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_val;
 359                         _dl_loaded_modules->n_phent = auxvt[AT_PHNUM].a_un.a_val;
 360                         _dl_symbol_tables = rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
 361                         _dl_memset(rpnt, 0, sizeof(struct dyn_elf));
 362                         rpnt->dyn = _dl_loaded_modules;
 363                         app_tpnt->rtld_flags = unlazy | RTLD_GLOBAL;
 364                         app_tpnt->usage_count++;
 365                         app_tpnt->symbol_scope = _dl_symbol_tables;
 366                         lpnt = (unsigned long *) (app_tpnt->dynamic_info[DT_PLTGOT]);
 367 #ifdef ALLOW_ZERO_PLTGOT
 368                         if (lpnt)
 369 #endif
 370                                 INIT_GOT(lpnt, _dl_loaded_modules);
 371                 }
 372
 373                 /* OK, fill this in - we did not have this before */
 374                 if (ppnt->p_type == PT_INTERP) {
 375                         char *ptmp;
 376
 377                         tpnt->libname = (char *) DL_RELOC_ADDR (ppnt->p_vaddr, app_tpnt->loadaddr);
 378
 379                         /* Store the path where the shared lib loader was found
 380                          * for later use
 381                          */
 382                         _dl_ldsopath = _dl_strdup(tpnt->libname);
 383                         ptmp = _dl_strrchr(_dl_ldsopath, '/');
 384                         if (ptmp != _dl_ldsopath)
 385                                 *ptmp = '\0';
 386
 387                         _dl_debug_early("Lib Loader: (%x) %s\n", (unsigned) DL_LOADADDR_BASE (tpnt->loadaddr),
 388                                         tpnt->libname);
 389                 }
 390         }
 391         app_tpnt->relro_addr = relro_addr;
 392         app_tpnt->relro_size = relro_size;
 393
 394 #ifdef __SUPPORT_LD_DEBUG__
 395         _dl_debug = _dl_getenv("LD_DEBUG", envp);
 396         if (_dl_debug) {
 397                 if (_dl_strstr(_dl_debug, "all")) {
 398                         _dl_debug_detail = _dl_debug_move = _dl_debug_symbols
 399                                 = _dl_debug_reloc = _dl_debug_bindings = _dl_debug_nofixups = (void*)1;
 400                 } else {
 401                         _dl_debug_detail   = _dl_strstr(_dl_debug, "detail");
 402                         _dl_debug_move     = _dl_strstr(_dl_debug, "move");
 403                         _dl_debug_symbols  = _dl_strstr(_dl_debug, "sym");
 404                         _dl_debug_reloc    = _dl_strstr(_dl_debug, "reloc");
 405                         _dl_debug_nofixups = _dl_strstr(_dl_debug, "nofix");
 406                         _dl_debug_bindings = _dl_strstr(_dl_debug, "bind");
 407                 }
 408         }
 409
 410         {
 411                 const char *dl_debug_output;
 412
 413                 dl_debug_output = _dl_getenv("LD_DEBUG_OUTPUT", envp);
 414
 415                 if (dl_debug_output) {
 416                         char tmp[22], *tmp1, *filename;
 417                         int len1, len2;
 418
 419                         _dl_memset(tmp, 0, sizeof(tmp));
 420                         tmp1 = _dl_simple_ltoa( tmp, (unsigned long)_dl_getpid());
 421
 422                         len1 = _dl_strlen(dl_debug_output);
 423                         len2 = _dl_strlen(tmp1);
 424
 425                         filename = _dl_malloc(len1+len2+2);
 426
 427                         if (filename) {
 428                                 _dl_strcpy (filename, dl_debug_output);
 429                                 filename[len1] = '.';
 430                                 _dl_strcpy (&filename[len1+1], tmp1);
 431
 432                                 _dl_debug_file= _dl_open(filename, O_WRONLY|O_CREAT, 0644);
 433                                 if (_dl_debug_file < 0) {
 434                                         _dl_debug_file = 2;
 435                                         _dl_dprintf(_dl_debug_file, "can't open file: '%s'\n",filename);
 436                                 }
 437                         }
 438                 }
 439         }
 440 #endif
 441
 442         if (_dl_getenv("LD_TRACE_LOADED_OBJECTS", envp) != NULL) {
 443                 trace_loaded_objects++;
 444         }
 445
 446 #ifndef __LDSO_LDD_SUPPORT__
 447         if (trace_loaded_objects) {
 448                 _dl_dprintf(_dl_debug_file, "Use the ldd provided by uClibc\n");
 449                 _dl_exit(1);
 450         }
 451 #endif
 452
 453         /*
 454          * OK, fix one more thing - set up debug_addr so it will point
 455          * to our chain.  Later we may need to fill in more fields, but this
 456          * should be enough for now.
 457          */
 458         debug_addr->r_map = (struct link_map *) _dl_loaded_modules;
 459         debug_addr->r_version = 1;
 460         debug_addr->r_ldbase = (ElfW(Addr)) DL_LOADADDR_BASE (load_addr);
 461         debug_addr->r_brk = (unsigned long) &_dl_debug_state;
 462         _dl_debug_addr = debug_addr;
 463
 464         /* Notify the debugger we are in a consistant state */
 465         _dl_debug_addr->r_state = RT_CONSISTENT;
 466         _dl_debug_state();
 467
 468         /* OK, we now have the application in the list, and we have some
 469          * basic stuff in place.  Now search through the list for other shared
 470          * libraries that should be loaded, and insert them on the list in the
 471          * correct order.
 472          */
 473
 474         _dl_map_cache();
 475
 476         if (_dl_preload) {
 477                 char c, *str, *str2;
 478
 479                 str = _dl_preload;
 480                 while (*str == ':' || *str == ' ' || *str == '\t')
 481                         str++;
 482
 483                 while (*str) {
 484                         str2 = str;
 485                         while (*str2 && *str2 != ':' && *str2 != ' ' && *str2 != '\t')
 486                                 str2++;
 487                         c = *str2;
 488                         *str2 = '\0';
 489
 490                         if (!_dl_secure || _dl_strchr(str, '/') == NULL) {
 491                                 _dl_if_debug_dprint("\tfile='%s';  needed by '%s'\n", str, _dl_progname);
 492
 493                                 tpnt1 = _dl_load_shared_library(_dl_secure, &rpnt, NULL, str, trace_loaded_objects);
 494                                 if (!tpnt1) {
 495 #ifdef __LDSO_LDD_SUPPORT__
 496                                         if (trace_loaded_objects)
 497                                                 _dl_dprintf(1, "\t%s => not found\n", str);
 498                                         else
 499 #endif
 500                                         {
 501                                                 _dl_dprintf(_dl_debug_file, "%s: can't load " "library '%s'\n", _dl_progname, str);
 502                                                 _dl_exit(15);
 503                                         }
 504                                 } else {
 505                                         tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
 506
 507                                         _dl_debug_early("Loading: (%x) %s\n", (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr), tpnt1->libname);
 508
 509 #ifdef __LDSO_LDD_SUPPORT__
 510                                         if (trace_loaded_objects &&
 511                                             tpnt1->usage_count == 1) {
 512                                                 /* This is a real hack to make
 513                                                  * ldd not print the library
 514                                                  * itself when run on a
 515                                                  * library.
 516                                                  */
 517                                                 if (_dl_strcmp(_dl_progname, str) != 0)
 518                                                         _dl_dprintf(1, "\t%s => %s (%x)\n", str, tpnt1->libname,
 519                                                                     (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr));
 520                                         }
 521 #endif
 522                                 }
 523                         }
 524
 525                         *str2 = c;
 526                         str = str2;
 527                         while (*str == ':' || *str == ' ' || *str == '\t')
 528                                 str++;
 529                 }
 530         }
 531
 532 #ifdef __LDSO_PRELOAD_FILE_SUPPORT__
 533         do {
 534                 struct stat st;
 535                 char *preload;
 536                 int fd;
 537                 char c, *cp, *cp2;
 538
 539                 if (_dl_stat(LDSO_PRELOAD, &st) || st.st_size == 0) {
 540                         break;
 541                 }
 542
 543                 if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY, 0)) < 0) {
 544                         _dl_dprintf(_dl_debug_file, "%s: can't open file '%s'\n",
 545                                     _dl_progname, LDSO_PRELOAD);
 546                         break;
 547                 }
 548
 549                 preload = (caddr_t) _dl_mmap(0, st.st_size + 1,
 550                                              PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
 551                 _dl_close(fd);
 552                 if (preload == (caddr_t) -1) {
 553                         _dl_dprintf(_dl_debug_file, "%s:%i: can't map '%s'\n",
 554                                     _dl_progname, __LINE__, LDSO_PRELOAD);
 555                         break;
 556                 }
 557
 558                 /* convert all separators and comments to spaces */
 559                 for (cp = preload; *cp; /*nada */ ) {
 560                         if (*cp == ':' || *cp == '\t' || *cp == '\n') {
 561                                 *cp++ = ' ';
 562                         } else if (*cp == '#') {
 563                                 do {
 564                                         *cp++ = ' ';
 565                                 } while (*cp != '\n' && *cp != '\0');
 566                         } else {
 567                                 cp++;
 568                         }
 569                 }
 570
 571                 /* find start of first library */
 572                 for (cp = preload; *cp && *cp == ' '; cp++)
 573                         /*nada */ ;
 574
 575                 while (*cp) {
 576                         /* find end of library */
 577                         for (cp2 = cp; *cp && *cp != ' '; cp++)
 578                                 /*nada */ ;
 579                         c = *cp;
 580                         *cp = '\0';
 581
 582                         _dl_if_debug_dprint("\tfile='%s';  needed by '%s'\n", cp2, _dl_progname);
 583
 584                         tpnt1 = _dl_load_shared_library(0, &rpnt, NULL, cp2, trace_loaded_objects);
 585                         if (!tpnt1) {
 586 #ifdef __LDSO_LDD_SUPPORT__
 587                                 if (trace_loaded_objects)
 588                                         _dl_dprintf(1, "\t%s => not found\n", cp2);
 589                                 else
 590 #endif
 591                                 {
 592                                         _dl_dprintf(_dl_debug_file, "%s: can't load library '%s'\n", _dl_progname, cp2);
 593                                         _dl_exit(15);
 594                                 }
 595                         } else {
 596                                 tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
 597
 598                                 _dl_debug_early("Loading: (%x) %s\n", (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr), tpnt1->libname);
 599
 600 #ifdef __LDSO_LDD_SUPPORT__
 601                                 if (trace_loaded_objects &&
 602                                     tpnt1->usage_count == 1) {
 603                                         _dl_dprintf(1, "\t%s => %s (%x)\n",
 604                                                     cp2, tpnt1->libname,
 605                                                     (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr));
 606                                 }
 607 #endif
 608                         }
 609
 610                         /* find start of next library */
 611                         *cp = c;
 612                         for ( /*nada */ ; *cp && *cp == ' '; cp++)
 613                                 /*nada */ ;
 614                 }
 615
 616                 _dl_munmap(preload, st.st_size + 1);
 617         } while (0);
 618 #endif /* __LDSO_PRELOAD_FILE_SUPPORT__ */
 619
 620         nlist = 0;
 621         for (tcurr = _dl_loaded_modules; tcurr; tcurr = tcurr->next) {
 622                 ElfW(Dyn) *this_dpnt;
 623
 624                 nlist++;
 625                 for (this_dpnt = (ElfW(Dyn) *) tcurr->dynamic_addr; this_dpnt->d_tag; this_dpnt++) {
 626                         if (this_dpnt->d_tag == DT_NEEDED) {
 627                                 char *name;
 628                                 struct init_fini_list *tmp;
 629
 630                                 lpntstr = (char*) (tcurr->dynamic_info[DT_STRTAB] + this_dpnt->d_un.d_val);
 631                                 name = _dl_get_last_path_component(lpntstr);
 632                                 if (_dl_strcmp(name, UCLIBC_LDSO) == 0)
 633                                         continue;
 634
 635                                 _dl_if_debug_dprint("\tfile='%s';  needed by '%s'\n", lpntstr, _dl_progname);
 636
 637                                 if (!(tpnt1 = _dl_load_shared_library(0, &rpnt, tcurr, lpntstr, trace_loaded_objects))) {
 638 #ifdef __LDSO_LDD_SUPPORT__
 639                                         if (trace_loaded_objects) {
 640                                                 _dl_dprintf(1, "\t%s => not found\n", lpntstr);
 641                                                 continue;
 642                                         } else
 643 #endif
 644                                         {
 645                                                 _dl_dprintf(_dl_debug_file, "%s: can't load library '%s'\n", _dl_progname, lpntstr);
 646                                                 _dl_exit(16);
 647                                         }
 648                                 }
 649
 650                                 tmp = alloca(sizeof(struct init_fini_list)); /* Allocates on stack, no need to free this memory */
 651                                 tmp->tpnt = tpnt1;
 652                                 tmp->next = tcurr->init_fini;
 653                                 tcurr->init_fini = tmp;
 654
 655                                 tpnt1->rtld_flags = unlazy | RTLD_GLOBAL;
 656
 657                                 _dl_debug_early("Loading: (%x) %s\n", (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr), tpnt1->libname);
 658
 659 #ifdef __LDSO_LDD_SUPPORT__
 660                                 if (trace_loaded_objects &&
 661                                     tpnt1->usage_count == 1) {
 662                                         _dl_dprintf(1, "\t%s => %s (%x)\n",
 663                                                     lpntstr, tpnt1->libname,
 664                                                     (unsigned) DL_LOADADDR_BASE (tpnt1->loadaddr));
 665                                 }
 666 #endif
 667                         }
 668                 }
 669         }
 670         _dl_unmap_cache();
 671
 672         --nlist; /* Exclude the application. */
 673         init_fini_list = _dl_malloc(nlist * sizeof(struct elf_resolve *));
 674         i = 0;
 675         for (tcurr = _dl_loaded_modules->next; tcurr; tcurr = tcurr->next) {
 676                 init_fini_list[i++] = tcurr;
 677         }
 678
 679         /* Sort the INIT/FINI list in dependency order. */
 680         for (tcurr = _dl_loaded_modules->next; tcurr; tcurr = tcurr->next) {
 681                 int j, k;
 682
 683                 for (j = 0; init_fini_list[j] != tcurr; ++j)
 684                         /* Empty */;
 685                 for (k = j + 1; k < nlist; ++k) {
 686                         struct init_fini_list *runp = init_fini_list[k]->init_fini;
 687
 688                         for (; runp; runp = runp->next) {
 689                                 if (runp->tpnt == tcurr) {
 690                                         struct elf_resolve *here = init_fini_list[k];
 691                                         _dl_if_debug_dprint("Move %s from pos %d to %d in INIT/FINI list\n", here->libname, k, j);
 692                                         for (i = (k - j); i; --i)
 693                                                 init_fini_list[i+j] = init_fini_list[i+j-1];
 694                                         init_fini_list[j] = here;
 695                                         ++j;
 696                                         break;
 697                                 }
 698                         }
 699                 }
 700         }
 701 #ifdef __SUPPORT_LD_DEBUG__
 702         if (_dl_debug) {
 703                 _dl_dprintf(_dl_debug_file, "\nINIT/FINI order and dependencies:\n");
 704                 for (i = 0; i < nlist; i++) {
 705                         struct init_fini_list *tmp;
 706
 707                         _dl_dprintf(_dl_debug_file, "lib: %s has deps:\n",
 708                                     init_fini_list[i]->libname);
 709                         tmp = init_fini_list[i]->init_fini;
 710                         for (; tmp; tmp = tmp->next)
 711                                 _dl_dprintf(_dl_debug_file, " %s ", tmp->tpnt->libname);
 712                         _dl_dprintf(_dl_debug_file, "\n");
 713                 }
 714         }
 715 #endif
 716
 717         /*
 718          * If the program interpreter is not in the module chain, add it.
 719          * This will be required for dlopen to be able to access the internal
 720          * functions in the dynamic linker and to relocate the interpreter
 721          * again once all libs are loaded.
 722          */
 723         if (tpnt) {
 724                 ElfW(Ehdr) *epnt = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_val;
 725                 ElfW(Phdr) *myppnt = (ElfW(Phdr) *) DL_RELOC_ADDR (epnt->e_phoff, load_addr);
 726                 int j;
 727
 728                 tpnt = _dl_add_elf_hash_table(tpnt->libname, load_addr,
 729                                               tpnt->dynamic_info,
 730                                               (unsigned long)tpnt->dynamic_addr,
 731                                               0);
 732
 733                 tpnt->n_phent = epnt->e_phnum;
 734                 tpnt->ppnt = myppnt;
 735                 for (j = 0; j < epnt->e_phnum; j++, myppnt++) {
 736                         if (myppnt->p_type ==  PT_GNU_RELRO) {
 737                                 tpnt->relro_addr = myppnt->p_vaddr;
 738                                 tpnt->relro_size = myppnt->p_memsz;
 739                                 break;
 740                         }
 741                 }
 742                 tpnt->libtype = program_interpreter;
 743                 tpnt->usage_count++;
 744                 tpnt->symbol_scope = _dl_symbol_tables;
 745                 if (rpnt) {
 746                         rpnt->next = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
 747                         _dl_memset(rpnt->next, 0, sizeof(struct dyn_elf));
 748                         rpnt->next->prev = rpnt;
 749                         rpnt = rpnt->next;
 750                 } else {
 751                         rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
 752                         _dl_memset(rpnt, 0, sizeof(struct dyn_elf));
 753                 }
 754                 rpnt->dyn = tpnt;
 755                 tpnt->rtld_flags = RTLD_NOW | RTLD_GLOBAL; /* Must not be LAZY */
 756 #ifdef RERELOCATE_LDSO
 757                 /* Only rerelocate functions for now. */
 758                 tpnt->init_flag = RELOCS_DONE;
 759                 lpnt = (unsigned long *) (tpnt->dynamic_info[DT_PLTGOT]);
 760 # ifdef ALLOW_ZERO_PLTGOT
 761                 if (tpnt->dynamic_info[DT_PLTGOT])
 762 # endif
 763                         INIT_GOT(lpnt, tpnt);
 764 #else
 765                 tpnt->init_flag = RELOCS_DONE | JMP_RELOCS_DONE;
 766 #endif
 767                 tpnt = NULL;
 768         }
 769
 770 #ifdef __LDSO_LDD_SUPPORT__
 771         /* End of the line for ldd.... */
 772         if (trace_loaded_objects) {
 773                 _dl_dprintf(1, "\t%s => %s (%x)\n",
 774                             rpnt->dyn->libname + _dl_strlen(_dl_ldsopath) + 1,
 775                             rpnt->dyn->libname, (unsigned) DL_LOADADDR_BASE (rpnt->dyn->loadaddr));
 776                 _dl_exit(0);
 777         }
 778 #endif
 779
 780         _dl_debug_early("Beginning relocation fixups\n");
 781
 782 #ifdef __mips__
 783         /*
 784          * Relocation of the GOT entries for MIPS have to be done
 785          * after all the libraries have been loaded.
 786          */
 787         _dl_perform_mips_global_got_relocations(_dl_loaded_modules, !unlazy);
 788 #endif
 789
 790         /*
 791          * OK, now all of the kids are tucked into bed in their proper
 792          * addresses.  Now we go through and look for REL and RELA records that
 793          * indicate fixups to the GOT tables.  We need to do this in reverse
 794          * order so that COPY directives work correctly.
 795          */
 796         if (_dl_symbol_tables)
 797                 if (_dl_fixup(_dl_symbol_tables, unlazy))
 798                         _dl_exit(-1);
 799
 800         for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
 801                 if (tpnt->relro_size)
 802                         _dl_protect_relro (tpnt);
 803         }
 804
 805         /* OK, at this point things are pretty much ready to run.  Now we need
 806          * to touch up a few items that are required, and then we can let the
 807          * user application have at it.  Note that the dynamic linker itself
 808          * is not guaranteed to be fully dynamicly linked if we are using
 809          * ld.so.1, so we have to look up each symbol individually.
 810          */
 811
 812         _dl_envp = (unsigned long *) (intptr_t) _dl_find_hash("__environ", _dl_symbol_tables, NULL, 0);
 813         if (_dl_envp)
 814                 *_dl_envp = (unsigned long) envp;
 815
 816 #ifndef __FORCE_SHAREABLE_TEXT_SEGMENTS__
 817         {
 818                 unsigned int j;
 819                 ElfW(Phdr) *myppnt;
 820
 821                 /* We had to set the protections of all pages to R/W for
 822                  * dynamic linking.  Set text pages back to R/O.
 823                  */
 824                 for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
 825                         for (myppnt = tpnt->ppnt, j = 0; j < tpnt->n_phent; j++, myppnt++) {
 826                                 if (myppnt->p_type == PT_LOAD && !(myppnt->p_flags & PF_W) && tpnt->dynamic_info[DT_TEXTREL]) {
 827                                         void *base = DL_RELOC_ADDR (myppnt->p_vaddr & PAGE_ALIGN, tpnt->loadaddr);
 828                                         _dl_mprotect(base,
 829                                                      (myppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) myppnt->p_filesz,
 830                                                      LXFLAGS(myppnt->p_flags));
 831                                 }
 832                         }
 833                 }
 834
 835         }
 836 #endif
 837         /* Notify the debugger we have added some objects. */
 838         _dl_debug_addr->r_state = RT_ADD;
 839         _dl_debug_state();
 840
 841         /* Run pre-initialization functions for the executable.  */
 842         _dl_run_array_forward(_dl_loaded_modules->dynamic_info[DT_PREINIT_ARRAY],
 843                               _dl_loaded_modules->dynamic_info[DT_PREINIT_ARRAYSZ],
 844                               _dl_loaded_modules->loadaddr);
 845
 846         /* Run initialization functions for loaded objects.  For the
 847            main executable, they will be run from __uClibc_main.  */
 848         for (i = nlist; i; --i) {
 849                 tpnt = init_fini_list[i-1];
 850                 tpnt->init_fini = NULL; /* Clear, since alloca was used */
 851                 if (tpnt->init_flag & INIT_FUNCS_CALLED)
 852                         continue;
 853                 tpnt->init_flag |= INIT_FUNCS_CALLED;
 854
 855                 if (tpnt->dynamic_info[DT_INIT]) {
 856                         void (*dl_elf_func) (void);
 857
 858                         dl_elf_func = (void (*)(void)) DL_RELOC_ADDR (tpnt->dynamic_info[DT_INIT], tpnt->loadaddr);
 859
 860                         _dl_if_debug_dprint("calling INIT: %s\n\n", tpnt->libname);
 861
 862                         (*dl_elf_func) ();
 863                 }
 864
 865                 _dl_run_init_array(tpnt);
 866         }
 867
 868         /* Find the real malloc function and make ldso functions use that from now on */
 869          _dl_malloc_function = (void* (*)(size_t)) (intptr_t) _dl_find_hash("malloc",
 870                          _dl_symbol_tables, NULL, ELF_RTYPE_CLASS_PLT);
 871
 872         /* Notify the debugger that all objects are now mapped in.  */
 873         _dl_debug_addr->r_state = RT_CONSISTENT;
 874         _dl_debug_state();
 875 }
 876
 877 char *_dl_getenv(const char *symbol, char **envp)
 878 {
 879         char *pnt;
 880         const char *pnt1;
 881
 882         while ((pnt = *envp++)) {
 883                 pnt1 = symbol;
 884                 while (*pnt && *pnt == *pnt1)
 885                         pnt1++, pnt++;
 886                 if (!*pnt || *pnt != '=' || *pnt1)
 887                         continue;
 888                 return pnt + 1;
 889         }
 890         return 0;
 891 }
 892
 893 void _dl_unsetenv(const char *symbol, char **envp)
 894 {
 895         char *pnt;
 896         const char *pnt1;
 897         char **newenvp = envp;
 898
 899         for (pnt = *envp; pnt; pnt = *++envp) {
 900                 pnt1 = symbol;
 901                 while (*pnt && *pnt == *pnt1)
 902                         pnt1++, pnt++;
 903                 if (!*pnt || *pnt != '=' || *pnt1)
 904                         *newenvp++ = *envp;
 905         }
 906         *newenvp++ = *envp;
 907         return;
 908 }
 909
 910 static int _dl_suid_ok(void)
 911 {
 912         __kernel_uid_t uid, euid;
 913         __kernel_gid_t gid, egid;
 914
 915         uid = _dl_getuid();
 916         euid = _dl_geteuid();
 917         gid = _dl_getgid();
 918         egid = _dl_getegid();
 919
 920         if (uid == euid && gid == egid) {
 921                 return 1;
 922         }
 923         return 0;
 924 }
 925
 926 void *_dl_malloc(int size)
 927 {
 928         void *retval;
 929
 930 #if 0
 931         _dl_debug_early("request for %d bytes\n", size);
 932 #endif
 933
 934         if (_dl_malloc_function)
 935                 return (*_dl_malloc_function) (size);
 936
 937         if (_dl_malloc_addr - _dl_mmap_zero + (unsigned)size > _dl_pagesize) {
 938                 _dl_debug_early("mmapping more memory\n");
 939                 _dl_mmap_zero = _dl_malloc_addr = _dl_mmap((void *) 0, size,
 940                                 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 941                 if (_dl_mmap_check_error(_dl_mmap_zero)) {
 942                         _dl_dprintf(_dl_debug_file, "%s: mmap of a spare page failed!\n", _dl_progname);
 943                         _dl_exit(20);
 944                 }
 945         }
 946         retval = _dl_malloc_addr;
 947         _dl_malloc_addr += size;
 948
 949         /*
 950          * Align memory to 4 byte boundary.  Some platforms require this,
 951          * others simply get better performance.
 952          */
 953         _dl_malloc_addr = (unsigned char *) (((unsigned long) _dl_malloc_addr + 3) & ~(3));
 954         return retval;
 955 }
 956
 957 #include "dl-hash.c"
 958 #include "dl-elf.c"