crypto/dso/dso_dl.c

   1 /*
   2  * Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
   3  * 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 #include "dso_locl.h"
  60
  61 #ifdef DSO_DL
  62
  63 # include <dl.h>
  64
  65 /* Part of the hack in "dl_load" ... */
  66 # define DSO_MAX_TRANSLATED_SIZE 256
  67
  68 static int dl_load(DSO *dso);
  69 static int dl_unload(DSO *dso);
  70 static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname);
  71 static char *dl_name_converter(DSO *dso, const char *filename);
  72 static char *dl_merger(DSO *dso, const char *filespec1,
  73                        const char *filespec2);
  74 static void *dl_globallookup(const char *name);
  75
  76 static DSO_METHOD dso_meth_dl = {
  77     "OpenSSL 'dl' shared library method",
  78     dl_load,
  79     dl_unload,
  80     dl_bind_func,
  81     NULL,                       /* ctrl */
  82     dl_name_converter,
  83     dl_merger,
  84     NULL,                       /* init */
  85     NULL,                       /* finish */
  86     dl_globallookup
  87 };
  88
  89 DSO_METHOD *DSO_METHOD_openssl(void)
  90 {
  91     return &dso_meth_dl;
  92 }
  93
  94 /*
  95  * For this DSO_METHOD, our meth_data STACK will contain; (i) the handle
  96  * (shl_t) returned from shl_load(). NB: I checked on HPUX11 and shl_t is
  97  * itself a pointer type so the cast is safe.
  98  */
  99
 100 static int dl_load(DSO *dso)
 101 {
 102     shl_t ptr = NULL;
 103     /*
 104      * We don't do any fancy retries or anything, just take the method's (or
 105      * DSO's if it has the callback set) best translation of the
 106      * platform-independent filename and try once with that.
 107      */
 108     char *filename = DSO_convert_filename(dso, NULL);
 109
 110     if (filename == NULL) {
 111         DSOerr(DSO_F_DL_LOAD, DSO_R_NO_FILENAME);
 112         goto err;
 113     }
 114     ptr = shl_load(filename, BIND_IMMEDIATE |
 115                    (dso->flags & DSO_FLAG_NO_NAME_TRANSLATION ? 0 :
 116                     DYNAMIC_PATH), 0L);
 117     if (ptr == NULL) {
 118         DSOerr(DSO_F_DL_LOAD, DSO_R_LOAD_FAILED);
 119         ERR_add_error_data(4, "filename(", filename, "): ", strerror(errno));
 120         goto err;
 121     }
 122     if (!sk_push(dso->meth_data, (char *)ptr)) {
 123         DSOerr(DSO_F_DL_LOAD, DSO_R_STACK_ERROR);
 124         goto err;
 125     }
 126     /*
 127      * Success, stick the converted filename we've loaded under into the DSO
 128      * (it also serves as the indicator that we are currently loaded).
 129      */
 130     dso->loaded_filename = filename;
 131     return (1);
 132  err:
 133     /* Cleanup! */
 134     OPENSSL_free(filename);
 135     if (ptr != NULL)
 136         shl_unload(ptr);
 137     return (0);
 138 }
 139
 140 static int dl_unload(DSO *dso)
 141 {
 142     shl_t ptr;
 143     if (dso == NULL) {
 144         DSOerr(DSO_F_DL_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
 145         return (0);
 146     }
 147     if (sk_num(dso->meth_data) < 1)
 148         return (1);
 149     /* Is this statement legal? */
 150     ptr = (shl_t) sk_pop(dso->meth_data);
 151     if (ptr == NULL) {
 152         DSOerr(DSO_F_DL_UNLOAD, DSO_R_NULL_HANDLE);
 153         /*
 154          * Should push the value back onto the stack in case of a retry.
 155          */
 156         sk_push(dso->meth_data, (char *)ptr);
 157         return (0);
 158     }
 159     shl_unload(ptr);
 160     return (1);
 161 }
 162
 163 static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname)
 164 {
 165     shl_t ptr;
 166     void *sym;
 167
 168     if ((dso == NULL) || (symname == NULL)) {
 169         DSOerr(DSO_F_DL_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
 170         return (NULL);
 171     }
 172     if (sk_num(dso->meth_data) < 1) {
 173         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_STACK_ERROR);
 174         return (NULL);
 175     }
 176     ptr = (shl_t) sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
 177     if (ptr == NULL) {
 178         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_NULL_HANDLE);
 179         return (NULL);
 180     }
 181     if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0) {
 182         DSOerr(DSO_F_DL_BIND_FUNC, DSO_R_SYM_FAILURE);
 183         ERR_add_error_data(4, "symname(", symname, "): ", strerror(errno));
 184         return (NULL);
 185     }
 186     return ((DSO_FUNC_TYPE)sym);
 187 }
 188
 189 static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2)
 190 {
 191     char *merged;
 192
 193     if (!filespec1 && !filespec2) {
 194         DSOerr(DSO_F_DL_MERGER, ERR_R_PASSED_NULL_PARAMETER);
 195         return (NULL);
 196     }
 197     /*
 198      * If the first file specification is a rooted path, it rules. same goes
 199      * if the second file specification is missing.
 200      */
 201     if (!filespec2 || filespec1[0] == '/') {
 202         merged = OPENSSL_strdup(filespec1);
 203         if (merged == NULL) {
 204             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
 205             return (NULL);
 206         }
 207     }
 208     /*
 209      * If the first file specification is missing, the second one rules.
 210      */
 211     else if (!filespec1) {
 212         merged = OPENSSL_strdup(filespec2);
 213         if (merged == NULL) {
 214             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
 215             return (NULL);
 216         }
 217     } else
 218         /*
 219          * This part isn't as trivial as it looks.  It assumes that the
 220          * second file specification really is a directory, and makes no
 221          * checks whatsoever.  Therefore, the result becomes the
 222          * concatenation of filespec2 followed by a slash followed by
 223          * filespec1.
 224          */
 225     {
 226         int spec2len, len;
 227
 228         spec2len = (filespec2 ? strlen(filespec2) : 0);
 229         len = spec2len + (filespec1 ? strlen(filespec1) : 0);
 230
 231         if (spec2len && filespec2[spec2len - 1] == '/') {
 232             spec2len--;
 233             len--;
 234         }
 235         merged = OPENSSL_malloc(len + 2);
 236         if (merged == NULL) {
 237             DSOerr(DSO_F_DL_MERGER, ERR_R_MALLOC_FAILURE);
 238             return (NULL);
 239         }
 240         strcpy(merged, filespec2);
 241         merged[spec2len] = '/';
 242         strcpy(&merged[spec2len + 1], filespec1);
 243     }
 244     return (merged);
 245 }
 246
 247 /*
 248  * This function is identical to the one in dso_dlfcn.c, but as it is highly
 249  * unlikely that both the "dl" *and* "dlfcn" variants are being compiled at
 250  * the same time, there's no great duplicating the code. Figuring out an
 251  * elegant way to share one copy of the code would be more difficult and
 252  * would not leave the implementations independent.
 253  */
 254 static char *dl_name_converter(DSO *dso, const char *filename)
 255 {
 256     char *translated;
 257     int len, rsize, transform;
 258
 259     len = strlen(filename);
 260     rsize = len + 1;
 261     transform = (strstr(filename, "/") == NULL);
 262     {
 263         /* We will convert this to "%s.s?" or "lib%s.s?" */
 264         rsize += strlen(DSO_EXTENSION); /* The length of ".s?" */
 265         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 266             rsize += 3;         /* The length of "lib" */
 267     }
 268     translated = OPENSSL_malloc(rsize);
 269     if (translated == NULL) {
 270         DSOerr(DSO_F_DL_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
 271         return (NULL);
 272     }
 273     if (transform) {
 274         if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
 275             sprintf(translated, "lib%s%s", filename, DSO_EXTENSION);
 276         else
 277             sprintf(translated, "%s%s", filename, DSO_EXTENSION);
 278     } else
 279         sprintf(translated, "%s", filename);
 280     return (translated);
 281 }
 282
 283 static void *dl_globallookup(const char *name)
 284 {
 285     void *ret;
 286     shl_t h = NULL;
 287
 288     return shl_findsym(&h, name, TYPE_UNDEFINED, &ret) ? NULL : ret;
 289 }
 290 #endif                          /* DSO_DL */