1/*
2 * EAP peer: Method registration
3 * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15#include "includes.h"
16#ifdef CONFIG_DYNAMIC_EAP_METHODS
17#include <dlfcn.h>
18#endif /* CONFIG_DYNAMIC_EAP_METHODS */
19
20#include "common.h"
21#include "eap_i.h"
22#include "eap_methods.h"
23
24
25static struct eap_method *eap_methods = NULL;
26
27
28/**
29 * eap_peer_get_eap_method - Get EAP method based on type number
30 * @vendor: EAP Vendor-Id (0 = IETF)
31 * @method: EAP type number
32 * Returns: Pointer to EAP method or %NULL if not found
33 */
34const struct eap_method * eap_peer_get_eap_method(int vendor, EapType method)
35{
36	struct eap_method *m;
37	for (m = eap_methods; m; m = m->next) {
38		if (m->vendor == vendor && m->method == method)
39			return m;
40	}
41	return NULL;
42}
43
44
45/**
46 * eap_peer_get_type - Get EAP type for the given EAP method name
47 * @name: EAP method name, e.g., TLS
48 * @vendor: Buffer for returning EAP Vendor-Id
49 * Returns: EAP method type or %EAP_TYPE_NONE if not found
50 *
51 * This function maps EAP type names into EAP type numbers based on the list of
52 * EAP methods included in the build.
53 */
54EapType eap_peer_get_type(const char *name, int *vendor)
55{
56	struct eap_method *m;
57	for (m = eap_methods; m; m = m->next) {
58		if (os_strcmp(m->name, name) == 0) {
59			*vendor = m->vendor;
60			return m->method;
61		}
62	}
63	*vendor = EAP_VENDOR_IETF;
64	return EAP_TYPE_NONE;
65}
66
67
68/**
69 * eap_get_name - Get EAP method name for the given EAP type
70 * @vendor: EAP Vendor-Id (0 = IETF)
71 * @type: EAP method type
72 * Returns: EAP method name, e.g., TLS, or %NULL if not found
73 *
74 * This function maps EAP type numbers into EAP type names based on the list of
75 * EAP methods included in the build.
76 */
77const char * eap_get_name(int vendor, EapType type)
78{
79	struct eap_method *m;
80	for (m = eap_methods; m; m = m->next) {
81		if (m->vendor == vendor && m->method == type)
82			return m->name;
83	}
84	return NULL;
85}
86
87
88/**
89 * eap_get_names - Get space separated list of names for supported EAP methods
90 * @buf: Buffer for names
91 * @buflen: Buffer length
92 * Returns: Number of characters written into buf (not including nul
93 * termination)
94 */
95size_t eap_get_names(char *buf, size_t buflen)
96{
97	char *pos, *end;
98	struct eap_method *m;
99	int ret;
100
101	if (buflen == 0)
102		return 0;
103
104	pos = buf;
105	end = pos + buflen;
106
107	for (m = eap_methods; m; m = m->next) {
108		ret = os_snprintf(pos, end - pos, "%s%s",
109				  m == eap_methods ? "" : " ", m->name);
110		if (ret < 0 || ret >= end - pos)
111			break;
112		pos += ret;
113	}
114	buf[buflen - 1] = '\0';
115
116	return pos - buf;
117}
118
119
120/**
121 * eap_get_names_as_string_array - Get supported EAP methods as string array
122 * @num: Buffer for returning the number of items in array, not including %NULL
123 * terminator. This parameter can be %NULL if the length is not needed.
124 * Returns: A %NULL-terminated array of strings, or %NULL on error.
125 *
126 * This function returns the list of names for all supported EAP methods as an
127 * array of strings. The caller must free the returned array items and the
128 * array.
129 */
130char ** eap_get_names_as_string_array(size_t *num)
131{
132	struct eap_method *m;
133	size_t array_len = 0;
134	char **array;
135	int i = 0, j;
136
137	for (m = eap_methods; m; m = m->next)
138		array_len++;
139
140	array = os_zalloc(sizeof(char *) * (array_len + 1));
141	if (array == NULL)
142		return NULL;
143
144	for (m = eap_methods; m; m = m->next) {
145		array[i++] = os_strdup(m->name);
146		if (array[i - 1] == NULL) {
147			for (j = 0; j < i; j++)
148				os_free(array[j]);
149			os_free(array);
150			return NULL;
151		}
152	}
153	array[i] = NULL;
154
155	if (num)
156		*num = array_len;
157
158	return array;
159}
160
161
162/**
163 * eap_peer_get_methods - Get a list of enabled EAP peer methods
164 * @count: Set to number of available methods
165 * Returns: List of enabled EAP peer methods
166 */
167const struct eap_method * eap_peer_get_methods(size_t *count)
168{
169	int c = 0;
170	struct eap_method *m;
171
172	for (m = eap_methods; m; m = m->next)
173		c++;
174
175	*count = c;
176	return eap_methods;
177}
178
179
180#ifdef CONFIG_DYNAMIC_EAP_METHODS
181/**
182 * eap_peer_method_load - Load a dynamic EAP method library (shared object)
183 * @so: File path for the shared object file to load
184 * Returns: 0 on success, -1 on failure
185 */
186int eap_peer_method_load(const char *so)
187{
188	void *handle;
189	int (*dyn_init)(void);
190	int ret;
191
192	handle = dlopen(so, RTLD_LAZY);
193	if (handle == NULL) {
194		wpa_printf(MSG_ERROR, "EAP: Failed to open dynamic EAP method "
195			   "'%s': %s", so, dlerror());
196		return -1;
197	}
198
199	dyn_init = dlsym(handle, "eap_peer_method_dynamic_init");
200	if (dyn_init == NULL) {
201		dlclose(handle);
202		wpa_printf(MSG_ERROR, "EAP: Invalid EAP method '%s' - no "
203			   "eap_peer_method_dynamic_init()", so);
204		return -1;
205	}
206
207	ret = dyn_init();
208	if (ret) {
209		dlclose(handle);
210		wpa_printf(MSG_ERROR, "EAP: Failed to add EAP method '%s' - "
211			   "ret %d", so, ret);
212		return ret;
213	}
214
215	/* Store the handle for this shared object. It will be freed with
216	 * dlclose() when the EAP method is unregistered. */
217	eap_methods->dl_handle = handle;
218
219	wpa_printf(MSG_DEBUG, "EAP: Loaded dynamic EAP method: '%s'", so);
220
221	return 0;
222}
223
224
225/**
226 * eap_peer_method_unload - Unload a dynamic EAP method library (shared object)
227 * @method: Pointer to the dynamically loaded EAP method
228 * Returns: 0 on success, -1 on failure
229 *
230 * This function can be used to unload EAP methods that have been previously
231 * loaded with eap_peer_method_load(). Before unloading the method, all
232 * references to the method must be removed to make sure that no dereferences
233 * of freed memory will occur after unloading.
234 */
235int eap_peer_method_unload(struct eap_method *method)
236{
237	struct eap_method *m, *prev;
238	void *handle;
239
240	m = eap_methods;
241	prev = NULL;
242	while (m) {
243		if (m == method)
244			break;
245		prev = m;
246		m = m->next;
247	}
248
249	if (m == NULL || m->dl_handle == NULL)
250		return -1;
251
252	if (prev)
253		prev->next = m->next;
254	else
255		eap_methods = m->next;
256
257	handle = m->dl_handle;
258
259	if (m->free)
260		m->free(m);
261	else
262		eap_peer_method_free(m);
263
264	dlclose(handle);
265
266	return 0;
267}
268#endif /* CONFIG_DYNAMIC_EAP_METHODS */
269
270
271/**
272 * eap_peer_method_alloc - Allocate EAP peer method structure
273 * @version: Version of the EAP peer method interface (set to
274 * EAP_PEER_METHOD_INTERFACE_VERSION)
275 * @vendor: EAP Vendor-ID (EAP_VENDOR_*) (0 = IETF)
276 * @method: EAP type number (EAP_TYPE_*)
277 * @name: Name of the method (e.g., "TLS")
278 * Returns: Allocated EAP method structure or %NULL on failure
279 *
280 * The returned structure should be freed with eap_peer_method_free() when it
281 * is not needed anymore.
282 */
283struct eap_method * eap_peer_method_alloc(int version, int vendor,
284					  EapType method, const char *name)
285{
286	struct eap_method *eap;
287	eap = os_zalloc(sizeof(*eap));
288	if (eap == NULL)
289		return NULL;
290	eap->version = version;
291	eap->vendor = vendor;
292	eap->method = method;
293	eap->name = name;
294	return eap;
295}
296
297
298/**
299 * eap_peer_method_free - Free EAP peer method structure
300 * @method: Method structure allocated with eap_peer_method_alloc()
301 */
302void eap_peer_method_free(struct eap_method *method)
303{
304	os_free(method);
305}
306
307
308/**
309 * eap_peer_method_register - Register an EAP peer method
310 * @method: EAP method to register
311 * Returns: 0 on success, -1 on invalid method, or -2 if a matching EAP method
312 * has already been registered
313 *
314 * Each EAP peer method needs to call this function to register itself as a
315 * supported EAP method.
316 */
317int eap_peer_method_register(struct eap_method *method)
318{
319	struct eap_method *m, *last = NULL;
320
321	if (method == NULL || method->name == NULL ||
322	    method->version != EAP_PEER_METHOD_INTERFACE_VERSION)
323		return -1;
324
325	for (m = eap_methods; m; m = m->next) {
326		if ((m->vendor == method->vendor &&
327		     m->method == method->method) ||
328		    os_strcmp(m->name, method->name) == 0)
329			return -2;
330		last = m;
331	}
332
333	if (last)
334		last->next = method;
335	else
336		eap_methods = method;
337
338	return 0;
339}
340
341
342/**
343 * eap_peer_register_methods - Register statically linked EAP peer methods
344 * Returns: 0 on success, -1 on failure
345 *
346 * This function is called at program initialization to register all EAP peer
347 * methods that were linked in statically.
348 */
349int eap_peer_register_methods(void)
350{
351	int ret = 0;
352
353#ifdef EAP_MD5
354	if (ret == 0) {
355		int eap_peer_md5_register(void);
356		ret = eap_peer_md5_register();
357	}
358#endif /* EAP_MD5 */
359
360#ifdef EAP_TLS
361	if (ret == 0) {
362		int eap_peer_tls_register(void);
363		ret = eap_peer_tls_register();
364	}
365#endif /* EAP_TLS */
366
367#ifdef EAP_MSCHAPv2
368	if (ret == 0) {
369		int eap_peer_mschapv2_register(void);
370		ret = eap_peer_mschapv2_register();
371	}
372#endif /* EAP_MSCHAPv2 */
373
374#ifdef EAP_PEAP
375	if (ret == 0) {
376		int eap_peer_peap_register(void);
377		ret = eap_peer_peap_register();
378	}
379#endif /* EAP_PEAP */
380
381#ifdef EAP_TTLS
382	if (ret == 0) {
383		int eap_peer_ttls_register(void);
384		ret = eap_peer_ttls_register();
385	}
386#endif /* EAP_TTLS */
387
388#ifdef EAP_GTC
389	if (ret == 0) {
390		int eap_peer_gtc_register(void);
391		ret = eap_peer_gtc_register();
392	}
393#endif /* EAP_GTC */
394
395#ifdef EAP_OTP
396	if (ret == 0) {
397		int eap_peer_otp_register(void);
398		ret = eap_peer_otp_register();
399	}
400#endif /* EAP_OTP */
401
402#ifdef EAP_SIM
403	if (ret == 0) {
404		int eap_peer_sim_register(void);
405		ret = eap_peer_sim_register();
406	}
407#endif /* EAP_SIM */
408
409#ifdef EAP_LEAP
410	if (ret == 0) {
411		int eap_peer_leap_register(void);
412		ret = eap_peer_leap_register();
413	}
414#endif /* EAP_LEAP */
415
416#ifdef EAP_PSK
417	if (ret == 0) {
418		int eap_peer_psk_register(void);
419		ret = eap_peer_psk_register();
420	}
421#endif /* EAP_PSK */
422
423#ifdef EAP_AKA
424	if (ret == 0) {
425		int eap_peer_aka_register(void);
426		ret = eap_peer_aka_register();
427	}
428#endif /* EAP_AKA */
429
430#ifdef EAP_AKA_PRIME
431	if (ret == 0) {
432		int eap_peer_aka_prime_register(void);
433		ret = eap_peer_aka_prime_register();
434	}
435#endif /* EAP_AKA_PRIME */
436
437#ifdef EAP_FAST
438	if (ret == 0) {
439		int eap_peer_fast_register(void);
440		ret = eap_peer_fast_register();
441	}
442#endif /* EAP_FAST */
443
444#ifdef EAP_PAX
445	if (ret == 0) {
446		int eap_peer_pax_register(void);
447		ret = eap_peer_pax_register();
448	}
449#endif /* EAP_PAX */
450
451#ifdef EAP_SAKE
452	if (ret == 0) {
453		int eap_peer_sake_register(void);
454		ret = eap_peer_sake_register();
455	}
456#endif /* EAP_SAKE */
457
458#ifdef EAP_GPSK
459	if (ret == 0) {
460		int eap_peer_gpsk_register(void);
461		ret = eap_peer_gpsk_register();
462	}
463#endif /* EAP_GPSK */
464
465#ifdef EAP_WSC
466	if (ret == 0) {
467		int eap_peer_wsc_register(void);
468		ret = eap_peer_wsc_register();
469	}
470#endif /* EAP_WSC */
471
472#ifdef EAP_IKEV2
473	if (ret == 0) {
474		int eap_peer_ikev2_register(void);
475		ret = eap_peer_ikev2_register();
476	}
477#endif /* EAP_IKEV2 */
478
479#ifdef EAP_VENDOR_TEST
480	if (ret == 0) {
481		int eap_peer_vendor_test_register(void);
482		ret = eap_peer_vendor_test_register();
483	}
484#endif /* EAP_VENDOR_TEST */
485
486#ifdef EAP_TNC
487	if (ret == 0) {
488		int eap_peer_tnc_register(void);
489		ret = eap_peer_tnc_register();
490	}
491#endif /* EAP_TNC */
492
493	return ret;
494}
495
496
497/**
498 * eap_peer_unregister_methods - Unregister EAP peer methods
499 *
500 * This function is called at program termination to unregister all EAP peer
501 * methods.
502 */
503void eap_peer_unregister_methods(void)
504{
505	struct eap_method *m;
506#ifdef CONFIG_DYNAMIC_EAP_METHODS
507	void *handle;
508#endif /* CONFIG_DYNAMIC_EAP_METHODS */
509
510	while (eap_methods) {
511		m = eap_methods;
512		eap_methods = eap_methods->next;
513
514#ifdef CONFIG_DYNAMIC_EAP_METHODS
515		handle = m->dl_handle;
516#endif /* CONFIG_DYNAMIC_EAP_METHODS */
517
518		if (m->free)
519			m->free(m);
520		else
521			eap_peer_method_free(m);
522
523#ifdef CONFIG_DYNAMIC_EAP_METHODS
524		if (handle)
525			dlclose(handle);
526#endif /* CONFIG_DYNAMIC_EAP_METHODS */
527	}
528}
529