[thirdparty/hostap.git] / src / eap_peer / eap_methods.c

/*
 * EAP peer: Method registration
 * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"
#ifdef CONFIG_DYNAMIC_EAP_METHODS
#include <dlfcn.h>
#endif /* CONFIG_DYNAMIC_EAP_METHODS */

#include "common.h"
#include "eap_i.h"
#include "eap_methods.h"


static struct eap_method *eap_methods = NULL;

static void eap_peer_method_free(struct eap_method *method);


/**
 * eap_peer_get_eap_method - Get EAP method based on type number
 * @vendor: EAP Vendor-Id (0 = IETF)
 * @method: EAP type number
 * Returns: Pointer to EAP method or %NULL if not found
 */
const struct eap_method * eap_peer_get_eap_method(int vendor, EapType method)
{
	struct eap_method *m;
	for (m = eap_methods; m; m = m->next) {
		if (m->vendor == vendor && m->method == method)
			return m;
	}
	return NULL;
}


/**
 * eap_peer_get_type - Get EAP type for the given EAP method name
 * @name: EAP method name, e.g., TLS
 * @vendor: Buffer for returning EAP Vendor-Id
 * Returns: EAP method type or %EAP_TYPE_NONE if not found
 *
 * This function maps EAP type names into EAP type numbers based on the list of
 * EAP methods included in the build.
 */
EapType eap_peer_get_type(const char *name, int *vendor)
{
	struct eap_method *m;
	for (m = eap_methods; m; m = m->next) {
		if (os_strcmp(m->name, name) == 0) {
			*vendor = m->vendor;
			return m->method;
		}
	}
	*vendor = EAP_VENDOR_IETF;
	return EAP_TYPE_NONE;
}


/**
 * eap_get_name - Get EAP method name for the given EAP type
 * @vendor: EAP Vendor-Id (0 = IETF)
 * @type: EAP method type
 * Returns: EAP method name, e.g., TLS, or %NULL if not found
 *
 * This function maps EAP type numbers into EAP type names based on the list of
 * EAP methods included in the build.
 */
const char * eap_get_name(int vendor, EapType type)
{
	struct eap_method *m;
	if (vendor == EAP_VENDOR_IETF && type == EAP_TYPE_EXPANDED)
		return "expanded";
	for (m = eap_methods; m; m = m->next) {
		if (m->vendor == vendor && m->method == type)
			return m->name;
	}
	return NULL;
}


/**
 * eap_get_names - Get space separated list of names for supported EAP methods
 * @buf: Buffer for names
 * @buflen: Buffer length
 * Returns: Number of characters written into buf (not including nul
 * termination)
 */
size_t eap_get_names(char *buf, size_t buflen)
{
	char *pos, *end;
	struct eap_method *m;
	int ret;

	if (buflen == 0)
		return 0;

	pos = buf;
	end = pos + buflen;

	for (m = eap_methods; m; m = m->next) {
		ret = os_snprintf(pos, end - pos, "%s%s",
				  m == eap_methods ? "" : " ", m->name);
		if (os_snprintf_error(end - pos, ret))
			break;
		pos += ret;
	}
	buf[buflen - 1] = '\0';

	return pos - buf;
}


/**
 * eap_get_names_as_string_array - Get supported EAP methods as string array
 * @num: Buffer for returning the number of items in array, not including %NULL
 * terminator. This parameter can be %NULL if the length is not needed.
 * Returns: A %NULL-terminated array of strings, or %NULL on error.
 *
 * This function returns the list of names for all supported EAP methods as an
 * array of strings. The caller must free the returned array items and the
 * array.
 */
char ** eap_get_names_as_string_array(size_t *num)
{
	struct eap_method *m;
	size_t array_len = 0;
	char **array;
	int i = 0, j;

	for (m = eap_methods; m; m = m->next)
		array_len++;

	array = os_calloc(array_len + 1, sizeof(char *));
	if (array == NULL)
		return NULL;

	for (m = eap_methods; m; m = m->next) {
		array[i++] = os_strdup(m->name);
		if (array[i - 1] == NULL) {
			for (j = 0; j < i; j++)
				os_free(array[j]);
			os_free(array);
			return NULL;
		}
	}
	array[i] = NULL;

	if (num)
		*num = array_len;

	return array;
}


