1 /* 2 * EAP peer: Method registration 3 * Copyright (c) 2004-2007, Jouni Malinen <j (at) 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 } 377
