radius_initialize.c

vxworks下radius协议栈 的源代码

/* radius_initialize.c */

/* Implementations of RADIUS initialization functions, including the 			*/
/* initialization of the global RADIUS_CLASS structure, RADIUS MIBs, 			*/
/* authtication and accounting sockets, timer and RADIUS server configuration, 	*/

/* Copyright 1984 - 2000 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
____________________
01h,12mar02,md  Enhancement - remove the following default configurations
				radius.receive_packet_rate_per_second
				radius.maximum_packets_per_rx_interval
01g,11mar02,md  Enhancement - moving polling socket read to seperate tasks and 
				replace taskLock/unLock with rwos_radius_data_mutex
01f,14nov01,md  Fixed SPR#70426 - pool packet identifiers per server
01e,27sept01,md  Deleted radius_set_delay_retransmit_count and add two new functions definition.
				 radius_set_packet_id_reused_timer_before_reuse and radius_check_packet_id_reused_pending
01d,08feb01,tk  initialize maximum_packets_per_rx_interval to default value
01c,26jan01,tk	ifdef all RADIUS MIBs code with __RADIUS_MIB__ 
01b,19dec00,md  fixed packet id and make socket nonblocking
01a,19dec00,md  merged from visual source safe
*/

#define GLOBAL_FILE
#include <stdio.h>
#include <stdarg.h>
#include "radius.h"
#ifdef __RADIUS_MIB__
#include "radius_mib_include.h"	
#endif

/************************************************************************/
static enum TEST radius_create_auth_socket_read_task (void);
static enum TEST radius_create_acct_socket_read_task (void);
static bool radius_open_socket_interface (UINT port, RADIUS_SOCKET_OBJECT* p_socket_object);
static void radius_shutdown_socket_read_task (RADIUS_SOCKET_OBJECT *p_socket_object);
static void radius_close_socket_interface (RADIUS_SOCKET_OBJECT* p_socket_object);
static void radius_initialize_timer (void);
static enum TEST radius_copy_configured_server_information (void);
static void radius_close_all_socket_interfaces (void);
/************************************************************************/
enum TEST initialize_radius (ULONG clock_ticks_per_second)
{
	bool socket_initialized;
	
	PARAMETER_NOT_USED (clock_ticks_per_second);
	
#if defined (__RADIUS_BREAKPOINT__) 
	check_for_radius_initialization_breakpoint ();
#endif /* __RADIUS_BREAKPOINT__ */ 

	if (radius.enabled == FALSE)
		{
		return (PASS);	
		}

	radius.timer_enabled = FALSE;

	if (radius.set_default_values == TRUE)
		{
		radius.maximum_rx_packet_size = MAXIMUM_RADIUS_RX_PACKET_SIZE;
		}
		
	radius.request_controller.p_list = rw_list_create (NULL);
	radius.request_controller.iterator = rw_container_create_iterator (radius.request_controller.p_list);

	radius.server_controller.p_list = rw_list_create (NULL);
	radius.server_controller.iterator = rw_container_create_iterator (radius.server_controller.p_list);

	if (radius_copy_configured_server_information () == FAIL)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to copy configured server information\n");

		return (FAIL);
		}

#ifdef __RADIUS_MIB__
	if (radius_mib_initialize () == false)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to init RADIUS MIBs\n");

		return (FAIL);
		}
#endif
  
	socket_initialized = false;
	
	socket_initialized = radius_open_socket_interface (radius.authentication_client_port, &radius.authentication_socket_object);
	
	if (socket_initialized == false)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to init authentication socket interface\n");
		
		return (FAIL);
		}

	if (radius_create_auth_socket_read_task () == FAIL)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to create authentication socket read task\n");

		radius_close_socket_interface (&radius.authentication_socket_object);

		return (FAIL);
		}

	socket_initialized = radius_open_socket_interface (radius.accounting_client_port, &radius.accounting_socket_object);
	
	if (socket_initialized == false)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to init accounting socket interface\n");
		
		radius_shutdown_socket_read_task (&radius.authentication_socket_object);

		radius_close_socket_interface (&radius.authentication_socket_object);

		return (FAIL);
		}
	
	if (radius_create_acct_socket_read_task () == FAIL)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to create accounting socket read task\n");

		radius_shutdown_socket_read_task (&radius.authentication_socket_object);

		radius_close_socket_interface (&radius.authentication_socket_object);

		radius_close_socket_interface (&radius.accounting_socket_object);

		return (FAIL);
		}

	radius_initialize_timer ();

	radius_utils_load ();

