libeap/src/eap_peer/eap_methods.c

   1 /*
   2  * EAP peer: Method registration
   3  * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10 #ifdef CONFIG_DYNAMIC_EAP_METHODS
  11 #include <dlfcn.h>
  12 #endif /* CONFIG_DYNAMIC_EAP_METHODS */
  13
  14 #include "common.h"
  15 #include "eap_i.h"
  16 #include "eap_methods.h"
  17
  18
  19 static struct eap_method *eap_methods = NULL;
  20
  21 static void eap_peer_method_free(struct eap_method *method);
  22
  23
  24 /**
  25  * eap_peer_get_eap_method - Get EAP method based on type number
  26  * @vendor: EAP Vendor-Id (0 = IETF)
  27  * @method: EAP type number
  28  * Returns: Pointer to EAP method or %NULL if not found
  29  */
  30 const struct eap_method * eap_peer_get_eap_method(int vendor, EapType method)
  31 {
  32         struct eap_method *m;
  33         for (m = eap_methods; m; m = m->next) {
  34                 if (m->vendor == vendor && m->method == method)
  35                         return m;
  36         }
  37         return NULL;
  38 }
  39
  40
  41 /**
  42  * eap_peer_get_type - Get EAP type for the given EAP method name
  43  * @name: EAP method name, e.g., TLS
  44  * @vendor: Buffer for returning EAP Vendor-Id
  45  * Returns: EAP method type or %EAP_TYPE_NONE if not found
  46  *
  47  * This function maps EAP type names into EAP type numbers based on the list of
  48  * EAP methods included in the build.
  49  */
  50 EapType eap_peer_get_type(const char *name, int *vendor)
  51 {
  52         struct eap_method *m;
  53         for (m = eap_methods; m; m = m->next) {
  54                 if (os_strcmp(m->name, name) == 0) {
  55                         *vendor = m->vendor;
  56                         return m->method;
  57                 }
  58         }
  59         *vendor = EAP_VENDOR_IETF;
  60         return EAP_TYPE_NONE;
  61 }
  62
  63
  64 /**
  65  * eap_get_name - Get EAP method name for the given EAP type
  66  * @vendor: EAP Vendor-Id (0 = IETF)
  67  * @type: EAP method type
  68  * Returns: EAP method name, e.g., TLS, or %NULL if not found
  69  *
  70  * This function maps EAP type numbers into EAP type names based on the list of
  71  * EAP methods included in the build.
  72  */
  73 const char * eap_get_name(int vendor, EapType type)
  74 {
  75         struct eap_method *m;
  76         if (vendor == EAP_VENDOR_IETF && type == EAP_TYPE_EXPANDED)
  77                 return "expanded";
  78         for (m = eap_methods; m; m = m->next) {
  79                 if (m->vendor == vendor && m->method == type)
  80                         return m->name;
  81         }
  82         return NULL;
  83 }
  84
  85
  86 /**
  87  * eap_get_names - Get space separated list of names for supported EAP methods
  88  * @buf: Buffer for names
  89  * @buflen: Buffer length
  90  * Returns: Number of characters written into buf (not including nul
  91  * termination)
  92  */
  93 size_t eap_get_names(char *buf, size_t buflen)
  94 {
  95         char *pos, *end;
  96         struct eap_method *m;
  97         int ret;
  98
  99         if (buflen == 0)
 100                 return 0;
 101
 102         pos = buf;
 103         end = pos + buflen;
 104
 105         for (m = eap_methods; m; m = m->next) {
 106                 ret = os_snprintf(pos, end - pos, "%s%s",
 107                                   m == eap_methods ? "" : " ", m->name);
 108                 if (os_snprintf_error(end - pos, ret))
 109                         break;
 110                 pos += ret;
 111         }
 112         buf[buflen - 1] = '\0';
 113
 114         return pos - buf;
 115 }
 116
 117
 118 /**
 119  * eap_get_names_as_string_array - Get supported EAP methods as string array
 120  * @num: Buffer for returning the number of items in array, not including %NULL
 121  * terminator. This parameter can be %NULL if the length is not needed.
 122  * Returns: A %NULL-terminated array of strings, or %NULL on error.
 123  *
 124  * This function returns the list of names for all supported EAP methods as an
 125  * array of strings. The caller must free the returned array items and the
 126  * array.
 127  */
 128 char ** eap_get_names_as_string_array(size_t *num)
 129 {
 130         struct eap_method *m;
 131         size_t array_len = 0;
 132         char **array;
 133         int i = 0, j;
 134
 135         for (m = eap_methods; m; m = m->next)
 136                 array_len++;
 137
 138         array = os_calloc(array_len + 1, sizeof(char *));
 139         if (array == NULL)
 140                 return NULL;
 141
 142         for (m = eap_methods; m; m = m->next) {
 143                 array[i++] = os_strdup(m->name);
 144                 if (array[i - 1] == NULL) {
 145                         for (j = 0; j < i; j++)
 146                                 os_free(array[j]);
 147                         os_free(array);
 148                         return NULL;
 149                 }
 150         }
 151         array[i] = NULL;
 152
 153         if (num)
 154                 *num = array_len;
 155
 156         return array;
 157 }
 158
 159
 160 /**
 161  * eap_peer_get_methods - Get a list of enabled EAP peer methods
 162  * @count: Set to number of available methods
 163  * Returns: List of enabled EAP peer methods
 164  */
 165 const struct eap_method * eap_peer_get_methods(size_t *count)
 166 {
 167         int c = 0;
 168         struct eap_method *m;
 169
 170         for (m = eap_methods; m; m = m->next)
 171                 c++;
 172
 173         *count = c;
 174         return eap_methods;
 175 }
 176
 177
 178 #ifdef CONFIG_DYNAMIC_EAP_METHODS
 179 /**
 180  * eap_peer_method_load - Load a dynamic EAP method library (shared object)
 181  * @so: File path for the shared object file to load
 182  * Returns: 0 on success, -1 on failure
 183  */
 184 int eap_peer_method_load(const char *so)
 185 {
 186         void *handle;
 187         int (*dyn_init)(void);
 188         int ret;
 189
 190         handle = dlopen(so, RTLD_LAZY);
 191         if (handle == NULL) {
 192                 wpa_printf(MSG_ERROR, "EAP: Failed to open dynamic EAP method "
 193                            "'%s': %s", so, dlerror());
 194                 return -1;
 195         }
 196
 197         dyn_init = dlsym(handle, "eap_peer_method_dynamic_init");
 198         if (dyn_init == NULL) {
 199                 dlclose(handle);
 200                 wpa_printf(MSG_ERROR, "EAP: Invalid EAP method '%s' - no "
 201                            "eap_peer_method_dynamic_init()", so);
 202                 return -1;
 203         }
 204
 205         ret = dyn_init();
 206         if (ret) {
 207                 dlclose(handle);
 208                 wpa_printf(MSG_ERROR, "EAP: Failed to add EAP method '%s' - "
 209                            "ret %d", so, ret);
 210                 return ret;
 211         }
 212
 213         /* Store the handle for this shared object. It will be freed with
 214          * dlclose() when the EAP method is unregistered. */
 215         eap_methods->dl_handle = handle;
 216
 217         wpa_printf(MSG_DEBUG, "EAP: Loaded dynamic EAP method: '%s'", so);
 218
 219         return 0;
 220 }
 221
 222
 223 /**
 224  * eap_peer_method_unload - Unload a dynamic EAP method library (shared object)
 225  * @method: Pointer to the dynamically loaded EAP method
 226  * Returns: 0 on success, -1 on failure
 227  *
 228  * This function can be used to unload EAP methods that have been previously
 229  * loaded with eap_peer_method_load(). Before unloading the method, all
 230  * references to the method must be removed to make sure that no dereferences
 231  * of freed memory will occur after unloading.
 232  */
 233 int eap_peer_method_unload(struct eap_method *method)
 234 {
 235         struct eap_method *m, *prev;
 236         void *handle;
 237
 238         m = eap_methods;
 239         prev = NULL;
 240         while (m) {
 241                 if (m == method)
 242                         break;
 243                 prev = m;
 244                 m = m->next;
 245         }
 246
 247         if (m == NULL || m->dl_handle == NULL)
 248                 return -1;
 249
 250         if (prev)
 251                 prev->next = m->next;
 252         else
 253                 eap_methods = m->next;
 254
 255         handle = m->dl_handle;
 256
 257         if (m->free)
 258                 m->free(m);
 259         else
 260                 eap_peer_method_free(m);
 261
 262         dlclose(handle);
 263
 264         return 0;
 265 }
 266 #endif /* CONFIG_DYNAMIC_EAP_METHODS */
 267
 268
 269 /**
 270  * eap_peer_method_alloc - Allocate EAP peer method structure
 271  * @version: Version of the EAP peer method interface (set to
 272  * EAP_PEER_METHOD_INTERFACE_VERSION)
 273  * @vendor: EAP Vendor-ID (EAP_VENDOR_*) (0 = IETF)
 274  * @method: EAP type number (EAP_TYPE_*)
 275  * @name: Name of the method (e.g., "TLS")
 276  * Returns: Allocated EAP method structure or %NULL on failure
 277  *
 278  * The returned structure should be freed with eap_peer_method_free() when it
 279  * is not needed anymore.
 280  */
 281 struct eap_method * eap_peer_method_alloc(int version, int vendor,
 282                                           EapType method, const char *name)
 283 {
 284         struct eap_method *eap;
 285         eap = os_zalloc(sizeof(*eap));
 286         if (eap == NULL)
 287                 return NULL;
 288         eap->version = version;
 289         eap->vendor = vendor;
 290         eap->method = method;
 291         eap->name = name;
 292         return eap;
 293 }
 294
 295
 296 /**
 297  * eap_peer_method_free - Free EAP peer method structure
 298  * @method: Method structure allocated with eap_peer_method_alloc()
 299  */
 300 static void eap_peer_method_free(struct eap_method *method)
 301 {
 302         os_free(method);
 303 }
 304
 305
 306 /**
 307  * eap_peer_method_register - Register an EAP peer method
 308  * @method: EAP method to register from eap_peer_method_alloc()
 309  * Returns: 0 on success, -1 on invalid method, or -2 if a matching EAP method
 310  * has already been registered
 311  *
 312  * Each EAP peer method needs to call this function to register itself as a
 313  * supported EAP method. The caller must not free the allocated method data
 314  * regardless of the return value.
 315  */
 316 int eap_peer_method_register(struct eap_method *method)
 317 {
 318         struct eap_method *m, *last = NULL;
 319
 320         if (method == NULL || method->name == NULL ||
 321             method->version != EAP_PEER_METHOD_INTERFACE_VERSION) {
 322                 eap_peer_method_free(method);
 323                 return -1;
 324         }
 325
 326         for (m = eap_methods; m; m = m->next) {
 327                 if ((m->vendor == method->vendor &&
 328                      m->method == method->method) ||
 329                     os_strcmp(m->name, method->name) == 0) {
 330                         eap_peer_method_free(method);
 331                         return -2;
 332                 }
 333                 last = m;
 334         }
 335
 336         if (last)
 337                 last->next = method;
 338         else
 339                 eap_methods = method;
 340
 341         return 0;
 342 }
 343
 344
 345 /**
 346  * eap_peer_unregister_methods - Unregister EAP peer methods
 347  *
 348  * This function is called at program termination to unregister all EAP peer
 349  * methods.
 350  */
 351 void eap_peer_unregister_methods(void)
 352 {
 353         struct eap_method *m;
 354 #ifdef CONFIG_DYNAMIC_EAP_METHODS
 355         void *handle;
 356 #endif /* CONFIG_DYNAMIC_EAP_METHODS */
 357
 358         while (eap_methods) {
 359                 m = eap_methods;
 360                 eap_methods = eap_methods->next;
 361
 362 #ifdef CONFIG_DYNAMIC_EAP_METHODS
 363                 handle = m->dl_handle;
 364 #endif /* CONFIG_DYNAMIC_EAP_METHODS */
 365
 366                 if (m->free)
 367                         m->free(m);
 368                 else
 369                         eap_peer_method_free(m);
 370
 371 #ifdef CONFIG_DYNAMIC_EAP_METHODS
 372                 if (handle)
 373                         dlclose(handle);
 374 #endif /* CONFIG_DYNAMIC_EAP_METHODS */
 375         }
 376 }