dot1xauthenticatorlib.c

dot1x认证源码,包括dot1x数据包的收发,认证的配置,MIB的设计等

#include "msgQLib.h"
#include "muxLib.h"
#include "muxTkLib.h"
#include "netBufLib.h"
#include "tmsTypes.h"
#include "swEndCommon.h"
#include <syslogMsg.h>

#include "dot1xAuth.h"
#include "dot1xEap.h"
#include "dot1xEapol.h"
#include "dot1xAuthenticatorLib.h"		/* the order of include should not changed */


uchar_t PAE_SRC_MAC[ETHER_ADDR_LEN] = {0x00, 0x50, 0x56, 0xC0, 0x00, 0x08}; /* 00-50-56-C0-00-08 */
void *pdot1xCookie = NULL;
NET_POOL_ID pNetPool = NULL;

/* network buffers configuration */
M_CL_CONFIG dot1xMclConfig =
{/* mBlk configuration table */
	0, 0, NULL, 0
};

CL_DESC dot1xClDescTbl[] =
{ /* network cluster pool configuration table */
  /* 
   * clusterSize		num 			memArea 		memSize
   * -----------		----			------- 		-------
   */
	{DEFAULT_PACKET_LEN, 0, NULL, 0}
};

int dot1xClDescTblNumEnt = (NELEMENTS(dot1xClDescTbl));



extern int flag;
extern PART_ID gDot1xMemPartID;
extern MSG_Q_ID Dot1xMsgQID ;
extern Dot1xStat_t TotalDot1xStat;











/*---------------------------------------*/
STATUS dot1xShutdownRtn( void *netCallbackId)
{

	return 1;
}

STATUS dot1xTxRestartRtn( void * netCallbackId)
{

	return 1;
}

void dot1xErrorRtn( void *netCallbackId, END_ERR *pError)
{

	return ;
}

#define HAVE_OFFSET

BOOL dot1xRecv
(
    void * netCallbackId,
    long type,
    M_BLK_ID pMblk,
    void * pSpareData
)
{
	u_char qTag[2];
	char *pEtherHdr;
	char mac[6];
	u_short vlan = 0;
	u_short port = 0;
	Dot1xMessage_t message;
	
	if ( netCallbackId )
	{
		Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_DEBUG, "dot1xRecv", "receive a 802.1x packet!");
		bzero((char *)&message, sizeof(Dot1xMessage_t));
		message.buf = (char *)memPartAlloc(gDot1xMemPartID, DEFAULT_PACKET_LEN);
		if (message.buf == NULL)
		{
			Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_EMERG, "dot1xRecv", "memPartAlloc failure!!");
			netMblkClChainFree(pMblk);
			return 0;
		}

		/*---check vlanID tag---*/
		memcpy(qTag, pMblk->m_data - 6, 2);
		if ( qTag[0] == 0x81 && qTag[1] == 0x00 )
		{
			pEtherHdr= pMblk->m_data - 18;
			memcpy((char *)&vlan, pEtherHdr+14, 2);
			vlan = htons(vlan) & 0x0fff;
			
		}
		else 
		{
			pEtherHdr = pMblk->m_data - 14;
			vlan = 0;
		}
		
		/*---get user mac address---*/
		bzero(mac, 6);
		memcpy(mac, pEtherHdr+6, MAC_ADDR_LENGTH);
		/*printf("\n mac address is %02x %02x %02x %02x %02x %02x \n", 
			mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);*/
		
		/*---get user port NO.---*/
		memcpy((char *)&port, &pSpareData, 2);
		/*port = port & 0xffff0000;
		port = port >> 16;*/
		/*printf("user vlan is %d, port is %d", vlan, port);*/
		
		/*---get user key---*/
		memcpy(message.UserKey, mac, MAC_ADDR_LENGTH);
		memcpy((char *)&message.UserKey[6], (char *)&vlan, 2);
		memcpy((char *)&message.UserKey[8], (char *)&port, 2);

		/*---copy data from mblk---*/
		bzero(message.buf, DEFAULT_PACKET_LEN);
		message.length = netMblkToBufCopy(pMblk, message.buf, NULL);
		netMblkClChainFree(pMblk);

		#if 0	/* for debug */
		{
			int i;
			printf("\nSpareData is %ld", (u_long)pSpareData);
			printf("\nPacket Length is %ld, from 0x%lx \n", message.length, (u_long)message.buf);
			for (i=0; i<message.length; i++)
			{
				if (!(i % 16)) printf("\n");
				printf("%02x ", message.buf[i]);
			}
		}
		#endif

		Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_DEBUG, "dot1xRecv", "free pMblk!");
		message.msgId = EAPOL_Frame;

		#if 0
		{
			int i;	
			char *p;
			p = (char *)&message;
			printf("\n dot1xRecv, message address is 0x%lx\nmessage is :", (u_long)&message);
			for (i=0; i<sizeof(message); i++)
			{
				if (!(i % 16)) printf("\n");
				printf("%02x ", p[i]);
			}
			printf("\n length is in %ld", ((u_long)&(message.length)-(u_long)&message));
		}
		#endif

		if (ERROR == msgQSend(Dot1xMsgQID, (void *)&message, sizeof(Dot1xMessage_t), NO_WAIT, MSG_PRI_NORMAL))
		{
			memPartFree(gDot1xMemPartID, message.buf);
			Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_CRIT, "dot1xRecv", "send 802.1x-packet to Q failure!!");
			return 0;
		}
		Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_NOTICE, "dot1xRecv", "send 802.1x-packet to Q successful!");
		

	}
	else
		netMblkClChainFree(pMblk);

	return 1;
}