#ifdef __RADIUS_MIB__
	if (radius_mib_attach () == false)
		{
		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: initialize_radius: failed to add RADIUS MIBs to the SNMP tree.\n");

		radius_shutdown_socket_read_task (&radius.authentication_socket_object);

		radius_shutdown_socket_read_task (&radius.accounting_socket_object);

		radius_close_socket_interface (&radius.authentication_socket_object);

		radius_close_socket_interface (&radius.accounting_socket_object);

		return (FAIL);
		}
#endif

	return (PASS);
}
/****************************************************************************/
static void radius_initialize_timer (void)
{
	radius.timer_dispatcher = rwos_dispatcher_create (RWOS_DISPATCHER_PRIORITY_NORMAL);

	rwos_dispatcher_register_user (radius.timer_dispatcher, (void *) NULL);

	rwos_dispatcher_register_idle_timer_handler (radius.timer_dispatcher, radius_timer);

	rwos_dispatcher_set_sleep_duration (radius.timer_dispatcher, RADIUS_TIMER_INTERVAL_IN_MSEC);

	radius.timer_enabled = TRUE;
}
/****************************************************************************/
static enum TEST radius_copy_configured_server_information (void)
{
	UINT server_count;
	RADIUS_SERVER_HANDLE server_handle;
	
	if (radius.number_of_servers_configured == 0)
		{
		return (PASS);
		}
	
	for (server_count = 0; server_count < radius.number_of_servers_configured; ++server_count)
		{
		server_handle = radius_server_create (radius.server_info[server_count].type, radius.server_info[server_count].ip_address, 
			radius.server_info[server_count].port, radius.server_info[server_count].max_retransmit_count, 
			radius.server_info[server_count].retransmission_interval, &radius.server_info[server_count].secret[0]);
	
		if (server_handle == INVALID_HANDLE)
			{
			return (FAIL);
			}

		radius_free_server_handle (server_handle);
		}
	
	return (PASS);	
}
/****************************************************************************/
void terminate_radius (void)
{
	RW_CONTAINER_ITERATOR request_entry_iterator;
    RW_CONTAINER_ITERATOR server_entry_iterator;
	RADIUS_REQUEST_ENTRY* p_request_entry;

	rwos_mutex_acquire (rwos_radius_data_mutex, WAIT_FOREVER);

	if (radius.enabled == TRUE)
		{
		request_entry_iterator = rw_container_create_copy_of_iterator (radius.request_controller.iterator);
		
		rw_container_goto_front (request_entry_iterator);
		
		while (rw_container_is_at_end (request_entry_iterator) == false)
			{
			p_request_entry = rw_container_at (request_entry_iterator);
			
			rw_container_remove (request_entry_iterator);
			
			if (p_request_entry->sptr_packet != NULL)
				{
				buffer_free (p_request_entry->sptr_packet);
				}

			if (p_request_entry->p_callbacks != NULL)
				{
				buffer_free (p_request_entry->p_callbacks);
				}

			table_free (p_request_entry);
			}
		
		rw_container_free_iterator (request_entry_iterator);
		
		radius_close_all_socket_interfaces ();

#ifdef __RADIUS_MIB__
		radius_mib_detach ();
		radius_mib_cleanup ();
#endif

	    server_entry_iterator = rw_container_create_copy_of_iterator (radius.server_controller.iterator);
		
		rw_container_goto_front (server_entry_iterator);
		
		while (rw_container_is_at_end (server_entry_iterator) == false)
			{
			radius_server_destroy (server_entry_iterator);
            }
		
		rw_container_free_iterator (server_entry_iterator);
	
		rwos_dispatcher_destroy (radius.timer_dispatcher);
		
		radius.enabled = FALSE;
		}

	rwos_mutex_release (rwos_radius_data_mutex);

	radius_printf (RADIUS_TRACE_PRINTF, "RADIUS: terminate_radius: RADIUS successfully stopped\n");
}
/****************************************************************************/
static enum TEST radius_create_auth_socket_read_task (void)
{
	int task_id;
	char task_name[RWOS_MAXIMUM_STRING_SIZE];

