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 (ret < 0 || ret >= end - pos)
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_zalloc(sizeof(char *) * (array_len + 1));
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