/**
 * eap_peer_get_methods - Get a list of enabled EAP peer methods
 * @count: Set to number of available methods
 * Returns: List of enabled EAP peer methods
 */
const struct eap_method * eap_peer_get_methods(size_t *count)
{
	int c = 0;
	struct eap_method *m;

	for (m = eap_methods; m; m = m->next)
		c++;
	
	*count = c;
	return eap_methods;
}


#ifdef CONFIG_DYNAMIC_EAP_METHODS
/**
 * eap_peer_method_load - Load a dynamic EAP method library (shared object)
 * @so: File path for the shared object file to load
 * Returns: 0 on success, -1 on failure
 */
int eap_peer_method_load(const char *so)
{
	void *handle;
	int (*dyn_init)(void);
	int ret;

	handle = dlopen(so, RTLD_LAZY);
	if (handle == NULL) {
		wpa_printf(MSG_ERROR, "EAP: Failed to open dynamic EAP method "
			   "'%s': %s", so, dlerror());
		return -1;
	}

	dyn_init = dlsym(handle, "eap_peer_method_dynamic_init");
	if (dyn_init == NULL) {
		dlclose(handle);
		wpa_printf(MSG_ERROR, "EAP: Invalid EAP method '%s' - no "
			   "eap_peer_method_dynamic_init()", so);
		return -1;
	}

	ret = dyn_init();
	if (ret) {
		dlclose(handle);
		wpa_printf(MSG_ERROR, "EAP: Failed to add EAP method '%s' - "
			   "ret %d", so, ret);
		return ret;
	}

	/* Store the handle for this shared object. It will be freed with
	 * dlclose() when the EAP method is unregistered. */
	eap_methods->dl_handle = handle;

	wpa_printf(MSG_DEBUG, "EAP: Loaded dynamic EAP method: '%s'", so);

	return 0;
}


/**
 * eap_peer_method_unload - Unload a dynamic EAP method library (shared object)
 * @method: Pointer to the dynamically loaded EAP method
 * Returns: 0 on success, -1 on failure
 *
 * This function can be used to unload EAP methods that have been previously
 * loaded with eap_peer_method_load(). Before unloading the method, all
 * references to the method must be removed to make sure that no dereferences
 * of freed memory will occur after unloading.
 */
int eap_peer_method_unload(struct eap_method *method)
{
	struct eap_method *m, *prev;
	void *handle;

	m = eap_methods;
	prev = NULL;
	while (m) {
		if (m == method)
			break;
		prev = m;
		m = m->next;
	}

	if (m == NULL || m->dl_handle == NULL)
		return -1;

	if (prev)
		prev->next = m->next;
	else
		eap_methods = m->next;

	handle = m->dl_handle;

	if (m->free)
		m->free(m);
	else
		eap_peer_method_free(m);

	dlclose(handle);

	return 0;
}
#endif /* CONFIG_DYNAMIC_EAP_METHODS */


/**
 * eap_peer_method_alloc - Allocate EAP peer method structure
 * @version: Version of the EAP peer method interface (set to
 * EAP_PEER_METHOD_INTERFACE_VERSION)
 * @vendor: EAP Vendor-ID (EAP_VENDOR_*) (0 = IETF)
 * @method: EAP type number (EAP_TYPE_*)
 * @name: Name of the method (e.g., "TLS")
 * Returns: Allocated EAP method structure or %NULL on failure
 *
 * The returned structure should be freed with eap_peer_method_free() when it
 * is not needed anymore.
 */
struct eap_method * eap_peer_method_alloc(int version, int vendor,
					  EapType method, const char *name)
{
	struct eap_method *eap;
	eap = os_zalloc(sizeof(*eap));
	if (eap == NULL)
		return NULL;
	eap->version = version;
	eap->vendor = vendor;
	eap->method = method;
	eap->name = name;
	return eap;
}


/**
 * eap_peer_method_free - Free EAP peer method structure
 * @method: Method structure allocated with eap_peer_method_alloc()
 */
