radius_timer.c

vxworks下radius协议栈 的源代码

/* radius_timer.c */

/* Implementations of RADIUS timer handlers, including checking pending 	*/
/* request for retransmission, and checking incoming RADIUS packets.		*/

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

/*
modification history
____________________
Date	Init	Change description
031102  md		Enhancement - moving polling socket read to seperate tasks and 
				replace taskLock/unLock with rwos_radius_data_mutex
111501  md		Removed excessive log messages
111401  md		Fixed SPR#70426 - pool packet identifiers per server
092701  md		Fixed SPR#70639 retransmission of accounting requests with RADIUS_ACCT_DELAY_TIME attribute
052301	tk		Took out check_delay_retransmit_count.  Not only it is redundant, it
				may cause packet identifier to be freed prematurely.
040501	tk		Added code to handle request timer for back-up RADIUS server
020801  tk		Added code in radius_timer_check_socket_event to improve transport rate.
012601  tk		ifdef all RADIUS MIBs code with __RADIUS_MIB__
121900  md		Moved radius_timer_check_socket_event out to use seperate timer and added 
                check_delay_retransmit_count()
121900  md		Merged from visual source safe
*/

#ifdef __RADIUS_DEBUG__
#include <logLib.h>	
#endif

#include "radius.h"
#ifdef __RADIUS_MIB__
#include "radius_mib_include.h"
#endif

extern RWOS_MUTEX	rwos_radius_data_mutex;

static void check_packet_id_reused_timer_per_server (void);
static void check_outstanding_radius_request_ages (void);
/************************************************************************/
void radius_timer (void* p_user)
{
	PARAMETER_NOT_USED (p_user);

	rwos_mutex_acquire (rwos_radius_data_mutex, WAIT_FOREVER);
	
	if (radius.timer_enabled == FALSE) 
		{
		rwos_mutex_release (rwos_radius_data_mutex);

		return;
		}

	check_packet_id_reused_timer_per_server ();

	check_outstanding_radius_request_ages ();

	rwos_mutex_release (rwos_radius_data_mutex);
}
/***********************************************************************************/
static void check_packet_id_reused_timer_per_server (void)
{
	RW_CONTAINER_ITERATOR server_iterator;
	RADIUS_SERVER* p_server;
	UINT id_counter;

	server_iterator = rw_container_create_copy_of_iterator (radius.server_controller.iterator);
		
	rw_container_goto_front (server_iterator);

	while (rw_container_is_at_end (server_iterator) == false)
		{
		p_server = rw_container_at (server_iterator);

		for (id_counter = 0; id_counter <= RADIUS_HIGHEST_PACKET_IDENTIFIER; ++id_counter)
		{
			if (p_server->pool_id_config[id_counter].time_before_reused > 0)
			{
				--p_server->pool_id_config[id_counter].time_before_reused;
				if (p_server->pool_id_config[id_counter].time_before_reused == 0)
				{
				p_server->pool_id_config[id_counter].packet_pool_id = TRUE;
				}
			}
		}
		
		rw_container_next (server_iterator);
		}

	rw_container_free_iterator (server_iterator);
}
/*************************************************************************************/
static void check_outstanding_radius_request_ages ()
{
	RW_CONTAINER_ITERATOR request_entry_iterator;
	RADIUS_REQUEST_ENTRY* p_request_entry;
	RADIUS_SERVER* p_server;
	
	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);
			
		++p_request_entry->request_time;

		if (p_request_entry->backup_server == false)
			{
			p_server = (RADIUS_SERVER*) rw_container_at ((RW_CONTAINER_ITERATOR) p_request_entry->server_handle);
			}
		else	/* for handling backup server */
			{
			p_server = (RADIUS_SERVER*) rw_container_at ((RW_CONTAINER_ITERATOR) p_request_entry->backup_server_handle);
			}
		
		/* tk - use '>=' instead of '>' since request_time starts from 0 */
		if (p_request_entry->request_time >= p_server->retransmission_interval)
			{
			#ifdef __RADIUS_MIB__
			semTake (g_sem_radius_mib, WAIT_FOREVER);
			#endif

			switch (p_request_entry->packet_header.code)
				{
				case RADIUS_ACCESS_REQUEST:
					++p_server->statistics.authentication_timeouts;
				
					break;
				case RADIUS_ACCOUNTING_REQUEST:
					++p_server->statistics.accounting_timeouts;
					break;
				default:
					/* should not happen! */
					break;
				}
			#ifdef __RADIUS_MIB__
			semGive (g_sem_radius_mib);
			#endif

			p_request_entry->request_time = 0;

			if (resend_radius_packet (p_request_entry) == FAIL)
				{
				radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: check_outstanding_radius_request_ages: failed to resend request.\n");

				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);
				
				continue;
				}
			}
		
		rw_container_next (request_entry_iterator);
		}

	rw_container_free_iterator (request_entry_iterator);
}