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