/* 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_interval01g,11mar02,md  Enhancement - moving polling socket read to seperate tasks and 				replace taskLock/unLock with rwos_radius_data_mutex01f,14nov01,md  Fixed SPR#70426 - pool packet identifiers per server01e,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_pending01d,08feb01,tk  initialize maximum_packets_per_rx_interval to default value01c,26jan01,tk	ifdef all RADIUS MIBs code with __RADIUS_MIB__ 01b,19dec00,md  fixed packet id and make socket nonblocking01a,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);}