1 /* 2 * Copyright (c) 2006 - 2007 Kungliga Tekniska H�gskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "krb5_locl.h" 35 RCSID("$Id: plugin.c 22033 2007-11-10 10:39:47Z lha $"); 36 #ifdef HAVE_DLFCN_H 37 #include <dlfcn.h> 38 #endif 39 #include <dirent.h> 40 41 struct krb5_plugin { 42 void *symbol; 43 void *dsohandle; 44 struct krb5_plugin *next; 45 }; 46 47 struct plugin { 48 enum krb5_plugin_type type; 49 void *name; 50 void *symbol; 51 struct plugin *next; 52 }; 53 54 static HEIMDAL_MUTEX plugin_mutex = HEIMDAL_MUTEX_INITIALIZER; 55 static struct plugin *registered = NULL; 56 57 static const char *plugin_dir = LIBDIR "/plugin/krb5"; 58 59 /* 60 * 61 */ 62 63 void * 64 _krb5_plugin_get_symbol(struct krb5_plugin *p) 65 { 66 return p->symbol; 67 } 68 69 struct krb5_plugin * 70 _krb5_plugin_get_next(struct krb5_plugin *p) 71 { 72 return p->next; 73 } 74 75 /* 76 * 77 */ 78 79 #ifdef HAVE_DLOPEN 80 81 static krb5_error_code 82 loadlib(krb5_context context, 83 enum krb5_plugin_type type, 84 const char *name, 85 const char *lib, 86 struct krb5_plugin **e) 87 { 88 *e = calloc(1, sizeof(**e)); 89 if (*e == NULL) { 90 krb5_set_error_string(context, "out of memory"); 91 return ENOMEM; 92 } 93 94 #ifndef RTLD_LAZY 95 #define RTLD_LAZY 0 96 #endif 97 98 (*e)->dsohandle = dlopen(lib, RTLD_LAZY); 99 if ((*e)->dsohandle == NULL) { 100 free(*e); 101 *e = NULL; 102 krb5_set_error_string(context, "Failed to load %s: %s", 103 lib, dlerror()); 104 return ENOMEM; 105 } 106 107 /* dlsym doesn't care about the type */ 108 (*e)->symbol = dlsym((*e)->dsohandle, name); 109 if ((*e)->symbol == NULL) { 110 dlclose((*e)->dsohandle); 111 free(*e); 112 krb5_clear_error_string(context); 113 return ENOMEM; 114 } 115 116 return 0; 117 } 118 #endif /* HAVE_DLOPEN */ 119 120 /** 121 * Register a plugin symbol name of specific type. 122 * @param context a Keberos context 123 * @param type type of plugin symbol 124 * @param name name of plugin symbol 125 * @param symbol a pointer to the named symbol 126 * @return In case of error a non zero error com_err error is returned 127 * and the Kerberos error string is set. 128 * 129 * @ingroup krb5_support 130 */ 131 132 krb5_error_code 133 krb5_plugin_register(krb5_context context, 134 enum krb5_plugin_type type, 135 const char *name, 136 void *symbol) 137 { 138 struct plugin *e; 139 140 e = calloc(1, sizeof(*e)); 141 if (e == NULL) { 142 krb5_set_error_string(context, "out of memory"); 143 return ENOMEM; 144 } 145 e->type = type; 146 e->name = strdup(name); 147 if (e->name == NULL) { 148 free(e); 149 krb5_set_error_string(context, "out of memory"); 150 return ENOMEM; 151 } 152 e->symbol = symbol; 153 154 HEIMDAL_MUTEX_lock(&plugin_mutex); 155 e->next = registered; 156 registered = e; 157 HEIMDAL_MUTEX_unlock(&plugin_mutex); 158 159 return 0; 160 } 161 162 krb5_error_code 163 _krb5_plugin_find(krb5_context context, 164 enum krb5_plugin_type type, 165 const char *name, 166 struct krb5_plugin **list) 167 { 168 struct krb5_plugin *e; 169 struct plugin *p; 170 krb5_error_code ret; 171 char *sysdirs[2] = { NULL, NULL }; 172 char **dirs = NULL, **di; 173 struct dirent *entry; 174 char *path; 175 DIR *d = NULL; 176 177 *list = NULL; 178 179 HEIMDAL_MUTEX_lock(&plugin_mutex); 180 181 for (p = registered; p != NULL; p = p->next) { 182 if (p->type != type || strcmp(p->name, name) != 0) 183 continue; 184 185 e = calloc(1, sizeof(*e)); 186 if (e == NULL) { 187 HEIMDAL_MUTEX_unlock(&plugin_mutex); 188 krb5_set_error_string(context, "out of memory"); 189 ret = ENOMEM; 190 goto out; 191 } 192 e->symbol = p->symbol; 193 e->dsohandle = NULL; 194 e->next = *list; 195 *list = e; 196 } 197 HEIMDAL_MUTEX_unlock(&plugin_mutex); 198 199 #ifdef HAVE_DLOPEN 200 201 dirs = krb5_config_get_strings(context, NULL, "libdefaults", 202 "plugin_dir", NULL); 203 if (dirs == NULL) { 204 sysdirs[0] = rk_UNCONST(plugin_dir); 205 dirs = sysdirs; 206 } 207 208 for (di = dirs; *di != NULL; di++) { 209 210 d = opendir(*di); 211 if (d == NULL) 212 continue; 213 214 while ((entry = readdir(d)) != NULL) { 215 asprintf(&path, "%s/%s", *di, entry->d_name); 216 if (path == NULL) { 217 krb5_set_error_string(context, "out of memory"); 218 ret = ENOMEM; 219 goto out; 220 } 221 ret = loadlib(context, type, name, path, &e); 222 free(path); 223 if (ret) 224 continue; 225 226 e->next = *list; 227 *list = e; 228 } 229 closedir(d); 230 } 231 if (dirs != sysdirs) 232 krb5_config_free_strings(dirs); 233 #endif /* HAVE_DLOPEN */ 234 235 if (*list == NULL) { 236 krb5_set_error_string(context, "Did not find a plugin for %s", name); 237 return ENOENT; 238 } 239 240 return 0; 241 242 out: 243 if (dirs && dirs != sysdirs) 244 krb5_config_free_strings(dirs); 245 if (d) 246 closedir(d); 247 _krb5_plugin_free(*list); 248 *list = NULL; 249 250 return ret; 251 } 252 253 void 254 _krb5_plugin_free(struct krb5_plugin *list) 255 { 256 struct krb5_plugin *next; 257 while (list) { 258 next = list->next; 259 if (list->dsohandle) 260 dlclose(list->dsohandle); 261 free(list); 262 list = next; 263 } 264 } 265