radius_attribute.c

vxworks下radius协议栈 的源代码

/* radius_attribute.c */

/* Implementation of functions to verify the validity of RADIUS attributes,	*/
/* and to read and write RADIUS attributes from/to RADIUS packets.			*/

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

/*
modification history
____________________
01d,26aug03,snd Changes done to remove Compilation warnings
01c,22mar02,md  concatenate multiple EAP Message attributes upon received 
				from RADIUS server into one EAP packet data
01b,27feb02,md  bug fixes
01a,19dec00,md  merged from visual source safe
*/

/************************************************************************/
/*	Copyright (C) 1993 - 1999 RouterWare, Inc.   								*/
/*	Unpublished - rights reserved under the Copyright Laws of the			*/
/*	United States.  Use, duplication, or disclosure by the 					*/
/*	Government is subject to restrictions as set forth in 					*/
/*	subparagraph (c)(1)(ii) of the Rights in Technical Data and 			*/
/*	Computer Software clause at 252.227-7013.										*/
/*	RouterWare, Inc., 3961 MacArthur Suite 212 Newport Beach, CA 92660	*/
/************************************************************************/
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include "radius.h"
#include "attribute_control_structures.h"
/************************************************************************************************/
static ATTRIBUTE_CONTROL *radius_get_attribute_control_table (enum RADIUS_CODE code);
static enum TEST radius_check_attribute (ATTRIBUTE_CONTROL *sptr_attribute_control, ATTRIBUTE_COUNT *sptr_attribute_count, 
	UINT index);
static enum TEST radius_verify_modifier (ATTRIBUTE_CONTROL *sptr_attribute_control, ATTRIBUTE_COUNT *attribute_count, UINT index);
static void convert_bytes_to_printable_ascii (BYTE *bptr_input_buffer, UINT length, char *cptr_output_buffer);

#ifdef __EAP__
static enum TEST radius_read_eap_attributes_from_packet (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *sptr_attribute_entry_in_packet, UINT packet_length,
														 RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller);
#endif /* __EAP__ */

