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
19static struct eap_method *eap_methods = NULL;
20
21static 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 */
30const 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 */
50EapType 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 */
73const 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 */
93size_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 */
128char ** 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 */
165const 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 */
184int 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 */
233int 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 */
281struct 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 */
300static 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 */
316int 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 */
351void 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