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 # include <dlfcn.h>
  82 # define HAVE_DLINFO 1
  83 # if defined(_AIX) || defined(__CYGWIN__) || \
  84      defined(__SCO_VERSION__) || defined(_SCO_ELF) || \
  85      (defined(__OpenBSD__) && !defined(RTLD_SELF))
  86 #  undef HAVE_DLINFO
  87 # endif
  88 #endif
  89
  90 /* Part of the hack in "dlfcn_load" ... */
  91 #define DSO_MAX_TRANSLATED_SIZE 256
  92
  93 static int dlfcn_load(DSO *dso);
  94 static int dlfcn_unload(DSO *dso);
  95 static void *dlfcn_bind_var(DSO *dso, const char *symname);
  96 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname);
  97 #if 0
  98 static int dlfcn_unbind(DSO *dso, char *symname, void *symptr);
  99 static int dlfcn_init(DSO *dso);
 100 static int dlfcn_finish(DSO *dso);
 101 static long dlfcn_ctrl(DSO *dso, int cmd, long larg, void *parg);
 102 #endif
 103 static char *dlfcn_name_converter(DSO *dso, const char *filename);
 104 static char *dlfcn_merger(DSO *dso, const char *filespec1,
 105         const char *filespec2);
 106 static int dlfcn_pathbyaddr(void *addr,char *path,int sz);
 107 static void *dlfcn_globallookup(const char *name);
 108
 109 static DSO_METHOD dso_meth_dlfcn = {
 110         "OpenSSL 'dlfcn' shared library method",
 111         dlfcn_load,
 112         dlfcn_unload,
 113         dlfcn_bind_var,
 114         dlfcn_bind_func,
 115 /* For now, "unbind" doesn't exist */
 116 #if 0
 117         NULL, /* unbind_var */
 118         NULL, /* unbind_func */
 119 #endif
 120         NULL, /* ctrl */
 121         dlfcn_name_converter,
 122         dlfcn_merger,
 123         NULL, /* init */
 124         NULL, /* finish */
 125         dlfcn_pathbyaddr,
 126         dlfcn_globallookup
 127         };
 128
 129 DSO_METHOD *DSO_METHOD_dlfcn(void)
 130         {
 131         return(&dso_meth_dlfcn);
 132         }
 133
 134 /* Prior to using the dlopen() function, we should decide on the flag
 135  * we send. There's a few different ways of doing this and it's a
 136  * messy venn-diagram to match up which platforms support what. So
 137  * as we don't have autoconf yet, I'm implementing a hack that could
 138  * be hacked further relatively easily to deal with cases as we find
 139  * them. Initially this is to cope with OpenBSD. */
 140 #if defined(__OpenBSD__) || defined(__NetBSD__)
 141 #       ifdef DL_LAZY
 142 #               define DLOPEN_FLAG DL_LAZY
 143 #       else
 144 #               ifdef RTLD_NOW
 145 #                       define DLOPEN_FLAG RTLD_NOW
 146 #               else
 147 #                       define DLOPEN_FLAG 0
 148 #               endif
 149 #       endif
 150 #else
 151 #       ifdef OPENSSL_SYS_SUNOS
 152 #               define DLOPEN_FLAG 1
 153 #       else
 154 #               define DLOPEN_FLAG RTLD_NOW /* Hope this works everywhere else */
 155 #       endif
 156 #endif
 157
 158 /* For this DSO_METHOD, our meth_data STACK will contain;
 159  * (i) the handle (void*) returned from dlopen().
 160  */
 161
 162 static int dlfcn_load(DSO *dso)
 163         {
 164         void *ptr = NULL;
 165         /* See applicable comments in dso_dl.c */
 166         char *filename = DSO_convert_filename(dso, NULL);
 167         int flags = DLOPEN_FLAG;
 168
 169         if(filename == NULL)
 170                 {
 171                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_NO_FILENAME);
 172                 goto err;
 173                 }
 174
 175 #ifdef RTLD_GLOBAL
 176         if (dso->flags & DSO_FLAG_GLOBAL_SYMBOLS)
 177                 flags |= RTLD_GLOBAL;
 178 #endif
 179         ptr = dlopen(filename, flags);
 180         if(ptr == NULL)
 181                 {
 182                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_LOAD_FAILED);
 183                 ERR_add_error_data(4, "filename(", filename, "): ", dlerror());
 184                 goto err;
 185                 }
 186         if(!sk_void_push(dso->meth_data, (char *)ptr))
 187                 {
 188                 DSOerr(DSO_F_DLFCN_LOAD,DSO_R_STACK_ERROR);
 189                 goto err;
 190                 }
 191         /* Success */
 192         dso->loaded_filename = filename;
 193         return(1);
 194 err:
 195         /* Cleanup! */
 196         if(filename != NULL)
 197                 OPENSSL_free(filename);
 198         if(ptr != NULL)
 199                 dlclose(ptr);
 200         return(0);
 201 }
 202
 203 static int dlfcn_unload(DSO *dso)
 204         {
 205         void *ptr;
 206         if(dso == NULL)
 207                 {
 208                 DSOerr(DSO_F_DLFCN_UNLOAD,ERR_R_PASSED_NULL_PARAMETER);
 209                 return(0);
 210                 }
 211         if(sk_void_num(dso->meth_data) < 1)
 212                 return(1);
 213         ptr = sk_void_pop(dso->meth_data);
 214         if(ptr == NULL)
 215                 {
 216                 DSOerr(DSO_F_DLFCN_UNLOAD,DSO_R_NULL_HANDLE);
 217                 /* Should push the value back onto the stack in
 218                  * case of a retry. */
 219                 sk_void_push(dso->meth_data, ptr);
 220                 return(0);
 221                 }
 222         /* For now I'm not aware of any errors associated with dlclose() */
 223         dlclose(ptr);
 224         return(1);
 225         }
 226
 227 static void *dlfcn_bind_var(DSO *dso, const char *symname)
 228         {
 229         void *ptr, *sym;
 230
 231         if((dso == NULL) || (symname == NULL))
 232                 {
 233                 DSOerr(DSO_F_DLFCN_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
 234                 return(NULL);
 235                 }
 236         if(sk_void_num(dso->meth_data) < 1)
 237                 {
 238                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_STACK_ERROR);
 239                 return(NULL);
 240                 }
 241         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 242         if(ptr == NULL)
 243                 {
 244                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_NULL_HANDLE);
 245                 return(NULL);
 246                 }
 247         sym = dlsym(ptr, symname);
 248         if(sym == NULL)
 249                 {
 250                 DSOerr(DSO_F_DLFCN_BIND_VAR,DSO_R_SYM_FAILURE);
 251                 ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
 252                 return(NULL);
 253                 }
 254         return(sym);
 255         }
 256
 257 static DSO_FUNC_TYPE dlfcn_bind_func(DSO *dso, const char *symname)
 258         {
 259         void *ptr;
 260         union {
 261                 DSO_FUNC_TYPE sym;
 262                 void *dlret;
 263         } u;
 264
 265         if((dso == NULL) || (symname == NULL))
 266                 {
 267                 DSOerr(DSO_F_DLFCN_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
 268                 return(NULL);
 269                 }
 270         if(sk_void_num(dso->meth_data) < 1)
 271                 {
 272                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_STACK_ERROR);
 273                 return(NULL);
 274                 }
 275         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 276         if(ptr == NULL)
 277                 {
 278                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_NULL_HANDLE);
 279                 return(NULL);
 280                 }
 281         u.dlret = dlsym(ptr, symname);
 282         if(u.dlret == NULL)
 283                 {
 284                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_SYM_FAILURE);
 285                 ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
 286                 return(NULL);
 287                 }
 288         return u.sym;
 289         }
 290
 291 static char *dlfcn_merger(DSO *dso, const char *filespec1,
 292         const char *filespec2)
 293         {
 294         char *merged;
 295
 296         if(!filespec1 && !filespec2)
 297                 {
 298                 DSOerr(DSO_F_DLFCN_MERGER,
 299                                 ERR_R_PASSED_NULL_PARAMETER);
 300                 return(NULL);
 301                 }
 302         /* If the first file specification is a rooted path, it rules.
 303            same goes if the second file specification is missing. */
 304         if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/'))
 305                 {
 306                 merged = OPENSSL_malloc(strlen(filespec1) + 1);
 307                 if(!merged)
 308                         {
 309                         DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
 310                         return(NULL);
 311                         }
 312                 strcpy(merged, filespec1);
 313                 }
 314         /* If the first file specification is missing, the second one rules. */
 315         else if (!filespec1)
 316                 {
 317                 merged = OPENSSL_malloc(strlen(filespec2) + 1);
 318                 if(!merged)
 319                         {
 320                         DSOerr(DSO_F_DLFCN_MERGER,
 321                                 ERR_R_MALLOC_FAILURE);
 322                         return(NULL);
 323                         }
 324                 strcpy(merged, filespec2);
 325                 }
 326         else
 327                 /* This part isn't as trivial as it looks.  It assumes that
 328                    the second file specification really is a directory, and
 329                    makes no checks whatsoever.  Therefore, the result becomes
 330                    the concatenation of filespec2 followed by a slash followed
 331                    by filespec1. */
 332                 {
 333                 int spec2len, len;
 334
 335                 spec2len = strlen(filespec2);
 336                 len = spec2len + (filespec1 ? strlen(filespec1) : 0);
 337
 338                 if(filespec2 && filespec2[spec2len - 1] == '/')
 339                         {
 340                         spec2len--;
 341                         len--;
 342                         }
 343                 merged = OPENSSL_malloc(len + 2);
 344                 if(!merged)
 345                         {
 346                         DSOerr(DSO_F_DLFCN_MERGER,
 347                                 ERR_R_MALLOC_FAILURE);
 348                         return(NULL);
 349                         }
 350                 strcpy(merged, filespec2);
 351                 merged[spec2len] = '/';
 352                 strcpy(&merged[spec2len + 1], filespec1);
 353                 }
 354         return(merged);
 355         }
 356
 357 #ifdef OPENSSL_SYS_MACOSX
 358 #define DSO_ext ".dylib"
 359 #define DSO_extlen 6
 360 #else
 361 #define DSO_ext ".so"
 362 #define DSO_extlen 3
 363 #endif
 364
 365
 366 static char *dlfcn_name_converter(DSO *dso, const char *filename)
 367         {
 368         char *translated;
 369         int len, rsize, transform;
 370
 371         len = strlen(filename);
 372         rsize = len + 1;
 373         transform = (strstr(filename, "/") == NULL);
 374         if(transform)
 375                 {
 376                 /* We will convert this to "%s.so" or "lib%s.so" etc */
 377                 rsize += DSO_extlen;    /* The length of ".so" */
 378                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 379                         rsize += 3; /* The length of "lib" */
 380                 }
 381         translated = OPENSSL_malloc(rsize);
 382         if(translated == NULL)
 383                 {
 384                 DSOerr(DSO_F_DLFCN_NAME_CONVERTER,
 385                                 DSO_R_NAME_TRANSLATION_FAILED);
 386                 return(NULL);
 387                 }
 388         if(transform)
 389                 {
 390                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 391                         sprintf(translated, "lib%s" DSO_ext, filename);
 392                 else
 393                         sprintf(translated, "%s" DSO_ext, filename);
 394                 }
 395         else
 396                 sprintf(translated, "%s", filename);
 397         return(translated);
 398         }
 399
 400 #ifdef __sgi
 401 /*
 402 This is a quote from IRIX manual for dladdr(3c):
 403
 404      <dlfcn.h> does not contain a prototype for dladdr or definition of
 405      Dl_info.  The #include <dlfcn.h>  in the SYNOPSIS line is traditional,
 406      but contains no dladdr prototype and no IRIX library contains an
 407      implementation.  Write your own declaration based on the code below.
 408
 409      The following code is dependent on internal interfaces that are not
 410      part of the IRIX compatibility guarantee; however, there is no future
 411      intention to change this interface, so on a practical level, the code
 412      below is safe to use on IRIX.
 413 */
 414 #include <rld_interface.h>
 415 #ifndef _RLD_INTERFACE_DLFCN_H_DLADDR
 416 #define _RLD_INTERFACE_DLFCN_H_DLADDR
 417 typedef struct Dl_info {
 418     const char * dli_fname;
 419     void       * dli_fbase;
 420     const char * dli_sname;
 421     void       * dli_saddr;
 422     int          dli_version;
 423     int          dli_reserved1;
 424     long         dli_reserved[4];
 425 } Dl_info;
 426 #else
 427 typedef struct Dl_info Dl_info;
 428 #endif
 429 #define _RLD_DLADDR             14
 430
 431 static int dladdr(void *address, Dl_info *dl)
 432 {
 433         void *v;
 434         v = _rld_new_interface(_RLD_DLADDR,address,dl);
 435         return (int)v;
 436 }
 437 #endif /* __sgi */
 438
 439 static int dlfcn_pathbyaddr(void *addr,char *path,int sz)
 440         {
 441 #ifdef HAVE_DLINFO
 442         Dl_info dli;
 443         int len;
 444
 445         if (addr == NULL)
 446                 {
 447                 union   { int(*f)(void*,char*,int); void *p; } t =
 448                         { dlfcn_pathbyaddr };
 449                 addr = t.p;
 450                 }
 451
 452         if (dladdr(addr,&dli))
 453                 {
 454                 len = (int)strlen(dli.dli_fname);
 455                 if (sz <= 0) return len+1;
 456                 if (len >= sz) len=sz-1;
 457                 memcpy(path,dli.dli_fname,len);
 458                 path[len++]=0;
 459                 return len;
 460                 }
 461
 462         ERR_add_error_data(4, "dlfcn_pathbyaddr(): ", dlerror());
 463 #endif
 464         return -1;
 465         }
 466
 467 static void *dlfcn_globallookup(const char *name)
 468         {
 469         void *ret = NULL,*handle = dlopen(NULL,RTLD_LAZY);
 470
 471         if (handle)
 472                 {
 473                 ret = dlsym(handle,name);
 474                 dlclose(handle);
 475                 }
 476
 477         return ret;
 478         }
 479 #endif /* DSO_DLFCN */