#ifdef __RADIUS_ATTRIBUTE_VERIFICATION_DEBUG__
bool radius_verify_attribute_value (RADIUS_ATTRIBUTE_ENTRY* p_attribute);
#endif /*__RADIUS_ATTRIBUTE_VERIFICATION_DEBUG__*/
/************************************************************************************************
* radius_verify_attributes ()

	verifies that the attributes in response packet comply with draft rfc.
 	Verification algorithm:
  	1: Scan attribute list, getting attribute type, and count.
	2: Scan the attribute table.
	   For each attribute check the following
		switch (presence)
			ILLEGAL - if attribute in list, error
			ZERO OR MORE - if not present, check modifier alternate
			                if present, check modifier both and dependent
			ONLY_ONE - self explanatory
			ONE_OR_MORE - self explanatory 
************************************************************************************************/
bool radius_verify_attributes (enum RADIUS_CODE code,  RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller)
{
	ATTRIBUTE_COUNT attribute_count;
	ATTRIBUTE_CONTROL *sptr_attribute_control;
	RADIUS_ATTRIBUTE_ENTRY* p_attribute;
	ULONG accounting_status;
	UINT index;
	RW_CONTAINER_ITERATOR attribute_iterator;
	
	sptr_attribute_control = NULL;
	p_attribute = NULL;
	attribute_iterator = 0;

	sptr_attribute_control = radius_get_attribute_control_table (code);
	
	if (sptr_attribute_control == NULL) 
		{

		return (true);

		}
			
	memset (&attribute_count, 0, sizeof (UINT) * MAXIMUM_RADIUS_ATTRIBUTE_TYPE);

	attribute_iterator = p_radius_attribute_list_controller->iterator;
	
	rw_container_goto_front (attribute_iterator);
	
	while (rw_container_is_at_end (attribute_iterator) == false)
		{

		p_attribute = rw_container_at (attribute_iterator);

#ifdef __RADIUS_ATTRIBUTE_VERIFICATION_DEBUG__
		if (radius_verify_attribute_value (p_attribute) == false)
			{

			radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: radius_verify_attribute_value: Value of attribute %d invalid.\n", p_attribute->type);
			
			return (false);

			}

		radius_printf (RADIUS_ALARM_PRINTF, "RADIUS: radius_verify_attribute_value: Value of attribute %d valid.\n", p_attribute->type);
#endif /*__RADIUS_ATTRIBUTE_VERIFICATION_DEBUG__*/

		if (p_attribute->type == RADIUS_ACCT_STATUS_TYPE)
			{
			
			radius_util_deserialize_ulong (p_attribute->value, &accounting_status);

			if ((code == RADIUS_ACCOUNTING_REQUEST) && (accounting_status > RADIUS_ACCOUNTING_OFF))
				{

				return (true);			/*Will not check tunnel accounting attributes.*/

				}

			}
		
		attribute_count.count[p_attribute->type]++;
		
		rw_container_next (attribute_iterator);

		}
		
	for (index = 0; index < MAXIMUM_RADIUS_ATTRIBUTE_TYPE; ++index)
		{

		if (radius_check_attribute (sptr_attribute_control, &attribute_count, index) == FAIL)
			{

			return (false);

			}

		}			
		
	return (true);
}	
/*****************************************************************************/
static ATTRIBUTE_CONTROL *radius_get_attribute_control_table (enum RADIUS_CODE code)
{
	switch (code)
		{

		case RADIUS_ACCESS_REQUEST:
			return (access_request_control);
 			
		case RADIUS_ACCESS_ACCEPT:
			return (access_accept_control);
				
		case RADIUS_ACCESS_REJECT:
			return (access_reject_control);
			
		case RADIUS_ACCOUNTING_REQUEST:
			return (accounting_request_control);
			
		case RADIUS_ACCOUNTING_RESPONSE:
			return (accounting_response_control);
			
		case RADIUS_ACCESS_CHALLENGE:
			return (access_challenge_control);
			
		case RADIUS_STATUS_SERVER:
		case RADIUS_STATUS_CLIENT:
		case RADIUS_RESERVED:
		default:
			return (NULL);

		}
}
/***************************************************************************/
static enum TEST radius_check_attribute (ATTRIBUTE_CONTROL *sptr_attribute_control, 
										ATTRIBUTE_COUNT *sptr_attribute_count, 
										UINT index)
{
	switch (sptr_attribute_control[index].presence)
		{

		case ILLEGAL:
			if (sptr_attribute_count->count[index] != ZERO_ATTRIBUTE_COUNT) 
				{

				return (FAIL);

				}

			break;

		case ZERO_OR_MORE:
			if (radius_verify_modifier (sptr_attribute_control, sptr_attribute_count, index) == FAIL)
				{
				return (FAIL);
				}

			break;

		case ZERO_OR_ONE:
			if (sptr_attribute_count->count[index] > MINIMUM_ATTRIBUTE_COUNT)
				{
				return (FAIL);
				}

			break;

		case ONE_ONLY:
			if (sptr_attribute_count->count[index] != MINIMUM_ATTRIBUTE_COUNT)
				{
				return (FAIL);
				}

			break;

		case ONE_OR_MORE:
			if (sptr_attribute_count->count[index] == ZERO_ATTRIBUTE_COUNT)
				{
				return (FAIL);
				}

			break;

		default:
			/* compiler error if we get here. Table not formed well */
			break;
		}

	return (PASS);
}
/***************************************************************************/
static enum TEST radius_verify_modifier (ATTRIBUTE_CONTROL *sptr_attribute_control, ATTRIBUTE_COUNT *sptr_attribute_count, UINT index)
{
	switch (sptr_attribute_control[index].modifier)
		{

		case NO_MODIFIER:
				break;

		case ALTERNATE:
			if (sptr_attribute_count->count[index] != ZERO_ATTRIBUTE_COUNT)
				{

				break;

				}

			if (sptr_attribute_count->count[sptr_attribute_control[index].other_type] == ZERO_ATTRIBUTE_COUNT)
				{

				return (FAIL);

				}

			break;

		case BOTH:
			if ((sptr_attribute_count->count[index] == ZERO_ATTRIBUTE_COUNT) ||
				(sptr_attribute_count->count[sptr_attribute_control[index].other_type] == ZERO_ATTRIBUTE_COUNT))
				{

				return (FAIL);

				}

			break;

		default:
			break;
		}

	return (PASS);
}
/*****************************************************************************************/
UINT get_radius_attribute_list_length (RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller)
{
	UINT length;
	RW_CONTAINER_ITERATOR attribute_iterator;
	RADIUS_ATTRIBUTE_ENTRY *p_attribute;

	length = 0;

	if (p_radius_attribute_list_controller == NULL) 
		{

		return (0);

		}

	attribute_iterator = p_radius_attribute_list_controller->iterator;

	rw_container_goto_front (attribute_iterator);
	
	while (rw_container_is_at_end (attribute_iterator) == false)
		{

		p_attribute = rw_container_at (attribute_iterator);
		
		length += (p_attribute->length_of_attribute_value + RADIUS_SIZE_OF_ATTRIBUTE_HEADER_IN_PACKET);

		rw_container_next (attribute_iterator);

		}

	return (length);
}
/*****************************************************************************************/
enum TEST radius_write_attributes_to_packet (RADIUS_PACKET *sptr_packet, RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller)
{
	RW_CONTAINER_ITERATOR attribute_iterator;
	RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *sptr_attribute_entry_in_packet;
	RADIUS_ATTRIBUTE_ENTRY* p_attribute;

