crypto/dso/dso_dlfcn.c

   1 /* dso_dlfcn.c -*- mode:C; c-file-style: "eay" -*- */
   2 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
   3  * project 2000.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 /* We need to do this early, because stdio.h includes the header files
  60    that handle _GNU_SOURCE and other similar macros.  Defining it later
  61    is simply too late, because those headers are protected from re-
  62    inclusion.  */
  63 #ifdef __linux
  64 # ifndef _GNU_SOURCE
  65 #  define _GNU_SOURCE   /* make sure dladdr is declared */
  66 # endif
  67 #endif
  68
  69 #include <stdio.h>
  70 #include "cryptlib.h"
  71 #include <openssl/dso.h>
  72
  73 #ifndef DSO_DLFCN
  74 DSO_METHOD *DSO_METHOD_dlfcn(void)
  75         {
  76         return NULL;
  77         }
  78 #else
  79
  80 #ifdef HAVE_DLFCN_H
  81 # ifdef __osf__
  82 #  define __EXTENSIONS__
  83 # endif
  84 # include <dlfcn.h>
  85 # define HAVE_DLINFO 1
  86 # if defined(_AIX) || defined(__CYGWIN__) || \
  87      defined(__SCO_VERSION__) || defined(_SCO_ELF) || \
  88      (defined(__osf__) && !defined(RTLD_NEXT))     || \
  89      (defined(__OpenBSD__) && !defined(RTLD_SELF)) || \
  90         defined(__ANDROID__)
  91 #  undef HAVE_DLINFO
  92 # endif
  93 #endif
  94
  95 /* Part of the hack in "dlfcn_load" ... */
  96 #define DSO_MAX_TRANSLATED_SIZE 256
  97
  98 static int dlfcn_load(DSO *dso);
  99 static int dlfcn_unload(DSO *dso);
 100 static void *dlfcn_bind_var(DSO *dso, const char *symname);
 101 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname);
 102 #if 0
 103 static int dlfcn_unbind(DSO *dso, char *symname, void *symptr);
 104 static int dlfcn_init(DSO *dso);
 105 static int dlfcn_finish(DSO *dso);
 106 static long dlfcn_ctrl(DSO *dso, int cmd, long larg, void *parg);
 107 #endif
 108 static char *dlfcn_name_converter(DSO *dso, const char *filename);
 109 static char *dlfcn_merger(DSO *dso, const char *filespec1,
 110         const char *filespec2);
 111 static int dlfcn_pathbyaddr(void *addr,char *path,int sz);
 112 static void *dlfcn_globallookup(const char *name);
 113
 114 static DSO_METHOD dso_meth_dlfcn = {
 115         "OpenSSL 'dlfcn' shared library method",
 116         dlfcn_load,
 117         dlfcn_unload,
 118         dlfcn_bind_var,
 119         dlfcn_bind_func,
 120 /* For now, "unbind" doesn't exist */
 121 #if 0
 122         NULL, /* unbind_var */
 123         NULL, /* unbind_func */
 124 #endif
 125         NULL, /* ctrl */
 126         dlfcn_name_converter,
 127         dlfcn_merger,
 128         NULL, /* init */
 129         NULL, /* finish */
 130         dlfcn_pathbyaddr,
 131         dlfcn_globallookup
 132         };
 133
 134 DSO_METHOD *DSO_METHOD_dlfcn(void)
 135         {
 136         return(&dso_meth_dlfcn);
 137         }
 138
 139 /* Prior to using the dlopen() function, we should decide on the flag
 140  * we send. There's a few different ways of doing this and it's a
 141  * messy venn-diagram to match up which platforms support what. So
 142  * as we don't have autoconf yet, I'm implementing a hack that could
 143  * be hacked further relatively easily to deal with cases as we find
 144  * them. Initially this is to cope with OpenBSD. */
 145 #if defined(__OpenBSD__) || defined(__NetBSD__)
 146 #       ifdef DL_LAZY
 147 #               define DLOPEN_FLAG DL_LAZY
 148 #       else
 149 #               ifdef RTLD_NOW
 150 #                       define DLOPEN_FLAG RTLD_NOW
 151 #               else
 152 #                       define DLOPEN_FLAG 0
 153 #               endif
 154 #       endif
 155 #else
 156 #       define DLOPEN_FLAG RTLD_NOW /* Hope this works everywhere else */
 157 #endif
 158
 159 /* For this DSO_METHOD, our meth_data STACK will contain;
 160  * (i) the handle (void*) returned from dlopen().
 161  */
 162
 163 static int dlfcn_load(DSO *dso)
 164         {
 165         void *ptr = NULL;
 166         /* See applicable comments in dso_dl.c */
 167         char *filename = DSO_convert_filename(dso, NULL);
 168         int flags = DLOPEN_FLAG;
 169
 170         if(filename == NULL)
 171                 {
 172                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_NO_FILENAME);
 173                 goto err;
 174                 }
 175
 176 #ifdef RTLD_GLOBAL
 177         if (dso->flags & DSO_FLAG_GLOBAL_SYMBOLS)
 178                 flags |= RTLD_GLOBAL;
 179 #endif
 180         ptr = dlopen(filename, flags);
 181         if(ptr == NULL)
 182                 {
 183                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_LOAD_FAILED);
 184                 ERR_add_error_data(4, "filename(", filename, "): ", dlerror());
 185                 goto err;
 186                 }
 187         if(!sk_void_push(dso->meth_data, (char *)ptr))
 188                 {
 189                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_STACK_ERROR);
 190                 goto err;
 191                 }
 192         /* Success */
 193         dso->loaded_filename = filename;
 194         return(1);
 195 err:
 196         /* Cleanup! */
 197         if(filename != NULL)
 198                 OPENSSL_free(filename);
 199         if(ptr != NULL)
 200                 dlclose(ptr);
 201         return(0);
 202 }
 203
 204 static int dlfcn_unload(DSO *dso)
 205         {
 206         void *ptr;
 207         if(dso == NULL)
 208                 {
 209                 DSOerr(DSO_F_DLFCN_UNLOAD,ERR_R_PASSED_NULL_PARAMETER);
 210                 return(0);
 211                 }
 212         if(sk_void_num(dso->meth_data) < 1)
 213                 return(1);
 214         ptr = sk_void_pop(dso->meth_data);
 215         if(ptr == NULL)
 216                 {
 217                 DSOerr(DSO_F_DLFCN_UNLOAD,DSO_R_NULL_HANDLE);
 218                 /* Should push the value back onto the stack in
 219                  * case of a retry. */
 220                 sk_void_push(dso->meth_data, ptr);
 221                 return(0);
 222                 }
 223         /* For now I'm not aware of any errors associated with dlclose() */
 224         dlclose(ptr);
 225         return(1);
 226         }
 227
 228 static void *dlfcn_bind_var(DSO *dso, const char *symname)
 229         {
 230         void *ptr, *sym;
 231
 232         if((dso == NULL) || (symname == NULL))
 233                 {
 234                 DSOerr(DSO_F_DLFCN_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
 235                 return(NULL);
 236                 }
 237         if(sk_void_num(dso->meth_data) < 1)
 238                 {
 239                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_STACK_ERROR);
 240                 return(NULL);
 241                 }
 242         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 243         if(ptr == NULL)
 244                 {
 245                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_NULL_HANDLE);
 246                 return(NULL);
 247                 }
 248         sym = dlsym(ptr, symname);
 249         if(sym == NULL)
 250                 {
 251                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_SYM_FAILURE);
 252                 ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
 253                 return(NULL);
 254                 }
 255         return(sym);
 256         }
 257
 258 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname)
 259         {
 260         void *ptr;
 261         union {
 262                 DSO_FUNC_TYPE sym;
 263                 void *dlret;
 264         } u;
 265
 266         if((dso == NULL) || (symname == NULL))
 267                 {
 268                 DSOerr(DSO_F_DLFCN_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
 269                 return(NULL);
 270                 }
 271         if(sk_void_num(dso->meth_data) < 1)
 272                 {
 273                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_STACK_ERROR);
 274                 return(NULL);
 275                 }
 276         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 277         if(ptr == NULL)
 278                 {
 279                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_NULL_HANDLE);
 280                 return(NULL);
 281                 }
 282         u.dlret = dlsym(ptr, symname);
 283         if(u.dlret == NULL)
 284                 {
 285                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_SYM_FAILURE);
 286                 ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
 287                 return(NULL);
 288                 }
 289         return u.sym;
 290         }
 291
 292 static char *dlfcn_merger(DSO *dso, const char *filespec1,
 293         const char *filespec2)
 294         {
 295         char *merged;
 296
 297         if(!filespec1 && !filespec2)
 298                 {
 299                 DSOerr(DSO_F_DLFCN_MERGER,
 300                                 ERR_R_PASSED_NULL_PARAMETER);
 301                 return(NULL);
 302                 }
 303         /* If the first file specification is a rooted path, it rules.
 304            same goes if the second file specification is missing. */
 305         if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/'))
 306                 {
 307                 merged = OPENSSL_malloc(strlen(filespec1) + 1);
 308                 if(!merged)
 309                         {
 310                         DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
 311                         return(NULL);
 312                         }
 313                 strcpy(merged, filespec1);
 314                 }
 315         /* If the first file specification is missing, the second one rules. */
 316         else if (!filespec1)
 317                 {
 318                 merged = OPENSSL_malloc(strlen(filespec2) + 1);
 319                 if(!merged)
 320                         {
 321                         DSOerr(DSO_F_DLFCN_MERGER,
 322                                 ERR_R_MALLOC_FAILURE);
 323                         return(NULL);
 324                         }
 325                 strcpy(merged, filespec2);
 326                 }
 327         else
 328                 /* This part isn't as trivial as it looks.  It assumes that
 329                    the second file specification really is a directory, and
 330                    makes no checks whatsoever.  Therefore, the result becomes
 331                    the concatenation of filespec2 followed by a slash followed
 332                    by filespec1. */
 333                 {
 334                 int spec2len, len;
 335
 336                 spec2len = strlen(filespec2);
 337                 len = spec2len + (filespec1 ? strlen(filespec1) : 0);
 338
 339                 if(filespec2 && filespec2[spec2len - 1] == '/')
 340                         {
 341                         spec2len--;
 342                         len--;
 343                         }
 344                 merged = OPENSSL_malloc(len + 2);
 345                 if(!merged)
 346                         {
 347                         DSOerr(DSO_F_DLFCN_MERGER,
 348                                 ERR_R_MALLOC_FAILURE);
 349                         return(NULL);
 350                         }
 351                 strcpy(merged, filespec2);
 352                 merged[spec2len] = '/';
 353                 strcpy(&merged[spec2len + 1], filespec1);
 354                 }
 355         return(merged);
 356         }
 357
 358 #ifdef OPENSSL_SYS_MACOSX
 359 #define DSO_ext ".dylib"
 360 #define DSO_extlen 6
 361 #else
 362 #define DSO_ext ".so"
 363 #define DSO_extlen 3
 364 #endif
 365
 366
 367 static char *dlfcn_name_converter(DSO *dso, const char *filename)
 368         {
 369         char *translated;
 370         int len, rsize, transform;
 371
 372         len = strlen(filename);
 373         rsize = len + 1;
 374         transform = (strstr(filename, "/") == NULL);
 375         if(transform)
 376                 {
 377                 /* We will convert this to "%s.so" or "lib%s.so" etc */
 378                 rsize += DSO_extlen;    /* The length of ".so" */
 379                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 380                         rsize += 3; /* The length of "lib" */
 381                 }
 382         translated = OPENSSL_malloc(rsize);
 383         if(translated == NULL)
 384                 {
 385                 DSOerr(DSO_F_DLFCN_NAME_CONVERTER,
 386                                 DSO_R_NAME_TRANSLATION_FAILED);
 387                 return(NULL);
 388                 }
 389         if(transform)
 390                 {
 391                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 392                         sprintf(translated, "lib%s" DSO_ext, filename);
 393                 else
 394                         sprintf(translated, "%s" DSO_ext, filename);
 395                 }
 396         else
 397                 sprintf(translated, "%s", filename);
 398         return(translated);
 399         }
 400
 401 #ifdef __sgi
 402 /*
 403 This is a quote from IRIX manual for dladdr(3c):
 404
 405      <dlfcn.h> does not contain a prototype for dladdr or definition of
 406      Dl_info.  The #include <dlfcn.h>  in the SYNOPSIS line is traditional,
 407      but contains no dladdr prototype and no IRIX library contains an
 408      implementation.  Write your own declaration based on the code below.
 409
 410      The following code is dependent on internal interfaces that are not
 411      part of the IRIX compatibility guarantee; however, there is no future
 412      intention to change this interface, so on a practical level, the code
 413      below is safe to use on IRIX.
 414 */
 415 #include <rld_interface.h>
 416 #ifndef _RLD_INTERFACE_DLFCN_H_DLADDR
 417 #define _RLD_INTERFACE_DLFCN_H_DLADDR
 418 typedef struct Dl_info {
 419     const char * dli_fname;
 420     void       * dli_fbase;
 421     const char * dli_sname;
 422     void       * dli_saddr;
 423     int          dli_version;
 424     int          dli_reserved1;
 425     long         dli_reserved[4];
 426 } Dl_info;
 427 #else
 428 typedef struct Dl_info Dl_info;
 429 #endif
 430 #define _RLD_DLADDR             14
 431
 432 static int dladdr(void *address, Dl_info *dl)
 433 {
 434         void *v;
 435         v = _rld_new_interface(_RLD_DLADDR,address,dl);
 436         return (int)v;
 437 }
 438 #endif /* __sgi */
 439
 440 static int dlfcn_pathbyaddr(void *addr,char *path,int sz)
 441         {
 442 #ifdef HAVE_DLINFO
 443         Dl_info dli;
 444         int len;
 445
 446         if (addr == NULL)
 447                 {
 448                 union   { int(*f)(void*,char*,int); void *p; } t =
 449                         { dlfcn_pathbyaddr };
 450                 addr = t.p;
 451                 }
 452
 453         if (dladdr(addr,&dli))
 454                 {
 455                 len = (int)strlen(dli.dli_fname);
 456                 if (sz <= 0) return len+1;
 457                 if (len >= sz) len=sz-1;
 458                 memcpy(path,dli.dli_fname,len);
 459                 path[len++]=0;
 460                 return len;
 461                 }
 462
 463         ERR_add_error_data(2, "dlfcn_pathbyaddr(): ", dlerror());
 464 #endif
 465         return -1;
 466         }
 467
 468 static void *dlfcn_globallookup(const char *name)
 469         {
 470         void *ret = NULL,*handle = dlopen(NULL,RTLD_LAZY);
 471
 472         if (handle)
 473                 {
 474                 ret = dlsym(handle,name);
 475                 dlclose(handle);
 476                 }
 477
 478         return ret;
 479         }
 480 #endif /* DSO_DLFCN */