STATUS dot1xFilterRecvPkt(Dot1xMessage_t *pMsg)
{
	struct Eapol_Header *pEapol_Hdr = NULL;
	struct Eap_Type_Header *pEap_Hdr = NULL;
	int eapol_len = 0;
	int eapol_type = EAPOL_Unknown;
	
	pEapol_Hdr = (struct Eapol_Header *)pMsg->buf;

	/* check eapol packet version, it should be version 1 */
	if (pEapol_Hdr->version != PAE_Protocol_Version)
	{
		Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_ERROR, "dot1xFilterRecvPkt", "eapol version invalid!");
		return ERROR;
	}
	
	/* get eapol packet length and type */
	pEapol_Hdr->len = htons(pEapol_Hdr->len);
	eapol_len = pEapol_Hdr->len;
	eapol_type = pEapol_Hdr->eap_type;
	if (pMsg->length < eapol_len + EAPOL_HEADER_LEN)
	{
		Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_ERROR, "dot1xFilterRecvPkt", "packet length error!");
		return ERROR;
	}

	if (eapol_type == EAP_Packet)
	{
		pEap_Hdr = (struct Eap_Type_Header *)((char *)pEapol_Hdr + EAPOL_HEADER_LEN);
		if (pEap_Hdr->code != EAP_Response)
		{
			TotalDot1xStat.dot1xAuthInvalidEapolFramesRx++;
			Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_ERROR, "dot1xFilterRecvPkt", "not EAP Response!");
			return ERROR;
		}
		
		if (eapol_len < EAP_TYPE_HEADER_LEN)
		{
			TotalDot1xStat.dot1xAuthEapLengthErrorFramesRx++;
			Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_ERROR, "dot1xFilterRecvPkt", "eapol length error!");
			return ERROR;
		}

		pEap_Hdr->len = htons(pEap_Hdr->len);
		if (pEap_Hdr->len != eapol_len)
		{
			TotalDot1xStat.dot1xAuthEapLengthErrorFramesRx++;
			Dot1x_logMsgSend(DOT1X_MODULE, SYSLOG_SEVERITY_ERROR, "dot1xFilterRecvPkt", "eap length error!");
			return ERROR;
		}
	
	}
	
	return OK;
}




int dot1xSend(
	const u_char *mac,
	const u_short vlan,
	const u_short port,
	const int msgType, 
	const char *msgBody,
	const u_long msgLen,
	const u_char identify, 
	const int privMsg
)
{
	u_char dot1xBuf[DEFAULT_PACKET_LEN] = {0};
	struct Eap_Private_Field *pEap_Private = NULL;
	struct Eapol_Header *pEapol_Hdr = NULL;
	struct Eap_Type_Header *pEap_Hdr = NULL;
	struct Eap_Type_Header *pEapMD5_Hdr = NULL;
	struct Eap_Private_Field Eap_Private;
	u_long buflen;
	M_BLK_ID pMblk = NULL;
	uchar_t *p = NULL;
	u_long Spare;

/*	printf("\n\n---------------------dot1xSend------------------");*/

	/* fill linkage private field here */
	memset(&Eap_Private, 0, sizeof(Eap_Private));
	memcpy(Eap_Private.linkageId, EAP_LINKAGE_IDENTIFIER, strlen(EAP_LINKAGE_IDENTIFIER));
	Eap_Private.version = htons(EAP_LINKAGE_VERSION);
	Eap_Private.build = htons(EAP_LINKAGE_BUILD);
	Eap_Private.msgType = privMsg;	/* passed from parameter */


	pEapol_Hdr = (struct Eapol_Header *)( dot1xBuf );
	pEapol_Hdr->version = PAE_Protocol_Version;
	pEapol_Hdr->eap_type = EAP_Packet;

	pEap_Hdr = (struct Eap_Type_Header *)((char *)pEapol_Hdr + EAPOL_HEADER_LEN);

	switch (msgType)
	{
		case dot1xMsg_Success:
			pEap_Hdr->code = EAP_Success;
			pEap_Hdr->id = identify;
			pEap_Hdr->len = EAP_TYPE_HEADER_LEN;
			pEapol_Hdr->len = EAP_TYPE_HEADER_LEN;

			/* append linkage private field */
			pEap_Private = (struct Eap_Private_Field *)((char *)pEap_Hdr + EAP_TYPE_HEADER_LEN);
			memcpy((void *)pEap_Private, (void *)&Eap_Private, sizeof(struct Eap_Private_Field));
			buflen = EAPOL_HEADER_LEN + pEap_Hdr->len + sizeof(struct Eap_Private_Field);
			break;

		case dot1xMsg_Failure:
			pEap_Hdr->code = EAP_Failure;
			pEap_Hdr->id = identify;
			pEap_Hdr->len = EAP_TYPE_HEADER_LEN;
			pEapol_Hdr->len = EAP_TYPE_HEADER_LEN;

			/* append linkage private field */
			pEap_Private = (struct Eap_Private_Field *)((char *)pEap_Hdr + EAP_TYPE_HEADER_LEN);
			memcpy((void *)pEap_Private, (void *)&Eap_Private, sizeof(struct Eap_Private_Field));
			buflen = EAPOL_HEADER_LEN + pEap_Hdr->len + sizeof(struct Eap_Private_Field);
			break;

		case  dot1xMsg_Req_Id:
			pEap_Hdr->code = EAP_Request;
			pEap_Hdr->id = identify;
			pEap_Hdr->len = EAP_TYPE_HEADER_LEN;
			pEap_Hdr->type = EAP_Type_Id;
			pEapol_Hdr->len = EAP_TYPE_HEADER_LEN;
			buflen = EAPOL_HEADER_LEN + pEap_Hdr->len;
			break;