	sprintf (task_name,"%s", RADIUS_AUTH_TASK_NAME);

	task_id = taskSpawn (task_name, 
				RADIUS_AUTH_TASK_PRIORITY,
				RADIUS_AUTH_TASK_OPTIONS,
				RADIUS_AUTH_TASK_STACK_SIZE,
				(FUNCPTR) RADIUSAuthSocketReadTask,
				(int) &radius.authentication_socket_object,
				0,0,0,0,0,0,0,0,0);


	if (task_id == ERROR)
		return (FALSE);
	else
		radius.authentication_socket_object.task_id = task_id;


	return (TRUE);
}
/****************************************************************************/
static enum TEST radius_create_acct_socket_read_task (void)
{
	int task_id;
	char task_name[RWOS_MAXIMUM_STRING_SIZE];

	sprintf (task_name,"%s", RADIUS_ACCT_TASK_NAME);

	task_id = taskSpawn (task_name, 
				RADIUS_ACCT_TASK_PRIORITY,
				RADIUS_ACCT_TASK_OPTIONS,
				RADIUS_ACCT_TASK_STACK_SIZE,
				(FUNCPTR) RADIUSAcctSocketReadTask,
				(int) &radius.accounting_socket_object,
				0,0,0,0,0,0,0,0,0);


	if (task_id == ERROR)
		return (FALSE);
	else
		radius.accounting_socket_object.task_id = task_id;


	return (TRUE);
}
/****************************************************************************/
static bool radius_open_socket_interface (UINT port, RADIUS_SOCKET_OBJECT* p_socket_object)
{
	struct sockaddr_in local_sockaddr_in;
	int sockaddr_size;

	p_socket_object->socket_descriptor = socket (AF_INET, SOCK_DGRAM, 0x00000000L);
	
	if (p_socket_object->socket_descriptor == ERROR)
		{
		radius_printf (RADIUS_INITIALIZATION_PRINTF, "RADIUS: radius_open_socket_interface: failed to initialize socket.\r\n");
		
		return (false);
		}

	sockaddr_size = sizeof (struct sockaddr_in);
	bzero ((char *) &local_sockaddr_in, sockaddr_size);
	local_sockaddr_in.sin_len = (u_char) sockaddr_size;
	local_sockaddr_in.sin_family = AF_INET;

	local_sockaddr_in.sin_port = htons ((USHORT) port);
	local_sockaddr_in.sin_addr.s_addr = htonl (radius.client_ip_address);

	if (bind (p_socket_object->socket_descriptor, (SOCKADDR *)&local_sockaddr_in, sizeof (SOCKADDR)) == ERROR)
		{
		radius_printf (RADIUS_INITIALIZATION_PRINTF, "RADIUS: radius_open_socket_interface: failed to bind socket to address.\r\n");
	
		return (false);
		}

	p_socket_object->state = RADIUS_ACTIVE;

	return (true);
}
/*****************************************************************************/
static void radius_shutdown_socket_read_task (RADIUS_SOCKET_OBJECT *p_socket_object)
{
	if (p_socket_object->task_id > 0)
		{
		taskDelete (p_socket_object->task_id);
		}
}
/****************************************************************************/
static void radius_close_socket_interface (RADIUS_SOCKET_OBJECT* p_socket_object)
{
	close (p_socket_object->socket_descriptor);
	p_socket_object->state = RADIUS_IDLE;
}
/****************************************************************************/
static void radius_close_all_socket_interfaces (void)
{
	close (radius.authentication_socket_object.socket_descriptor);

	radius.authentication_socket_object.state = RADIUS_IDLE;

	close (radius.accounting_socket_object.socket_descriptor);
	
	radius.accounting_socket_object.state = RADIUS_IDLE;

	return;
}
/*************************************************************************/
void radius_printf (enum RADIUS_PRINTF_GROUPS printf_group,const char *cptr_format, ...)
{
	BOOLEAN print_string;

	va_list argptr;

	va_start (argptr,cptr_format);

	if (radius.printing_enabled == FALSE)
		{
		va_end (argptr);

		return;
		}

	print_string = FALSE;

	switch (printf_group)
		{
		case RADIUS_ALARM_PRINTF:
			print_string = (enum BOOLEAN) radius.alarm_printing_enabled;
			break;
		case RADIUS_INITIALIZATION_PRINTF:
			print_string = (enum BOOLEAN) radius.initialization_printing_enabled;
			break;
		case RADIUS_SOCKET_PRINTF:
			print_string = (enum BOOLEAN) radius.socket_printing_enabled;
			break;
		case RADIUS_DATA_PRINTF:
			print_string = (enum BOOLEAN) radius.data_printing_enabled;
			break;
		case RADIUS_TRACE_PRINTF:
			print_string = (enum BOOLEAN) radius.trace_printing_enabled;
			break;
		}

	if (print_string == TRUE)
		{
		vprintf (cptr_format,argptr);
		}

	va_end (argptr);
}
/*************************************************************************/
void radius_initialize_packet_pool_identifier_per_server (RADIUS_SERVER* p_server)
{
	UINT id_counter;

	for (id_counter = 0; id_counter <= RADIUS_HIGHEST_PACKET_IDENTIFIER; ++id_counter)
	{
		p_server->pool_id_config[id_counter].packet_pool_id = TRUE;
		p_server->pool_id_config[id_counter].time_before_reused = 0;
	}
}
/*************************************************************************/
enum TEST radius_get_next_available_packet_identifier_per_server (RADIUS_SERVER* p_server, UINT *uiptr_id)
{
	UINT id_counter;

