lib/libc/gen/dlfcn.c

   1 /*-
   2  * Copyright (c) 1998 John D. Polstra
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 /*
  31  * Linkage to services provided by the dynamic linker.
  32  */
  33 #include <sys/mman.h>
  34 #include <dlfcn.h>
  35 #include <link.h>
  36 #include <stddef.h>
  37 #include "namespace.h"
  38 #include <pthread.h>
  39 #include "un-namespace.h"
  40 #include "libc_private.h"
  41
  42 static char sorry[] = "Service unavailable";
  43
  44 void _rtld_thread_init(void *);
  45 void _rtld_atfork_pre(int *);
  46 void _rtld_atfork_post(int *);
  47
  48 /*
  49  * For ELF, the dynamic linker directly resolves references to its
  50  * services to functions inside the dynamic linker itself.  These
  51  * weak-symbol stubs are necessary so that "ld" won't complain about
  52  * undefined symbols.  The stubs are executed only when the program is
  53  * linked statically, or when a given service isn't implemented in the
  54  * dynamic linker.  They must return an error if called, and they must
  55  * be weak symbols so that the dynamic linker can override them.
  56  */
  57
  58 #pragma weak _rtld_error
  59 void
  60 _rtld_error(const char *fmt, ...)
  61 {
  62 }
  63
  64 #pragma weak dladdr
  65 int
  66 dladdr(const void *addr, Dl_info *dlip)
  67 {
  68         _rtld_error(sorry);
  69         return 0;
  70 }
  71
  72 #pragma weak dlclose
  73 int
  74 dlclose(void *handle)
  75 {
  76         _rtld_error(sorry);
  77         return -1;
  78 }
  79
  80 #pragma weak dlerror
  81 char *
  82 dlerror(void)
  83 {
  84         return sorry;
  85 }
  86
  87 #pragma weak dllockinit
  88 void
  89 dllockinit(void *context,
  90            void *(*lock_create)(void *context),
  91            void (*rlock_acquire)(void *lock),
  92            void (*wlock_acquire)(void *lock),
  93            void (*lock_release)(void *lock),
  94            void (*lock_destroy)(void *lock),
  95            void (*context_destroy)(void *context))
  96 {
  97         if (context_destroy != NULL)
  98                 context_destroy(context);
  99 }
 100
 101 #pragma weak dlopen
 102 void *
 103 dlopen(const char *name, int mode)
 104 {
 105         _rtld_error(sorry);
 106         return NULL;
 107 }
 108
 109 #pragma weak dlsym
 110 void *
 111 dlsym(void * __restrict handle, const char * __restrict name)
 112 {
 113         _rtld_error(sorry);
 114         return NULL;
 115 }
 116
 117 #pragma weak dlfunc
 118 dlfunc_t
 119 dlfunc(void * __restrict handle, const char * __restrict name)
 120 {
 121         _rtld_error(sorry);
 122         return NULL;
 123 }
 124
 125 #pragma weak dlvsym
 126 void *
 127 dlvsym(void * __restrict handle, const char * __restrict name,
 128     const char * __restrict version)
 129 {
 130         _rtld_error(sorry);
 131         return NULL;
 132 }
 133
 134 #pragma weak dlinfo
 135 int
 136 dlinfo(void * __restrict handle, int request, void * __restrict p)
 137 {
 138         _rtld_error(sorry);
 139         return 0;
 140 }
 141
 142 #pragma weak _rtld_thread_init
 143 void
 144 _rtld_thread_init(void * li)
 145 {
 146         _rtld_error(sorry);
 147 }
 148
 149 static pthread_once_t dl_phdr_info_once = PTHREAD_ONCE_INIT;
 150 static struct dl_phdr_info phdr_info;
 151
 152 static void
 153 dl_init_phdr_info(void)
 154 {
 155         Elf_Auxinfo *auxp;
 156         unsigned int i;
 157
 158         for (auxp = __elf_aux_vector; auxp->a_type != AT_NULL; auxp++) {
 159                 switch (auxp->a_type) {
 160                 case AT_BASE:
 161                         phdr_info.dlpi_addr = (Elf_Addr)auxp->a_un.a_ptr;
 162                         break;
 163                 case AT_EXECPATH:
 164                         phdr_info.dlpi_name = (const char *)auxp->a_un.a_ptr;
 165                         break;
 166                 case AT_PHDR:
 167                         phdr_info.dlpi_phdr =
 168                             (const Elf_Phdr *)auxp->a_un.a_ptr;
 169                         break;
 170                 case AT_PHNUM:
 171                         phdr_info.dlpi_phnum = (Elf_Half)auxp->a_un.a_val;
 172                         break;
 173                 }
 174         }
 175         for (i = 0; i < phdr_info.dlpi_phnum; i++) {
 176                 if (phdr_info.dlpi_phdr[i].p_type == PT_TLS) {
 177                         phdr_info.dlpi_tls_modid = 1;
 178                         phdr_info.dlpi_tls_data =
 179                             (void*)phdr_info.dlpi_phdr[i].p_vaddr;
 180                 }
 181         }
 182         phdr_info.dlpi_adds = 1;
 183 }
 184
 185 #pragma weak dl_iterate_phdr
 186 int
 187 dl_iterate_phdr(int (*callback)(struct dl_phdr_info *, size_t, void *),
 188     void *data)
 189 {
 190
 191         __init_elf_aux_vector();
 192         if (__elf_aux_vector == NULL)
 193                 return (1);
 194         _once(&dl_phdr_info_once, dl_init_phdr_info);
 195         return (callback(&phdr_info, sizeof(phdr_info), data));
 196 }
 197
 198 #pragma weak fdlopen
 199 void *
 200 fdlopen(int fd, int mode)
 201 {
 202
 203         _rtld_error(sorry);
 204         return NULL;
 205 }
 206
 207 #pragma weak _rtld_atfork_pre
 208 void
 209 _rtld_atfork_pre(int *locks)
 210 {
 211 }
 212
 213 #pragma weak _rtld_atfork_post
 214 void
 215 _rtld_atfork_post(int *locks)
 216 {
 217 }
 218
 219 #pragma weak _rtld_addr_phdr
 220 int
 221 _rtld_addr_phdr(const void *addr, struct dl_phdr_info *phdr_info)
 222 {
 223
 224         return (0);
 225 }
 226
 227 #pragma weak _rtld_get_stack_prot
 228 int
 229 _rtld_get_stack_prot(void)
 230 {
 231
 232         return (PROT_EXEC | PROT_READ | PROT_WRITE);
 233 }
 234
 235 #pragma weak _rtld_is_dlopened
 236 int
 237 _rtld_is_dlopened(void *arg)
 238 {
 239
 240         return (0);
 241 }