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