lib/libc/gen/dlfcn.c

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