123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005 |
- /* Run an ELF binary on a linux system.
- Copyright (C) 1993-1996, Eric Youngdale.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
- /* Program to load an ELF binary on a linux system, and run it.
- * References to symbols in sharable libraries can be resolved by
- * an ELF sharable library. */
- /* Disclaimer: I have never seen any AT&T source code for SVr4, nor have
- I ever taken any courses on internals. This program was developed using
- information available through the book "UNIX SYSTEM V RELEASE 4,
- Programmers guide: Ansi C and Programming Support Tools", which did
- a more than adequate job of explaining everything required to get this
- working. */
- /*
- * The main trick with this program is that initially, we ourselves are not
- * dynamicly linked. This means that we cannot access any global variables
- * since the GOT is initialized by the linker assuming a virtual address of 0,
- * and we cannot call any functions since the PLT is not initialized at all
- * (it will tend to want to call the dynamic linker
- *
- * There are further restrictions - we cannot use large switch statements,
- * since the compiler generates tables of addresses and jumps through them.
- * We can use inline functions, because these do not transfer control to
- * a new address, but they must be static so that they are not exported
- * from the modules. We cannot use normal syscall stubs, because these
- * all reference the errno global variable which is not yet initialized.
- * We can use all of the local stack variables that we want, since these
- * are all referenced to %ebp or %esp.
- *
- * Life is further complicated by the fact that initially we do not want
- * to do a complete dynamic linking. We want to allow the user to supply
- * new functions replacing some of the library versions, and until we have
- * the list of modules that we should search set up, we do not want to do
- * any of this. Thus I have chosen to only perform the relocations for
- * variables that start with "_dl_" since ANSI specifies that the user is
- * not supposed to redefine any of these variables.
- *
- * Fortunately, the linker itself leaves a few clues lying around, and
- * when the kernel starts the image, there are a few further clues.
- * First of all, there is information buried on the stack that the kernel
- * leaves, which includes information about the load address that the
- * program interpreter was loaded at, the number of sections, the address
- * the application was loaded at and so forth. Here this information
- * is stored in the array dl_info, and the indicies are taken from the
- * file /usr/include/sys/auxv.h on any SVr4 system.
- *
- * The linker itself leaves a pointer to the .dynamic section in the first
- * slot of the GOT, and as it turns out, %ebx points to ghe GOT when
- * you are using PIC code, so we just dereference this to get the address
- * of the dynamic sections.
- *
- * Typically you must load all text pages as writable so that dynamic linking
- * can succeed. The kernel under SVr4 loads these as R/O, so we must call
- * mprotect to change the protections. Once we are done, we should set these
- * back again, so the desired behavior is achieved. Under linux there is
- * currently no mprotect function in the distribution kernel (although
- * someone has alpha patches), so for now everything is loaded writable.
- *
- * We do not have access to malloc and friends at the initial stages of dynamic
- * linking, and it would be handy to have some scratchpad memory available
- * for use as we set things up. It is a bit of a kluge, but we mmap /dev/zero
- * to get one page of scratchpad. A simpleminded _dl_malloc is provided so
- * that we have some memory that can be used for this purpose. Typically
- * we would not want to use the same memory pool as malloc anyway - the user
- * might want to redefine malloc for example.
- *
- * Our first task is to perform a minimal linking so that we can call other
- * portions of the dynamic linker. Once we have done this, we then build
- * the list of modules that the application requires, using LD_LIBRARY_PATH
- * if this is not a suid program (/usr/lib otherwise). Once this is done,
- * we can do the dynamic linking as required (and we must omit the things
- * we did to get the dynamic linker up and running in the first place.
- * After we have done this, we just have a few housekeeping chores and we
- * can transfer control to the user's application.
- */
- #include <stdarg.h>
- #include <linux/types.h>
- #include <linux/fcntl.h>
- #include <linux/unistd.h>
- #include <linux/elf.h>
- #include <linux/mman.h>
- #include "link.h"
- #include "sysdep.h"
- #include "hash.h"
- #include "linuxelf.h"
- #include "syscall.h"
- #include "string.h"
- #include "../config.h"
- #define ALLOW_ZERO_PLTGOT
- static char * _dl_malloc_addr, *_dl_mmap_zero;
- char * _dl_library_path = 0; /* Where we look for libraries */
- char *_dl_preload = 0; /* Things to be loaded before the libs. */
- char *_dl_progname = "/lib/ld-linux-uclibc.so.1";
- static char * _dl_not_lazy = 0;
- static char * _dl_warn = 0; /* Used by ldd */
- static char * _dl_trace_loaded_objects = 0;
- static int (*_dl_elf_main)(int, char **, char**);
- static int (*_dl_elf_init)(void);
- void * (*_dl_malloc_function)(int size) = NULL;
- struct r_debug * _dl_debug_addr = NULL;
- unsigned int * _dl_brkp;
- unsigned int * _dl_envp;
- #define DL_MALLOC(SIZE) ((void *) (malloc_buffer += SIZE, malloc_buffer - SIZE))
- /*
- * Make sure that the malloc buffer is aligned on 4 byte boundary. For 64 bit
- * platforms we may need to increase this to 8, but this is good enough for
- * now. This is typically called after DL_MALLOC.
- */
- #define REALIGN() malloc_buffer = (char *) (((unsigned int) malloc_buffer + 3) & ~(3))
- #define ELF_HASH(RESULT,NAME) { \
- unsigned long hash = 0; \
- unsigned long tmp; \
- char * name = NAME; \
- while (*name){ \
- hash = (hash << 4) + *name++; \
- if((tmp = hash & 0xf0000000)) hash ^= tmp >> 24; \
- hash &= ~tmp; \
- } \
- RESULT = hash; \
- }
- extern int _dl_linux_resolve(void);
- extern int _dl_interpreter_exit(int);
- extern char * _dl_strdup(const char *);
- extern char * _dl_getenv(char * symbol, char ** envp);
- extern void _dl_unsetenv(char * symbol, char ** envp);
- extern int _dl_fixup(struct elf_resolve * tpnt);
- /*
- * Datatype of a relocation on this platform
- */
- #ifdef ELF_USES_RELOCA
- typedef struct elf32_rela ELF_RELOC;
- #else
- typedef struct elf32_rel ELF_RELOC;
- #endif
- /*
- * This stub function is used by some debuggers. The idea is that they
- * can set an internal breakpoint on it, so that we are notified when the
- * address mapping is changed in some way.
- */
- void _dl_debug_state()
- {
- return;
- }
- void _dl_boot(int args);
- void _dl_boot(int args){
- unsigned int argc;
- char ** argv, ** envp;
- int status;
- unsigned int load_addr;
- unsigned int * got;
- unsigned int * aux_dat;
- int goof = 0;
- struct elfhdr * header;
- struct elf_resolve * tpnt;
- struct dyn_elf * rpnt;
- struct elf_resolve * app_tpnt;
- unsigned int brk_addr;
- unsigned int dl_data[AT_EGID+1];
- unsigned char * malloc_buffer, *mmap_zero;
- int (*_dl_atexit)(void *);
- int * lpnt;
- struct dynamic * dpnt;
- unsigned int *hash_addr;
- struct r_debug * debug_addr;
- unsigned int *chains;
- int indx;
- int _dl_secure;
- /* First obtain the information on the stack that tells us more about
- what binary is loaded, where it is loaded, etc, etc */
- GET_ARGV(aux_dat, args);
- argc = *(aux_dat - 1);
- argv = (char **) aux_dat;
- aux_dat += argc; /* Skip over the argv pointers */
- aux_dat++; /* Skip over NULL at end of argv */
- envp = (char **) aux_dat;
- while(*aux_dat) aux_dat++; /* Skip over the envp pointers */
- aux_dat++; /* Skip over NULL at end of envp */
- dl_data[AT_UID] = -1; /* check later to see if it is changed */
- while(*aux_dat)
- {
- unsigned int * ad1;
- ad1 = aux_dat + 1;
- if( *aux_dat <= AT_EGID ) dl_data[*aux_dat] = *ad1;
- aux_dat += 2;
- }
- /* Next, locate the GOT */
- load_addr = dl_data[AT_BASE];
- GET_GOT(got);
- dpnt = (struct dynamic *) (*got + load_addr);
-
- /* OK, time for another hack. Now call mmap to get a page of writable
- memory that can be used for a temporary malloc. We do not know brk
- yet, so we cannot use real malloc. */
- {
- /* This hack is to work around a suspected asm bug in gcc-2.7.0 */
- int zfileno;
- #define ZFILENO ((-1 & (~zfileno)) | zfileno)
- /*#define ZFILENO -1*/
- #ifndef MAP_ANONYMOUS
- #ifdef __sparc__
- #define MAP_ANONYMOUS 0x20
- #else
- #error MAP_ANONYMOUS not defined and suplementary value not known
- #endif
- #endif
- /* See if we need to relocate this address */
- mmap_zero = malloc_buffer = (unsigned char *) _dl_mmap((void*) 0, 4096,
- PROT_READ | PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, ZFILENO, 0);
- if(_dl_mmap_check_error(mmap_zero)) {
- SEND_STDERR("dl_boot: mmap of /dev/zero failed!\n");
- _dl_exit(13);
- }
- }
- tpnt = DL_MALLOC(sizeof(struct elf_resolve));
- REALIGN();
- _dl_memset (tpnt, 0, sizeof (*tpnt));
- app_tpnt = DL_MALLOC(sizeof(struct elf_resolve));
- REALIGN();
- _dl_memset (app_tpnt, 0, sizeof (*app_tpnt));
- /*
- * This is used by gdb to locate the chain of shared libraries that are currently loaded.
- */
- debug_addr = DL_MALLOC(sizeof(struct r_debug));
- REALIGN();
- _dl_memset (debug_addr, 0, sizeof (*debug_addr));
- /* OK, that was easy. Next scan the DYNAMIC section of the image.
- We are only doing ourself right now - we will have to do the rest later */
- while(dpnt->d_tag)
- {
- tpnt->dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
- if(dpnt->d_tag == DT_TEXTREL ||
- SVR4_BUGCOMPAT) tpnt->dynamic_info[DT_TEXTREL] = 1;
- dpnt++;
- }
- {
- struct elf_phdr * ppnt;
- int i;
-
- ppnt = (struct elf_phdr *) dl_data[AT_PHDR];
- for(i=0; i<dl_data[AT_PHNUM]; i++, ppnt++)
- if(ppnt->p_type == PT_DYNAMIC) {
- dpnt = (struct dynamic *) ppnt->p_vaddr;
- while(dpnt->d_tag)
- {
- if(dpnt->d_tag > DT_JMPREL) {dpnt++; continue; }
- app_tpnt->dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
- if(dpnt->d_tag == DT_DEBUG) dpnt->d_un.d_val = (int) debug_addr;
- if(dpnt->d_tag == DT_TEXTREL ||
- SVR4_BUGCOMPAT) app_tpnt->dynamic_info[DT_TEXTREL] = 1;
- dpnt++;
- }
- }
- }
- /* Get some more of the information that we will need to dynamicly link
- this module to itself */
- hash_addr = (unsigned int *) (tpnt->dynamic_info[DT_HASH]+load_addr);
- tpnt->nbucket = *hash_addr++;
- tpnt->nchain = *hash_addr++;
- tpnt->elf_buckets = hash_addr;
- hash_addr += tpnt->nbucket;
- chains = hash_addr;
- /* Ugly, ugly. We need to call mprotect to change the protection of
- the text pages so that we can do the dynamic linking. We can set the
- protection back again once we are done */
- {
- struct elf_phdr * ppnt;
- int i;
- /* First cover the shared library/dynamic linker. */
- if(tpnt->dynamic_info[DT_TEXTREL]) {
- header = (struct elfhdr *) dl_data[AT_BASE];
- ppnt = (struct elf_phdr *) (dl_data[AT_BASE] + header->e_phoff);
- for(i=0; i<header->e_phnum ; i++, ppnt++) {
- if(ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W))
- _dl_mprotect((void *) (load_addr + (ppnt->p_vaddr & 0xfffff000)),
- (ppnt->p_vaddr & 0xfff) + (unsigned int) ppnt->p_filesz,
- PROT_READ | PROT_WRITE | PROT_EXEC);
- }
- }
-
- /* Now cover the application program. */
- if(app_tpnt->dynamic_info[DT_TEXTREL]) {
- ppnt = (struct elf_phdr *) dl_data[AT_PHDR];
- for(i=0; i<dl_data[AT_PHNUM]; i++, ppnt++) {
- if(ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W))
- _dl_mprotect((void *) (ppnt->p_vaddr & 0xfffff000),
- (ppnt->p_vaddr & 0xfff) + (unsigned int) ppnt->p_filesz,
- PROT_READ | PROT_WRITE | PROT_EXEC);
- }
- }
- }
- /* OK, now do the relocations. We do not do a lazy binding here, so
- that once we are done, we have considerably more flexibility. */
- goof = 0;
- for(indx=0; indx < 2; indx++)
- {
- int i;
- ELF_RELOC * rpnt;
- unsigned int * reloc_addr;
- unsigned int symbol_addr;
- int symtab_index;
- unsigned int rel_addr, rel_size;
-
- #ifdef ELF_USES_RELOCA
- rel_addr = (indx ? tpnt->dynamic_info[DT_JMPREL] : tpnt->dynamic_info[DT_RELA]);
- rel_size = (indx ? tpnt->dynamic_info[DT_PLTRELSZ] : tpnt->dynamic_info[DT_RELASZ]);
- #else
- rel_addr = (indx ? tpnt->dynamic_info[DT_JMPREL] : tpnt->dynamic_info[DT_REL]);
- rel_size = (indx ? tpnt->dynamic_info[DT_PLTRELSZ] : tpnt->dynamic_info[DT_RELSZ]);
- #endif
- if(!rel_addr) continue;
- /* Now parse the relocation information */
- rpnt = (ELF_RELOC *) (rel_addr + load_addr);
- for(i=0; i< rel_size; i+=sizeof(ELF_RELOC), rpnt++){
- reloc_addr = (int *) (load_addr + (int)rpnt->r_offset);
- symtab_index = ELF32_R_SYM(rpnt->r_info);
- symbol_addr = 0;
- if(symtab_index) {
- char * strtab;
- struct elf32_sym * symtab;
- symtab = (struct elf32_sym *) (tpnt->dynamic_info[DT_SYMTAB]+load_addr);
- strtab = (char *) (tpnt->dynamic_info[DT_STRTAB]+load_addr);
- /* We only do a partial dynamic linking right now. The user
- is not supposed to redefine any symbols that start with
- a '_', so we can do this with confidence. */
- if (!_dl_symbol(strtab + symtab[symtab_index].st_name)) continue;
- symbol_addr = load_addr + symtab[symtab_index].st_value;
- if(!symbol_addr) {
- /*
- * This will segfault - you cannot call a function until
- * we have finished the relocations.
- */
- SEND_STDERR("ELF dynamic loader - unable to self-bootstrap - symbol ");
- SEND_STDERR(strtab + symtab[symtab_index].st_name);
- SEND_STDERR(" undefined.\n");
- goof++;
- }
- }
- /*
- * Use this machine-specific macro to perform the actual relocation.
- */
- PERFORM_BOOTSTRAP_RELOC(rpnt, reloc_addr, symbol_addr, load_addr);
- }
- }
- if (goof) _dl_exit(14);
- /* OK, at this point we have a crude malloc capability. Start to build
- the tables of the modules that are required for this beast to run.
- We start with the basic executable, and then go from there. Eventually
- we will run across ourself, and we will need to properly deal with that
- as well. */
- _dl_malloc_addr = malloc_buffer;
- _dl_mmap_zero = mmap_zero;
- /* tpnt = _dl_malloc(sizeof(struct elf_resolve)); */
- /* Now we have done the mandatory linking of some things. We are now
- free to start using global variables, since these things have all been
- fixed up by now. Still no function calls outside of this library ,
- since the dynamic resolver is not yet ready. */
- lpnt = (int *) (tpnt->dynamic_info[DT_PLTGOT] + load_addr);
- INIT_GOT(lpnt, tpnt);
- /* OK, this was a big step, now we need to scan all of the user images
- and load them properly. */
- tpnt->next = 0;
- tpnt->libname = 0;
- tpnt->libtype = program_interpreter;
- { struct elfhdr * epnt;
- struct elf_phdr * ppnt;
- int i;
- epnt = (struct elfhdr *) dl_data[AT_BASE];
- tpnt->n_phent = epnt->e_phnum;
- tpnt->ppnt = ppnt = (struct elf_phdr *) (load_addr + epnt->e_phoff);
- for(i=0;i < epnt->e_phnum; i++, ppnt++){
- if(ppnt->p_type == PT_DYNAMIC) {
- tpnt->dynamic_addr = ppnt->p_vaddr + load_addr;
- tpnt->dynamic_size = ppnt->p_filesz;
- }
- }
- }
- tpnt->chains = chains;
- tpnt->loadaddr = (char *) load_addr;
- brk_addr = 0;
- rpnt = NULL;
- /* At this point we are now free to examine the user application,
- and figure out which libraries are supposed to be called. Until
- we have this list, we will not be completely ready for dynamic linking */
- {
- struct elf_phdr * ppnt;
- int i;
- ppnt = (struct elf_phdr *) dl_data[AT_PHDR];
- for(i=0; i<dl_data[AT_PHNUM]; i++, ppnt++) {
- if(ppnt->p_type == PT_LOAD) {
- if(ppnt->p_vaddr + ppnt->p_memsz > brk_addr)
- brk_addr = ppnt->p_vaddr + ppnt->p_memsz;
- }
- if(ppnt->p_type == PT_DYNAMIC) {
- #ifndef ALLOW_ZERO_PLTGOT
- /* make sure it's really there. */
- if (app_tpnt->dynamic_info[DT_PLTGOT] == 0) continue;
- #endif
- /* OK, we have what we need - slip this one into the list. */
- app_tpnt = _dl_add_elf_hash_table("", 0,
- app_tpnt->dynamic_info, ppnt->p_vaddr, ppnt->p_filesz);
- _dl_loaded_modules->libtype = elf_executable;
- _dl_loaded_modules->ppnt = (struct elf_phdr *) dl_data[AT_PHDR];
- _dl_loaded_modules->n_phent = dl_data[AT_PHNUM];
- _dl_symbol_tables = rpnt =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt, 0, sizeof (*rpnt));
- rpnt->dyn = _dl_loaded_modules;
- app_tpnt->usage_count++;
- app_tpnt->symbol_scope = _dl_symbol_tables;
- lpnt = (int *) (app_tpnt->dynamic_info[DT_PLTGOT]);
- #ifdef ALLOW_ZERO_PLTGOT
- if (lpnt)
- #endif
- INIT_GOT(lpnt, _dl_loaded_modules);
- }
- if(ppnt->p_type == PT_INTERP) { /* OK, fill this in - we did not have
- this before */
- tpnt->libname = _dl_strdup((char *) ppnt->p_offset +(dl_data[AT_PHDR] & 0xfffff000));
- }
- }
- }
- if (argv[0])
- _dl_progname = argv[0];
- /* Now we need to figure out what kind of options are selected.
- Note that for SUID programs we ignore the settings in LD_LIBRARY_PATH */
- {
- _dl_not_lazy = _dl_getenv("LD_BIND_NOW",envp);
- if ( (dl_data[AT_UID] == -1 && _dl_suid_ok()) ||
- (dl_data[AT_UID] != -1 && dl_data[AT_UID] == dl_data[AT_EUID] &&
- dl_data[AT_GID] == dl_data[AT_EGID]))
- {
- _dl_secure = 0;
- _dl_preload = _dl_getenv("LD_PRELOAD", envp);
- _dl_library_path = _dl_getenv("LD_LIBRARY_PATH",envp);
- }
- else
- {
- _dl_secure = 1;
- _dl_preload = _dl_getenv("LD_PRELOAD", envp);
- _dl_unsetenv("LD_AOUT_PRELOAD", envp);
- _dl_unsetenv("LD_LIBRARY_PATH", envp);
- _dl_unsetenv("LD_AOUT_LIBRARY_PATH", envp);
- _dl_library_path = NULL;
- }
- }
- _dl_trace_loaded_objects = _dl_getenv("LD_TRACE_LOADED_OBJECTS", envp);
- /* OK, we now have the application in the list, and we have some
- basic stuff in place. Now search through the list for other shared
- libraries that should be loaded, and insert them on the list in the
- correct order. */
- #ifdef USE_CACHE
- _dl_map_cache();
- #endif
- {
- struct elf_resolve *tcurr;
- struct elf_resolve *tpnt1;
- char *lpnt;
- if (_dl_preload) {
- char c, *str, *str2;
- str = _dl_preload;
- while (*str == ':' || *str == ' ' || *str == '\t')
- str++;
- while (*str) {
- str2 = str;
- while (*str2 && *str2 != ':' && *str2 != ' ' && *str2 != '\t')
- str2++;
- c = *str2;
- *str2 = '\0';
- if (!_dl_secure || _dl_strchr(str, '/') == NULL) {
- tpnt1 = _dl_load_shared_library(_dl_secure, NULL, str);
- if (!tpnt1) {
- if (_dl_trace_loaded_objects)
- _dl_fdprintf(1, "\t%s => not found\n", str);
- else {
- _dl_fdprintf(2, "%s: can't load library '%s'\n",
- _dl_progname, str);
- _dl_exit(15);
- }
- } else {
- if (_dl_trace_loaded_objects && !tpnt1->usage_count) {
- /* this is a real hack to make ldd not print the
- library itself when run on a library. */
- if (_dl_strcmp(_dl_progname, str) != 0)
- _dl_fdprintf(1, "\t%s => %s (0x%x)\n", str, tpnt1->libname,
- (unsigned)tpnt1->loadaddr);
- }
- rpnt->next =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt->next, 0, sizeof (*(rpnt->next)));
- rpnt = rpnt->next;
- tpnt1->usage_count++;
- tpnt1->symbol_scope = _dl_symbol_tables;
- tpnt1->libtype = elf_lib;
- rpnt->dyn = tpnt1;
- }
- }
- *str2 = c;
- str = str2;
- while (*str == ':' || *str == ' ' || *str == '\t')
- str++;
- }
- }
- {
- int fd;
- struct kernel_stat st;
- char *preload;
- if (!_dl_stat(LDSO_PRELOAD, &st)) {
- if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY)) < 0) {
- _dl_fdprintf(2, "%s: can't open file '%s'\n", _dl_progname,
- LDSO_PRELOAD);
- } else {
- preload = (caddr_t)_dl_mmap(0, st.st_size+1, PROT_READ|PROT_WRITE,
- MAP_PRIVATE, fd, 0);
- _dl_close (fd);
- if (preload == (caddr_t)-1) {
- _dl_fdprintf(2, "%s: can't map file '%s'\n", _dl_progname,
- LDSO_PRELOAD);
- } else {
- char c, *cp, *cp2;
- /* convert all separators and comments to spaces */
- for (cp = preload; *cp; /*nada*/) {
- if (*cp == ':' || *cp == '\t' || *cp == '\n') {
- *cp++ = ' ';
- } else if (*cp == '#') {
- do
- *cp++ = ' ';
- while (*cp != '\n' && *cp != '\0');
- } else {
- cp++;
- }
- }
- /* find start of first library */
- for (cp = preload; *cp && *cp == ' '; cp++)
- /*nada*/;
- while (*cp) {
- /* find end of library */
- for (cp2 = cp; *cp && *cp != ' '; cp++)
- /*nada*/;
- c = *cp;
- *cp = '\0';
- tpnt1 = _dl_load_shared_library(0, NULL, cp2);
- if (!tpnt1) {
- if (_dl_trace_loaded_objects)
- _dl_fdprintf(1, "\t%s => not found\n", cp2);
- else {
- _dl_fdprintf(2, "%s: can't load library '%s'\n",
- _dl_progname, cp2);
- _dl_exit(15);
- }
- } else {
- if (_dl_trace_loaded_objects && !tpnt1->usage_count)
- _dl_fdprintf(1, "\t%s => %s (0x%x)\n", cp2, tpnt1->libname,
- (unsigned)tpnt1->loadaddr);
- rpnt->next =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt->next, 0, sizeof (*(rpnt->next)));
- rpnt = rpnt->next;
- tpnt1->usage_count++;
- tpnt1->symbol_scope = _dl_symbol_tables;
- tpnt1->libtype = elf_lib;
- rpnt->dyn = tpnt1;
- }
- /* find start of next library */
- *cp = c;
- for (/*nada*/; *cp && *cp == ' '; cp++)
- /*nada*/;
- }
- _dl_munmap(preload, st.st_size+1);
- }
- }
- }
- }
- for (tcurr = _dl_loaded_modules; tcurr; tcurr = tcurr->next)
- {
- for (dpnt = (struct dynamic *)tcurr->dynamic_addr; dpnt->d_tag; dpnt++)
- {
- if(dpnt->d_tag == DT_NEEDED)
- {
- lpnt = tcurr->loadaddr + tcurr->dynamic_info[DT_STRTAB] +
- dpnt->d_un.d_val;
- if (tpnt && _dl_strcmp(lpnt, tpnt->libname) == 0)
- {
- struct elf_resolve * ttmp;
- ttmp = _dl_loaded_modules;
- while (ttmp->next)
- ttmp = ttmp->next;
- ttmp->next = tpnt;
- tpnt->prev = ttmp;
- tpnt->next = NULL;
- rpnt->next =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt->next, 0, sizeof (*(rpnt->next)));
- rpnt = rpnt->next;
- rpnt->dyn = tpnt;
- tpnt->usage_count++;
- tpnt->symbol_scope = _dl_symbol_tables;
- tpnt = NULL;
- continue;
- }
- if (!(tpnt1 = _dl_load_shared_library(0, tcurr, lpnt)))
- {
- if (_dl_trace_loaded_objects)
- _dl_fdprintf(1, "\t%s => not found\n", lpnt);
- else
- {
- _dl_fdprintf(2, "%s: can't load library '%s'\n",
- _dl_progname, lpnt);
- _dl_exit(16);
- }
- }
- else
- {
- if (_dl_trace_loaded_objects && !tpnt1->usage_count)
- _dl_fdprintf(1, "\t%s => %s (0x%x)\n", lpnt, tpnt1->libname,
- (unsigned)tpnt1->loadaddr);
- rpnt->next =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt->next, 0, sizeof (*(rpnt->next)));
- rpnt = rpnt->next;
- tpnt1->usage_count++;
- tpnt1->symbol_scope = _dl_symbol_tables;
- tpnt1->libtype = elf_lib;
- rpnt->dyn = tpnt1;
- }
- }
- }
- }
- }
- #ifdef USE_CACHE
- _dl_unmap_cache();
- #endif
- /* ldd uses uses this. I am not sure how you pick up the other flags */
- if(_dl_trace_loaded_objects)
- {
- _dl_warn = _dl_getenv("LD_WARN", envp);
- if (!_dl_warn) _dl_exit(0);
- }
- /*
- * If the program interpreter is not in the module chain, add it. This will
- * be required for dlopen to be able to access the internal functions in the
- * dynamic linker.
- */
- if(tpnt) {
- struct elf_resolve * tcurr;
- tcurr = _dl_loaded_modules;
- if (tcurr)
- while(tcurr->next) tcurr = tcurr->next;
- tpnt->next = NULL;
- tpnt->usage_count++;
- if (tcurr) {
- tcurr->next = tpnt;
- tpnt->prev = tcurr;
- }
- else {
- _dl_loaded_modules = tpnt;
- tpnt->prev = NULL;
- }
- if (rpnt) {
- rpnt->next =
- (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt->next, 0, sizeof (*(rpnt->next)));
- rpnt = rpnt->next;
- } else {
- rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
- _dl_memset (rpnt, 0, sizeof (*(rpnt->next)));
- }
- rpnt->dyn = tpnt;
- tpnt = NULL;
- }
- /*
- * OK, now all of the kids are tucked into bed in their proper addresses.
- * Now we go through and look for REL and RELA records that indicate fixups
- * to the GOT tables. We need to do this in reverse order so that COPY
- * directives work correctly */
- goof = _dl_loaded_modules ? _dl_fixup(_dl_loaded_modules) : 0;
- /* Some flavors of SVr4 do not generate the R_*_COPY directive,
- and we have to manually search for entries that require fixups.
- Solaris gets this one right, from what I understand. */
- if (_dl_symbol_tables)
- goof += _dl_copy_fixups(_dl_symbol_tables);
- if(goof || _dl_trace_loaded_objects) _dl_exit(0);
- /* OK, at this point things are pretty much ready to run. Now we
- need to touch up a few items that are required, and then
- we can let the user application have at it. Note that
- the dynamic linker itself is not guaranteed to be fully
- dynamicly linked if we are using ld.so.1, so we have to look
- up each symbol individually. */
- _dl_brkp = (unsigned int *) _dl_find_hash("___brk_addr", NULL, 1, NULL, 0);
- if (_dl_brkp) *_dl_brkp = brk_addr;
- _dl_envp = (unsigned int *) _dl_find_hash("__environ", NULL, 1, NULL, 0);
- if (_dl_envp) *_dl_envp = (unsigned int) envp;
- {
- int i;
- struct elf_phdr * ppnt;
- /* We had to set the protections of all pages to R/W for dynamic linking.
- Set text pages back to R/O */
- for(tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next)
- for(ppnt = tpnt->ppnt, i=0; i < tpnt->n_phent; i++, ppnt++)
- if(ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W) &&
- tpnt->dynamic_info[DT_TEXTREL])
- _dl_mprotect((void *) (tpnt->loadaddr + (ppnt->p_vaddr & 0xfffff000)),
- (ppnt->p_vaddr & 0xfff) + (unsigned int) ppnt->p_filesz,
- LXFLAGS(ppnt->p_flags));
- }
- _dl_atexit = (int (*)(void *)) _dl_find_hash("atexit", NULL, 1, NULL, 0);
- /*
- * OK, fix one more thing - set up the debug_addr structure to point
- * to our chain. Later we may need to fill in more fields, but this
- * should be enough for now.
- */
- debug_addr->r_map = (struct link_map *) _dl_loaded_modules;
- debug_addr->r_version = 1;
- debug_addr->r_ldbase = load_addr;
- debug_addr->r_brk = (unsigned long) &_dl_debug_state;
- _dl_debug_addr = debug_addr;
- debug_addr->r_state = RT_CONSISTENT;
- /* This is written in this funny way to keep gcc from inlining the
- function call. */
- ((void (*)(void))debug_addr->r_brk)();
- for(tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next)
- {
- /* Apparently crt1 for the application is responsible for handling this.
- * We only need to run the init/fini for shared libraries
- */
- if (tpnt->libtype == program_interpreter ||
- tpnt->libtype == elf_executable) continue;
- if (tpnt->init_flag & INIT_FUNCS_CALLED) continue;
- tpnt->init_flag |= INIT_FUNCS_CALLED;
-
- if(tpnt->dynamic_info[DT_INIT]) {
- _dl_elf_init = (int (*)(void)) (tpnt->loadaddr +
- tpnt->dynamic_info[DT_INIT]);
- (*_dl_elf_init)();
- }
- if(_dl_atexit && tpnt->dynamic_info[DT_FINI])
- {
- (*_dl_atexit)(tpnt->loadaddr + tpnt->dynamic_info[DT_FINI]);
- }
- #undef DL_DEBUG
- #ifdef DL_DEBUG
- else
- {
- _dl_fdprintf(2, tpnt->libname);
- _dl_fdprintf(2, ": ");
- if (!_dl_atexit)
- _dl_fdprintf(2, "The address is atexit () is 0x0.");
- if (!tpnt->dynamic_info[DT_FINI])
- _dl_fdprintf(2, "Invalid .fini section.");
- _dl_fdprintf(2, "\n");
- }
- #endif
- #undef DL_DEBUG
- }
- /* OK we are done here. Turn out the lights, and lock up. */
- _dl_elf_main = (int (*)(int, char**, char**)) dl_data[AT_ENTRY];
- /*
- * Transfer control to the application.
- */
- START();
- }
- int _dl_fixup(struct elf_resolve * tpnt)
- {
- int goof = 0;
- if(tpnt->next) goof += _dl_fixup(tpnt->next);
- if(tpnt->dynamic_info[DT_REL]) {
- #ifdef ELF_USES_RELOCA
- _dl_fdprintf(2, "%s: can't handle REL relocation records\n", _dl_progname);
- _dl_exit(17);
- #else
- if (tpnt->init_flag & RELOCS_DONE) return goof;
- tpnt->init_flag |= RELOCS_DONE;
-
- goof += _dl_parse_relocation_information(tpnt, tpnt->dynamic_info[DT_REL],
- tpnt->dynamic_info[DT_RELSZ], 0);
- #endif
- }
- if(tpnt->dynamic_info[DT_RELA]) {
- #ifdef ELF_USES_RELOCA
- if (tpnt->init_flag & RELOCS_DONE) return goof;
- tpnt->init_flag |= RELOCS_DONE;
-
- goof += _dl_parse_relocation_information(tpnt, tpnt->dynamic_info[DT_RELA],
- tpnt->dynamic_info[DT_RELASZ], 0);
- #else
- _dl_fdprintf(2, "%s: can't handle RELA relocation records\n", _dl_progname);
- _dl_exit(18);
- #endif
- }
- if(tpnt->dynamic_info[DT_JMPREL])
- {
- if (tpnt->init_flag & JMP_RELOCS_DONE) return goof;
- tpnt->init_flag |= JMP_RELOCS_DONE;
-
- if(! _dl_not_lazy || *_dl_not_lazy == 0)
- _dl_parse_lazy_relocation_information(tpnt, tpnt->dynamic_info[DT_JMPREL],
- tpnt->dynamic_info[DT_PLTRELSZ], 0);
- else
- goof += _dl_parse_relocation_information(tpnt,
- tpnt->dynamic_info[DT_JMPREL],
- tpnt->dynamic_info[DT_PLTRELSZ], 0);
- }
- return goof;
- }
- void * _dl_malloc(int size) {
- void * retval;
- if(_dl_malloc_function)
- return (*_dl_malloc_function)(size);
- if(_dl_malloc_addr-_dl_mmap_zero+size>4096) {
- _dl_mmap_zero = _dl_malloc_addr = (unsigned char *) _dl_mmap((void*) 0, size,
- PROT_READ | PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
- if(_dl_mmap_check_error(_dl_mmap_zero)) {
- _dl_fdprintf(2, "%s: can't map '/dev/zero'\n", _dl_progname);
- _dl_exit(20);
- }
- }
- retval = _dl_malloc_addr;
- _dl_malloc_addr += size;
- /*
- * Align memory to 4 byte boundary. Some platforms require this, others
- * simply get better performance.
- */
- _dl_malloc_addr = (char *) (((unsigned int) _dl_malloc_addr + 3) & ~(3));
- return retval;
- }
- char * _dl_getenv(char *symbol, char **envp)
- {
- char *pnt;
- char *pnt1;
- while ((pnt = *envp++)) {
- pnt1 = symbol;
- while (*pnt && *pnt == *pnt1)
- pnt1++, pnt++;
- if (!*pnt || *pnt != '=' || *pnt1)
- continue;
- return pnt+1;
- }
- return 0;
- }
- void _dl_unsetenv(char *symbol, char **envp)
- {
- char *pnt;
- char *pnt1;
- char **newenvp = envp;
- for (pnt = *envp; pnt; pnt = *++envp) {
- pnt1 = symbol;
- while (*pnt && *pnt == *pnt1)
- pnt1++, pnt++;
- if(!*pnt || *pnt != '=' || *pnt1)
- *newenvp++ = *envp;
- }
- *newenvp++ = *envp;
- return;
- }
- char * _dl_strdup(const char * string){
- char * retval;
- int len;
- len = _dl_strlen(string);
- retval = _dl_malloc(len + 1);
- _dl_strcpy(retval, string);
- return retval;
- }
- /* In principle we could do the .fini stuff here, but we already
- registered this stuff with atexit */
- int _dl_interpreter_exit(int exitcode){
- /* _dl_fdprintf(2, "Hey, look where I am!\n"); */
- return 0;
- }
|