    for (id_counter = (*uiptr_id) + 1; id_counter <= RADIUS_HIGHEST_PACKET_IDENTIFIER; ++id_counter)
	{
		if (p_server->pool_id_config[id_counter].packet_pool_id == TRUE)
		{
            p_server->pool_id_config[id_counter].packet_pool_id = FALSE;
			*uiptr_id = id_counter;
			return (TRUE);
		}

	}

	for (id_counter = 0; id_counter < *uiptr_id; ++id_counter)
	{
		if (p_server->pool_id_config[id_counter].packet_pool_id == TRUE)
		{
            p_server->pool_id_config[id_counter].packet_pool_id = FALSE;
			*uiptr_id = id_counter;
			return (TRUE);
		}
	}

	return (FALSE);
}
/*************************************************************************/
void radius_free_packet_identifier_per_server (RADIUS_SERVER* p_server, UINT packet_id)
{
    if (packet_id <= RADIUS_HIGHEST_PACKET_IDENTIFIER)
		{
	    p_server->pool_id_config[packet_id].packet_pool_id = TRUE;
        p_server->pool_id_config[packet_id].time_before_reused = 0;
		}
}
/*************************************************************************/
void radius_set_packet_id_reused_timer_before_reuse_per_server (RADIUS_SERVER* p_server, UINT packet_id)
{
    if (packet_id <= RADIUS_HIGHEST_PACKET_IDENTIFIER)
		{
        p_server->pool_id_config[packet_id].time_before_reused = RADIUS_PACKET_ID_REUSED_TIMER_INTERVAL_IN_MSEC;
		}
}
/*************************************************************************/
bool radius_check_packet_id_reused_pending_per_server (RADIUS_SERVER* p_server, UINT packet_id)
{
    if (packet_id <= RADIUS_HIGHEST_PACKET_IDENTIFIER)
		{
		if (p_server->pool_id_config[packet_id].time_before_reused > 0)
			{
			p_server->pool_id_config[packet_id].packet_pool_id = TRUE;
			return (true);
			}
		}

	return (false);
}