	if (sptr_packet == NULL) 
		{

		return (FAIL);

		}

	sptr_attribute_entry_in_packet = (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *) &sptr_packet->data;

	attribute_iterator = p_radius_attribute_list_controller->iterator;
	
	rw_container_goto_front (attribute_iterator);
	
	while (rw_container_is_at_end (attribute_iterator) == false)
		{

		p_attribute = rw_container_at (attribute_iterator);
		
		sptr_attribute_entry_in_packet->type = (BYTE_ENUM (RADIUS_ATTRIBUTE_TYPE)) p_attribute->type;
		sptr_attribute_entry_in_packet->length = (BYTE) (p_attribute->length_of_attribute_value + 
			RADIUS_SIZE_OF_ATTRIBUTE_HEADER_IN_PACKET);

		memcpy (&sptr_attribute_entry_in_packet->value[0], &p_attribute->value[0], p_attribute->length_of_attribute_value);

		sptr_attribute_entry_in_packet = (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *) ((BYTE *) sptr_attribute_entry_in_packet + 
			sptr_attribute_entry_in_packet->length);

		rw_container_next (attribute_iterator);

		}

	return (PASS);
}
/*****************************************************************************************/
enum TEST radius_read_attributes_from_packet (RADIUS_PACKET *sptr_packet, RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller)
{
#ifndef __EAP__
	enum RADIUS_ATTRIBUTE_TYPE type;
	UINT attribute_length;
#endif /* __EAP__ */
	RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *sptr_attribute_entry_in_packet;
	UINT packet_length;

	if (sptr_packet == NULL) 
		{

		return (FAIL);

		}

	if (p_radius_attribute_list_controller == NULL) 
		{

		return (FAIL);

		}

	sptr_attribute_entry_in_packet = (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *) &sptr_packet->data;

	packet_length = (UINT) (swap (sptr_packet->header.length));

	if (packet_length < sizeof (RADIUS_PACKET_HEADER)) 
		{
		return (FAIL);
		}

	packet_length -= sizeof (RADIUS_PACKET_HEADER);

#ifdef __EAP__

	if (radius_read_eap_attributes_from_packet (sptr_attribute_entry_in_packet, packet_length, p_radius_attribute_list_controller)
		== FAIL)
		{
		return (FAIL);
		}

#else

	while (packet_length > 0)
		{

		type = sptr_attribute_entry_in_packet->type;

		attribute_length = (UINT) sptr_attribute_entry_in_packet->length;

		packet_length -= attribute_length;

		if (radius_add_attribute_to_list ((RADIUS_ATTRIBUTE_LIST_HANDLE) p_radius_attribute_list_controller, 
			type, attribute_length - RADIUS_SIZE_OF_ATTRIBUTE_HEADER_IN_PACKET, 
			&sptr_attribute_entry_in_packet->value[0]) == FAIL)
			{

			return (FAIL);

			}

		sptr_attribute_entry_in_packet = (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *) ((UINT) sptr_attribute_entry_in_packet + attribute_length);

		}

#endif /* __EAP__ */

	return (PASS);
}
#ifdef __EAP__
/*****************************************************************************************/
/* Read EAP Message attributes from the packet and concatenate them into one			 */
/* consecutive data buffer before adding them to the attribute list handle if			 */
/* necessary.																			 */
/*****************************************************************************************/
static enum TEST radius_read_eap_attributes_from_packet (RADIUS_ATTRIBUTE_ENTRY_IN_PACKET *sptr_attribute_entry_in_packet, UINT packet_length,
														 RADIUS_LIST_CONTROLLER* p_radius_attribute_list_controller)
{
	enum RADIUS_ATTRIBUTE_TYPE type;
	UINT attribute_length;
	UINT length_of_attribute_data;
	BYTE temp_attribute_data[MAXIMUM_RADIUS_RX_PACKET_SIZE];
	bool eap_message_found = false;
	int index = 0;

	while (packet_length > 0)
		{

		type = sptr_attribute_entry_in_packet->type;

		attribute_length = (UINT) sptr_attribute_entry_in_packet->length;

		length_of_attribute_data = attribute_length - RADIUS_SIZE_OF_ATTRIBUTE_HEADER_IN_PACKET;

		if (type == RADIUS_EAP_MESSAGE)
			{
			memcpy (&temp_attribute_data[index], &sptr_attribute_entry_in_packet->value[0], length_of_attribute_data);
			
			index += length_of_attribute_data;

			eap_message_found = true;
			}
		else
			{

			if (eap_message_found == true)
				{
				if (radius_add_attribute_to_list ((RADIUS_ATTRIBUTE_LIST_HANDLE) p_radius_attribute_list_controller, 
					RADIUS_EAP_MESSAGE, index, 
					&temp_attribute_data[0]) == FAIL)
					{

					return (FAIL);

					}
				
				index = 0;

				eap_message_found = false;

				}