static void eap_peer_method_free(struct eap_method *method)
{
	os_free(method);
}


/**
 * eap_peer_method_register - Register an EAP peer method
 * @method: EAP method to register from eap_peer_method_alloc()
 * Returns: 0 on success, -1 on invalid method, or -2 if a matching EAP method
 * has already been registered
 *
 * Each EAP peer method needs to call this function to register itself as a
 * supported EAP method. The caller must not free the allocated method data
 * regardless of the return value.
 */
int eap_peer_method_register(struct eap_method *method)
{
	struct eap_method *m, *last = NULL;

	if (method == NULL || method->name == NULL ||
	    method->version != EAP_PEER_METHOD_INTERFACE_VERSION) {
		eap_peer_method_free(method);
		return -1;
	}

	for (m = eap_methods; m; m = m->next) {
		if ((m->vendor == method->vendor &&
		     m->method == method->method) ||
		    os_strcmp(m->name, method->name) == 0) {
			eap_peer_method_free(method);
			return -2;
		}
		last = m;
	}

	if (last)
		last->next = method;
	else
		eap_methods = method;

	return 0;
}


/**
 * eap_peer_unregister_methods - Unregister EAP peer methods
 *
 * This function is called at program termination to unregister all EAP peer
 * methods.
 */
void eap_peer_unregister_methods(void)
{
	struct eap_method *m;
#ifdef CONFIG_DYNAMIC_EAP_METHODS
	void *handle;
#endif /* CONFIG_DYNAMIC_EAP_METHODS */

	while (eap_methods) {
		m = eap_methods;
		eap_methods = eap_methods->next;

#ifdef CONFIG_DYNAMIC_EAP_METHODS
		handle = m->dl_handle;
#endif /* CONFIG_DYNAMIC_EAP_METHODS */

		if (m->free)
			m->free(m);
		else
			eap_peer_method_free(m);

#ifdef CONFIG_DYNAMIC_EAP_METHODS
		if (handle)
			dlclose(handle);
#endif /* CONFIG_DYNAMIC_EAP_METHODS */
	}
}
Commit	Line	Data
6fc6879b JM	1	/*
	2	* EAP peer: Method registration
	3	* Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
	4	*
0f3d578e JM	5	* This software may be distributed under the terms of the BSD license.
0f3d578e JM	6	* See README for more details.
6fc6879b JM	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
49a26bb3 JM	21	static void eap_peer_method_free(struct eap_method *method);
49a26bb3 JM	22
6fc6879b JM	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;
49a191a1 JM	76	if (vendor == EAP_VENDOR_IETF && type == EAP_TYPE_EXPANDED)
49a191a1 JM	77	return "expanded";
6fc6879b JM	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);
d85e1fc8	108	if (os_snprintf_error(end - pos, ret))
6fc6879b JM	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
faebdeaa	138	array = os_calloc(array_len + 1, sizeof(char *));
6fc6879b JM	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	*/
49a26bb3	300	static void eap_peer_method_free(struct eap_method *method)
6fc6879b JM	301	{
	302	os_free(method);
	303	}
	304
	305
	306	/**
	307	* eap_peer_method_register - Register an EAP peer method
49a26bb3	308	* @method: EAP method to register from eap_peer_method_alloc()
6fc6879b JM	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
49a26bb3 JM	313	* supported EAP method. The caller must not free the allocated method data
49a26bb3 JM	314	* regardless of the return value.
6fc6879b JM	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 \|\|
49a26bb3 JM	321	method->version != EAP_PEER_METHOD_INTERFACE_VERSION) {
49a26bb3 JM	322	eap_peer_method_free(method);
6fc6879b	323	return -1;
49a26bb3	324	}
6fc6879b JM	325
	326	for (m = eap_methods; m; m = m->next) {
	327	if ((m->vendor == method->vendor &&
	328	m->method == method->method) \|\|
49a26bb3 JM	329	os_strcmp(m->name, method->name) == 0) {
49a26bb3 JM	330	eap_peer_method_free(method);
6fc6879b	331	return -2;
49a26bb3	332	}
6fc6879b JM	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
6fc6879b JM	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	}