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         DSO_FUNC_TYPE sym, *tsym = &sym;
 261
 262         if((dso == NULL) || (symname == NULL))
 263                 {
 264                 DSOerr(DSO_F_DLFCN_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
 265                 return(NULL);
 266                 }
 267         if(sk_void_num(dso->meth_data) < 1)
 268                 {
 269                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_STACK_ERROR);
 270                 return(NULL);
 271                 }
 272         ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 273         if(ptr == NULL)
 274                 {
 275                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_NULL_HANDLE);
 276                 return(NULL);
 277                 }
 278         *(void **)(tsym) = dlsym(ptr, symname);
 279         if(sym == NULL)
 280                 {
 281                 DSOerr(DSO_F_DLFCN_BIND_FUNC,DSO_R_SYM_FAILURE);
 282                 ERR_add_error_data(4, "symname(", symname, "): ", dlerror());
 283                 return(NULL);
 284                 }
 285         return(sym);
 286         }
 287
 288 static char *dlfcn_merger(DSO *dso, const char *filespec1,
 289         const char *filespec2)
 290         {
 291         char *merged;
 292
 293         if(!filespec1 && !filespec2)
 294                 {
 295                 DSOerr(DSO_F_DLFCN_MERGER,
 296                                 ERR_R_PASSED_NULL_PARAMETER);
 297                 return(NULL);
 298                 }
 299         /* If the first file specification is a rooted path, it rules.
 300            same goes if the second file specification is missing. */
 301         if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/'))
 302                 {
 303                 merged = OPENSSL_malloc(strlen(filespec1) + 1);
 304                 if(!merged)
 305                         {
 306                         DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);
 307                         return(NULL);
 308                         }
 309                 strcpy(merged, filespec1);
 310                 }
 311         /* If the first file specification is missing, the second one rules. */
 312         else if (!filespec1)
 313                 {
 314                 merged = OPENSSL_malloc(strlen(filespec2) + 1);
 315                 if(!merged)
 316                         {
 317                         DSOerr(DSO_F_DLFCN_MERGER,
 318                                 ERR_R_MALLOC_FAILURE);
 319                         return(NULL);
 320                         }
 321                 strcpy(merged, filespec2);
 322                 }
 323         else
 324                 /* This part isn't as trivial as it looks.  It assumes that
 325                    the second file specification really is a directory, and
 326                    makes no checks whatsoever.  Therefore, the result becomes
 327                    the concatenation of filespec2 followed by a slash followed
 328                    by filespec1. */
 329                 {
 330                 int spec2len, len;
 331
 332                 spec2len = strlen(filespec2);
 333                 len = spec2len + (filespec1 ? strlen(filespec1) : 0);
 334
 335                 if(filespec2 && filespec2[spec2len - 1] == '/')
 336                         {
 337                         spec2len--;
 338                         len--;
 339                         }
 340                 merged = OPENSSL_malloc(len + 2);
 341                 if(!merged)
 342                         {
 343                         DSOerr(DSO_F_DLFCN_MERGER,
 344                                 ERR_R_MALLOC_FAILURE);
 345                         return(NULL);
 346                         }
 347                 strcpy(merged, filespec2);
 348                 merged[spec2len] = '/';
 349                 strcpy(&merged[spec2len + 1], filespec1);
 350                 }
 351         return(merged);
 352         }
 353
 354 #ifdef OPENSSL_SYS_MACOSX
 355 #define DSO_ext ".dylib"
 356 #define DSO_extlen 6
 357 #else
 358 #define DSO_ext ".so"
 359 #define DSO_extlen 3
 360 #endif
 361
 362
 363 static char *dlfcn_name_converter(DSO *dso, const char *filename)
 364         {
 365         char *translated;
 366         int len, rsize, transform;
 367
 368         len = strlen(filename);
 369         rsize = len + 1;
 370         transform = (strstr(filename, "/") == NULL);
 371         if(transform)
 372                 {
 373                 /* We will convert this to "%s.so" or "lib%s.so" etc */
 374                 rsize += DSO_extlen;    /* The length of ".so" */
 375                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 376                         rsize += 3; /* The length of "lib" */
 377                 }
 378         translated = OPENSSL_malloc(rsize);
 379         if(translated == NULL)
 380                 {
 381                 DSOerr(DSO_F_DLFCN_NAME_CONVERTER,
 382                                 DSO_R_NAME_TRANSLATION_FAILED);
 383                 return(NULL);
 384                 }
 385         if(transform)
 386                 {
 387                 if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 388                         sprintf(translated, "lib%s" DSO_ext, filename);
 389                 else
 390                         sprintf(translated, "%s" DSO_ext, filename);
 391                 }
 392         else
 393                 sprintf(translated, "%s", filename);
 394         return(translated);
 395         }
 396
 397 #ifdef __sgi
 398 /*
 399 This is a quote from IRIX manual for dladdr(3c):
 400
 401      <dlfcn.h> does not contain a prototype for dladdr or definition of
 402      Dl_info.  The #include <dlfcn.h>  in the SYNOPSIS line is traditional,
 403      but contains no dladdr prototype and no IRIX library contains an
 404      implementation.  Write your own declaration based on the code below.
 405
 406      The following code is dependent on internal interfaces that are not
 407      part of the IRIX compatibility guarantee; however, there is no future
 408      intention to change this interface, so on a practical level, the code
 409      below is safe to use on IRIX.
 410 */
 411 #include <rld_interface.h>
 412 #ifndef _RLD_INTERFACE_DLFCN_H_DLADDR
 413 #define _RLD_INTERFACE_DLFCN_H_DLADDR
 414 typedef struct Dl_info {
 415     const char * dli_fname;
 416     void       * dli_fbase;
 417     const char * dli_sname;
 418     void       * dli_saddr;
 419     int          dli_version;
 420     int          dli_reserved1;
 421     long         dli_reserved[4];
 422 } Dl_info;
 423 #else
 424 typedef struct Dl_info Dl_info;
 425 #endif
 426 #define _RLD_DLADDR             14
 427
 428 static int dladdr(void *address, Dl_info *dl)
 429 {
 430         void *v;
 431         v = _rld_new_interface(_RLD_DLADDR,address,dl);
 432         return (int)v;
 433 }
 434 #endif /* __sgi */
 435
 436 static int dlfcn_pathbyaddr(void *addr,char *path,int sz)
 437         {
 438 #ifdef HAVE_DLINFO
 439         Dl_info dli;
 440         int len;
 441
 442         if (addr == NULL)
 443                 {
 444                 union   { int(*f)(void*,char*,int); void *p; } t =
 445                         { dlfcn_pathbyaddr };
 446                 addr = t.p;
 447                 }
 448
 449         if (dladdr(addr,&dli))
 450                 {
 451                 len = (int)strlen(dli.dli_fname);
 452                 if (sz <= 0) return len+1;
 453                 if (len >= sz) len=sz-1;
 454                 memcpy(path,dli.dli_fname,len);
 455                 path[len++]=0;
 456                 return len;
 457                 }
 458
 459         ERR_add_error_data(4, "dlfcn_pathbyaddr(): ", dlerror());
 460 #endif
 461         return -1;
 462         }
 463
 464 static void *dlfcn_globallookup(const char *name)
 465         {
 466         void *ret = NULL,*handle = dlopen(NULL,RTLD_LAZY);
 467
 468         if (handle)
 469                 {
 470                 ret = dlsym(handle,name);
 471                 dlclose(handle);
 472                 }
 473
 474         return ret;
 475         }
 476 #endif /* DSO_DLFCN */