allow_types = eap-md5

 	identity = "Your account name" # Replace your account name. 

	 eap-md5 {

      		username = "Your account name" # Replace your account name again:)

      		password = "Your password"   # If the password has spaces, quote it.

		}

#include <sys/ioctl.h>  

#include <net/if.h>  

#include <net/if_arp.h>  

#include <arpa/inet.h>  

#include <errno.h>  

#include <linux/netlink.h>

#include <linux/rtnetlink.h>

uint8_t md5rec[16];

char DNS[20];

      if(ruijie_op==1)

      {

        append_rgtail(thisint);   //by acevery, for Red Gaint Facilities.

      }

/*************************************************

 * 

 * Append Red Gaint tail to each response data,

 *                                   by acevery

 * 

 *************************************************/

void append_rgtail(struct interface_data *thisint)

{

	int i;

	uint8_t rgsig[144] ={

	// 0 --> 22

	0x00,0x00,0x13,0x11, // Encode( 0x00,0x00,0x13,0x11 ) Ruijie OEM Mark

	0x01, // Encode( 0x01/00 )

	0x00,0x00,0x00,0x00, // Encode( IP )

	0x00,0x00,0x00,0x00, // Encode( SubNetMask )

	0x00,0x00,0x00,0x00, // Encode( NetGate )

	0x00,0x00,0x00,0x00, // Encode( DNS )

	0x00,0x00, // Checksum( )

	// 23 --> 58

	0x00,0x00,0x13,0x11,0x38,0x30,0x32,0x31,0x78,0x2e,0x65,0x78,0x65,0x00,0x00,0x00, // ASCII 8021x.exe

	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //

	0x00,0x00,0x00,0x00,

	// 59 --> 77

	0x02,0x38,0x00,0x00, // 8021x.exe File Version (2.56)

	0x00, // unknow flag

	0x00,0x00,0x13,0x11,0x00,0x4a,0x1a,0x28,0x00,0x00,0x13,0x11,0x17,0x22, // Const strings

	// 78 --> 120

	0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, 

	0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, // 32bytes spc. Random strings

	0x1a,0x0c,0x00,0x00,0x13,0x11,0x18,0x06,0x00,0x00,0x00, // Const strings

	// 121

	0x01, // DHCP and first time flag

	// V2.56 (and upper?) added

	// 122 -->

	0x1a,0x0e,0x00,0x00,0x13,0x11,0x2d,0x08, // Const strings

	// 130 --> 135

	0x00,0x00,0x00,0x00,0x00,0x00, // True NIC MAC

	// 136--> 143

	0x1a,0x08,0x00,0x00,0x13,0x11,0x2f,0x02 // Const strings

	};

	// 1 , we fill in the Network Parameters part:

	// 0 --> 20   +   121

	if(getNP(thisint, &rgsig[RJ_IP_OFFSET], IP)==-1)

	{

		debug_printf(DEBUG_EVERYTHING,"The %s is not up, we don't get Network Parameters for Authentication.\n",thisint->intName);

		for(i=0;i<16;i++)

		{

			rgsig[RJ_IP_OFFSET+i]=0x00;

		}

		rgsig[RJ_DHCP_OFFSET]=0x01;

	}

	else 

	{

		debug_printf(DEBUG_EVERYTHING,"The %s is up, we will get Network Parameters for Authentication.\n",thisint->intName);

		debug_printf(DEBUG_NORMAL,"Trying to get Netmask.\n");

		if(getNP(thisint, &rgsig[RJ_NM_OFFSET], NM)==-1)

		{

			debug_printf(DEBUG_NORMAL,"Couldn't get subNetmask!\n");

		}

		debug_printf(DEBUG_NORMAL,"Trying to get Gateway.\n");

		if(gotRoute(&rgsig[RJ_GW_OFFSET])!=0)

		{

			debug_printf(DEBUG_NORMAL,"Couldn't get Gateway!\n");

		}

		debug_printf(DEBUG_NORMAL,"Trying to get DNS.\n");

		if(gotDNS(&rgsig[RJ_DNS_OFFSET])!=0)

		{

			debug_printf(DEBUG_NORMAL,"Couldn't get DNS!\n");

		}

		rgsig[RJ_DHCP_OFFSET]=0x00;

	}

	// 2 , we calculate the Checksum of the Network Parameters.

	//  21 --> 22

	checksumNP(rgsig,&rgsig[RJ_CS_OFFSET]);

	// 3 , we Encode the Network Parameter in Ruijie's algorithm.

	//  0 -- > 22

	for(i=0;i<23;i++)

	{

		rgsig[i]=encodeNP(rgsig[i]);

	}

	// 4 , we generate the sepecial 32 byte Hash

	// 78 --> 109

	if(md5rec[0]==0 && md5rec[2]==0)

	{

		debug_printf(DEBUG_EVERYTHING, 

				"We haven't got the random md5 hash, so use randstr() to fill the 32 byte Hash.\n");

		randstr(&rgsig[RJ_HASH_OFFSET]);

	}

	else

	{

		debug_printf(DEBUG_EVERYTHING,

				"Use the got random md5 hash to generate the 33 byte Hash.\n");

		for(i=0;i<16;i++)

			debug_printf(DEBUG_NORMAL,"%.2x",md5rec[i]);

		debug_printf(DEBUG_NORMAL,"\n");

		Hash8021x(&rgsig[RJ_HASH_OFFSET]);

	}

	// 5 , we fill the NIC MAC

	// 130 --> 135

	memcpy(&rgsig[RJ_MAC_OFFSET],&thisint->source_mac[0],6);

	// All right, the Ruijie tail is ready :)

	memcpy(&thisint->sendframe[thisint->send_size], rgsig, RGSIGLEN);

	thisint->send_size += RGSIGLEN;

}

  if(ruijie_op==1)

  {

    append_rgtail(thisint);

  }

      if(ruijie_op==1)

      {

        get_rg_ssid(thisint);

      }

/**********************************************************

 *

 * Get initial Red Gaint session id for later echo packet

 * to keep the supplicant connected from the server.

 *

 *********************************************************/

void get_rg_ssid(struct interface_data *thisint)

{

	ULONG_BYTEARRAY uTemp;

	uint16_t offset;

	offset = ntohs( *((uint16_t *)&(thisint->recvframe)[0x10]));

	debug_printf(DEBUG_EVERYTHING,"header lenth : %d \n",offset);

	uTemp.ulValue = *((uint32_t *)(&(thisint->recvframe)[0x12 + offset - 0x08]));

	debug_printf(DEBUG_EVERYTHING, "Got Red Gaint SSID :\n");

	debug_hex_dump(DEBUG_EVERYTHING,&uTemp.btValue[0],4);

	thisint->rg_ssid.btValue[0] = encodeNP(uTemp.btValue[3]);

	thisint->rg_ssid.btValue[1] = encodeNP(uTemp.btValue[2]);

	thisint->rg_ssid.btValue[2] = encodeNP(uTemp.btValue[1]);

	thisint->rg_ssid.btValue[3] = encodeNP(uTemp.btValue[0]);

}

/************************************************************************

 *

 * Ruijie use its special algorithm to authenticate client. Below are the

 * functions need to be pass its test :) 

 * All the functions are called in

 * append_rgtail().

 ************************************************************************/

// Special random string function for the seek frame and first Respond frame.

// Comes from Mento Supplicant v 6.0 beta3 by soar.

void  randstr(uint8_t * randhash)

{

	uint16_t a,b,c,d,e;

	unsigned t;

	int i;

	t=time(NULL);

	srand(t);

	a=rand();

	b=rand();

	c=rand();

	d=rand();

	e=rand();

	uint8_t strRandom[65];

	// now we get the rand md5 hash from string format:

	sprintf(strRandom,"%.4X%.4X%.4X%.4X%.4X%.8X3884",a,b,c,d,e,t);

	for(i=0;i<32;i++)

	{

		randhash[i]=strRandom[i];	

	}

}

/************************************************************************

 *

* Hash8021x is the key algorithm in Ruijie Supplicant, 

* Comes from Mento Supplicant v 6.0 beta 3 by soar.

*

* Use 8  MD5 checksum 0x00001000h --> 0x00021000h binary of 8021x.exe

* (every segment is 0x4000h)£¬been added the random MD5 hash from

* authenticator before every segment. Then, use the 8 MD5 hash and the

* random hash from authenticator to form a 0x90h table tableC, then

* checksum tableC.

*

*************************************************************************/

void Hash8021x( uint8_t * strMD5Hash)

{

	FILE *RJfile;

	int BufferSize=0x4a00;

	int nLength=0,i=0,j=0;

	uint8_t md5get[16],md5result[16];

	for(i=0;i<16;i++)

	{

		md5get[i]=0;

	}

	uint8_t Buffer1[0x5000];//the buffer for 8021x.exe reading segment

	uint8_t Buffer2[0x5000];// buffer for md5hash got and 8021x.exe segment

	RJfile = fopen( "/etc/8021x.exe", "rb");

	fseek(RJfile,0x1000,SEEK_SET);

	static uint8_t TableC[0x90]={};

			// Transform to TableC

	TableC[0]=md5rec[0];

	for (i=1;i<8;i++)

	{

		TableC[i*18-1]=md5rec[i*2-1];

		TableC[i*18]=md5rec[i*2];

	}

	TableC[143]=md5rec[15];

	// Calculate 8021x.exe segment md5sum

	j=0;

	while((nLength=fread(Buffer1,BufferSize,1,RJfile))>0 && j<8)

	{

		for(i=0;i<16;i++)

		{

			Buffer2[i]=md5rec[i];

		}

		for (i=0;i<BufferSize;i++)

		{

			Buffer2[16+i]=Buffer1[i];

		}

		MD5(Buffer2,BufferSize+16,md5get);

		for (i=0;i<16;i++)

		{

			TableC[18*j+i+1]=md5get[i];

		}

		j++;

	}// end of while, and now we got a ready TableC

	fclose(RJfile);

	MD5(TableC,144,md5result);// Calculate TableC md5sum, and store to strMD5Hash

	sprintf(&strMD5Hash[0],"%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",md5result[0],md5result[1],md5result[2],md5result[3],md5result[4],md5result[5],md5result[6],md5result[7],md5result[8],md5result[9],md5result[10],md5result[11],md5result[12],md5result[13],md5result[14],md5result[15],32);

	debug_printf(DEBUG_EVERYTHING, "Ruijie 8021x.exe Check MD5 in ACSII is: ");

	for(i=0;i<16;i++)

	{

		debug_printf(DEBUG_NORMAL,"%.2x ",strMD5Hash[i]);

	}

	debug_printf(DEBUG_NORMAL,"\n");

}

/************************************************************************

 *

 * checksumNP is another algorithm in Ruijie Supplicant,

 * it calculate the checksum of Ruijie OEM mart and Net Parameters: local IP, Netmask,

 * Gateway and DNS.

 * Mainly Comes from Mento Supplicant v 6.0 beta 3 by soar.

 *

 ************************************************************************/

void checksumNP(uint8_t * sCircleBase,uint8_t * RuijieChecksum)

{

static uint8_t Table[]={

		0x00,0x00,0x21,0x10,0x42,0x20,0x63,0x30,0x84,0x40,0xA5,0x50,0xC6,0x60,0xE7,0x70, 

		0x08,0x81,0x29,0x91,0x4A,0xA1,0x6B,0xB1,0x8C,0xC1,0xAD,0xD1,0xCE,0xE1,0xEF,0xF1, 

		0x31,0x12,0x10,0x02,0x73,0x32,0x52,0x22,0xB5,0x52,0x94,0x42,0xF7,0x72,0xD6,0x62, 

		0x39,0x93,0x18,0x83,0x7B,0xB3,0x5A,0xA3,0xBD,0xD3,0x9C,0xC3,0xFF,0xF3,0xDE,0xE3, 

		0x62,0x24,0x43,0x34,0x20,0x04,0x01,0x14,0xE6,0x64,0xC7,0x74,0xA4,0x44,0x85,0x54, 

		0x6A,0xA5,0x4B,0xB5,0x28,0x85,0x09,0x95,0xEE,0xE5,0xCF,0xF5,0xAC,0xC5,0x8D,0xD5, 

		0x53,0x36,0x72,0x26,0x11,0x16,0x30,0x06,0xD7,0x76,0xF6,0x66,0x95,0x56,0xB4,0x46, 

		0x5B,0xB7,0x7A,0xA7,0x19,0x97,0x38,0x87,0xDF,0xF7,0xFE,0xE7,0x9D,0xD7,0xBC,0xC7, 

		0xC4,0x48,0xE5,0x58,0x86,0x68,0xA7,0x78,0x40,0x08,0x61,0x18,0x02,0x28,0x23,0x38, 

		0xCC,0xC9,0xED,0xD9,0x8E,0xE9,0xAF,0xF9,0x48,0x89,0x69,0x99,0x0A,0xA9,0x2B,0xB9, 

		0xF5,0x5A,0xD4,0x4A,0xB7,0x7A,0x96,0x6A,0x71,0x1A,0x50,0x0A,0x33,0x3A,0x12,0x2A, 

		0xFD,0xDB,0xDC,0xCB,0xBF,0xFB,0x9E,0xEB,0x79,0x9B,0x58,0x8B,0x3B,0xBB,0x1A,0xAB, 

		0xA6,0x6C,0x87,0x7C,0xE4,0x4C,0xC5,0x5C,0x22,0x2C,0x03,0x3C,0x60,0x0C,0x41,0x1C, 

		0xAE,0xED,0x8F,0xFD,0xEC,0xCD,0xCD,0xDD,0x2A,0xAD,0x0B,0xBD,0x68,0x8D,0x49,0x9D, 

		0x97,0x7E,0xB6,0x6E,0xD5,0x5E,0xF4,0x4E,0x13,0x3E,0x32,0x2E,0x51,0x1E,0x70,0x0E, 

		0x9F,0xFF,0xBE,0xEF,0xDD,0xDF,0xFC,0xCF,0x1B,0xBF,0x3A,0xAF,0x59,0x9F,0x78,0x8F, 

		0x88,0x91,0xA9,0x81,0xCA,0xB1,0xEB,0xA1,0x0C,0xD1,0x2D,0xC1,0x4E,0xF1,0x6F,0xE1, 

		0x80,0x10,0xA1,0x00,0xC2,0x30,0xE3,0x20,0x04,0x50,0x25,0x40,0x46,0x70,0x67,0x60, 

		0xB9,0x83,0x98,0x93,0xFB,0xA3,0xDA,0xB3,0x3D,0xC3,0x1C,0xD3,0x7F,0xE3,0x5E,0xF3, 

		0xB1,0x02,0x90,0x12,0xF3,0x22,0xD2,0x32,0x35,0x42,0x14,0x52,0x77,0x62,0x56,0x72, 

		0xEA,0xB5,0xCB,0xA5,0xA8,0x95,0x89,0x85,0x6E,0xF5,0x4F,0xE5,0x2C,0xD5,0x0D,0xC5, 

		0xE2,0x34,0xC3,0x24,0xA0,0x14,0x81,0x04,0x66,0x74,0x47,0x64,0x24,0x54,0x05,0x44, 

		0xDB,0xA7,0xFA,0xB7,0x99,0x87,0xB8,0x97,0x5F,0xE7,0x7E,0xF7,0x1D,0xC7,0x3C,0xD7, 

		0xD3,0x26,0xF2,0x36,0x91,0x06,0xB0,0x16,0x57,0x66,0x76,0x76,0x15,0x46,0x34,0x56, 

		0x4C,0xD9,0x6D,0xC9,0x0E,0xF9,0x2F,0xE9,0xC8,0x99,0xE9,0x89,0x8A,0xB9,0xAB,0xA9, 

		0x44,0x58,0x65,0x48,0x06,0x78,0x27,0x68,0xC0,0x18,0xE1,0x08,0x82,0x38,0xA3,0x28, 

		0x7D,0xCB,0x5C,0xDB,0x3F,0xEB,0x1E,0xFB,0xF9,0x8B,0xD8,0x9B,0xBB,0xAB,0x9A,0xBB, 

		0x75,0x4A,0x54,0x5A,0x37,0x6A,0x16,0x7A,0xF1,0x0A,0xD0,0x1A,0xB3,0x2A,0x92,0x3A, 

		0x2E,0xFD,0x0F,0xED,0x6C,0xDD,0x4D,0xCD,0xAA,0xBD,0x8B,0xAD,0xE8,0x9D,0xC9,0x8D, 

		0x26,0x7C,0x07,0x6C,0x64,0x5C,0x45,0x4C,0xA2,0x3C,0x83,0x2C,0xE0,0x1C,0xC1,0x0C, 

		0x1F,0xEF,0x3E,0xFF,0x5D,0xCF,0x7C,0xDF,0x9B,0xAF,0xBA,0xBF,0xD9,0x8F,0xF8,0x9F, 

		0x17,0x6E,0x36,0x7E,0x55,0x4E,0x74,0x5E,0x93,0x2E,0xB2,0x3E,0xD1,0x0E,0xF0,0x1E};

	int ax=0,bx=0,dx=0,i;

	for (i=0 ; i<0x15 ; i++ )

	{

		dx = ax;

		bx = 0;

		bx = (bx&0xff00) | (sCircleBase[i]);

		dx &= 0xffff;

		dx >>= 8;

		dx ^= bx;

		bx = 0;

		bx &= 0x00ff;

		bx |= (ax&0xff)<<8;

		ax = Table[dx*2] | Table[dx*2+1]<<8;

		ax ^= bx;

	}

	RuijieChecksum[0] = (uint8_t) ((ax&0xff00)>>8);

	RuijieChecksum[1] = (uint8_t) (ax&0x00ff);

}

/************************************************************************

 * getNP is use to get IP, Netmask, Hardward Address of eth0.

 * It also check wether we use static IP or shift to 2nd authentication.

 *************************************************************************/

int getNP(struct interface_data *thisint, uint8_t *address, int request)  

{  

	int sock,i;  

	struct ifreq ifr;  

	// initiate the socket

	sock = socket(AF_INET,SOCK_DGRAM,0);  

	if (sock == -1)  

	{  

		perror("socket");  

		return   -1;  

	}  

	strncpy(ifr.ifr_name, thisint->intName, IFNAMSIZ);  

	ifr.ifr_name[IFNAMSIZ - 1] = 0;  

	if (ioctl(sock,request,&ifr) < 0)  

	{  

		perror("ioctl");  

		return   -1;  

	}  

	//memcpy(&sin,   &ifr.ifr_addr,   sizeof(sin));  

	memcpy(address, ifr.ifr_addr.sa_data+2, 4);  

	for(i=0;i<4;i++)

		debug_printf(DEBUG_NORMAL,"%.2x ",address[i]);

	debug_printf(DEBUG_NORMAL,"\n");

	// bring down the socket

	close(sock);

	return 0;

} 

/************************************************************************

 * the readNLSock, parseRoutes and gotRoutes are using to get the route 

 * information via socket.

 * Modified from Bob's orginal code.

 ************************************************************************/

uint8_t ggateway[4];

int readNlSock(int sockFd, uint8_t *bufPtr, int seqNum, int pId)

{

	struct nlmsghdr *nlHdr;

	int readLen = 0, msgLen = 0;

	do{

		/* Recieve response from the kernel */

		if((readLen = recv(sockFd, bufPtr, BUFSIZE - msgLen, 0)) < 0)

		{

			perror("SOCK READ: ");

			return -1;

		}

		nlHdr = (struct nlmsghdr *)bufPtr;

		/* Check if the header is valid */

		if((NLMSG_OK(nlHdr, readLen) == 0) || (nlHdr->nlmsg_type == NLMSG_ERROR))

		{

			perror("Error in recieved packet");

			return -1;

		}

		/* Check if the its the last message */

		if(nlHdr->nlmsg_type == NLMSG_DONE)

		{

			break;

		}

		else

		{

		/* Else move the pointer to buffer appropriately */

			bufPtr += readLen;

			msgLen += readLen;

		}

		/* Check if its a multi part message */

		if((nlHdr->nlmsg_flags & NLM_F_MULTI) == 0) 

		{

		/* return if its not */

			break;

		}

	}

	while((nlHdr->nlmsg_seq != seqNum) || (nlHdr->nlmsg_pid != pId));

	return msgLen;

}

/* For parsing the route info returned */

int parseRoutes(struct nlmsghdr *nlHdr, struct route_info *rtInfo, uint8_t * gateway)

{

	struct rtmsg *rtMsg;

	struct rtattr *rtAttr;

	int rtLen,i;

	uint8_t *tempBuf = NULL;

	tempBuf = (uint8_t *)malloc(100);

	rtMsg = (struct rtmsg *)NLMSG_DATA(nlHdr);

/* If the route is not for AF_INET or does not belong to main routing table

then return. */

	if((rtMsg->rtm_family != AF_INET) || (rtMsg->rtm_table != RT_TABLE_MAIN))

		return -1;

/* get the rtattr field */

	rtAttr = (struct rtattr *)RTM_RTA(rtMsg);

	rtLen = RTM_PAYLOAD(nlHdr);

	for(;RTA_OK(rtAttr,rtLen);rtAttr = RTA_NEXT(rtAttr,rtLen))

	{

		switch(rtAttr->rta_type)

		{

			case RTA_OIF:

				if_indextoname(*(int *)RTA_DATA(rtAttr), rtInfo->ifName);

				break;

			case RTA_GATEWAY:

				rtInfo->gateWay = *(uint32_t *)RTA_DATA(rtAttr);

				break;

			case RTA_PREFSRC:

				rtInfo->srcAddr = *(uint32_t *)RTA_DATA(rtAttr);

				break;

			case RTA_DST:

				rtInfo->dstAddr = *(uint32_t *)RTA_DATA(rtAttr);

				break;

		}

	}

//printf("%s\n", (uint8_t *)inet_ntoa(rtInfo->dstAddr));

// ADDED BY BOB - ALSO COMMENTED printRoute

	if (strstr((uint8_t *)inet_ntoa(*(struct in_addr *)&rtInfo->dstAddr), "0.0.0.0"))

	{

		memcpy(gateway,&rtInfo->gateWay,4);	

		for(i=0;i<4;i++)

			printf("%.2x ",gateway[i]);

		printf("\n");

	}

//printRoute(rtInfo);

	free(tempBuf);

return 0;

}

int gotRoute(uint8_t * Gateway)

{

	struct nlmsghdr *nlMsg;

	struct rtmsg *rtMsg;

	struct route_info *rtInfo;

	uint8_t msgBuf[BUFSIZE];

	int sock, len, msgSeq = 0;

	/* Create Socket */

	if((sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0)

		perror("Socket Creation: ");

	/* Initialize the buffer */

	memset(msgBuf, 0, BUFSIZE);

	/* point the header and the msg structure pointers into the buffer */

	nlMsg = (struct nlmsghdr *)msgBuf;

	rtMsg = (struct rtmsg *)NLMSG_DATA(nlMsg);

	/* Fill in the nlmsg header*/

	nlMsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); // Length of message.

	nlMsg->nlmsg_type = RTM_GETROUTE; // Get the routes from kernel routing table .

	nlMsg->nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST; // The message is a request for dump.

	nlMsg->nlmsg_seq = msgSeq++; // Sequence of the message packet.

	nlMsg->nlmsg_pid = getpid(); // PID of process sending the request.

	/* Send the request */

	if(send(sock, nlMsg, nlMsg->nlmsg_len, 0) < 0)

	{

		printf("Write To Socket Failed...\n");

		return -1;

	}

	/* Read the response */

	if((len = readNlSock(sock, msgBuf, msgSeq, getpid())) < 0)

	{

		printf("Read From Socket Failed...\n");

		return -1;

	}

	/* Parse and print the response */

	rtInfo = (struct route_info *)malloc(sizeof(struct route_info));

	// ADDED BY BOB

	/* THIS IS THE NETTSTAT -RL code I commented out the printing here and in parse routes */

	//fprintf(stdout, "Destination\tGateway\tInterface\tSource\n");

	for(;NLMSG_OK(nlMsg,len);nlMsg = NLMSG_NEXT(nlMsg,len))

	{

		memset(rtInfo, 0, sizeof(struct route_info));

		parseRoutes(nlMsg, rtInfo,Gateway);

	}

	if(Gateway[0]==0)

	{

		printf("Couldn't get route!\n");

		return -1;

	}

	free(rtInfo);

	close(sock);

// ADDED BY BOB

	return 0;

}

/************************************************************************

 * gotDNS use some trick to got DNS, because I feel that system also look

 * into /etc/resolv.conf for DNS :)

 * **********************************************************************/

int gotDNS(uint8_t * dns)

{	

	FILE* dnsfile;

	char input[20];

	system("cat /etc/resolv.conf | sed -n '/^nameserver/p' | awk '{print $2}' > /tmp/dns.conf");

	dnsfile=fopen("/tmp/dns.conf","r");

	if(dnsfile==NULL)

	{

		perror("Error opening file");

		return -1;

	}

	fgets(input,20,dnsfile);

	input[19]=0;

	sprintf(DNS,"%s",input);

	DNS[19]=0;

	inet_aton(input,dns);

	fclose(dnsfile);

	remove("/tmp/dns.conf");

	debug_printf(DEBUG_EVERYTHING,"The DNS is %s\n",input);

    return 0;

}

#define RGSIGLEN	0x90

#define IP	SIOCGIFADDR

#define NM	SIOCGIFNETMASK

#define BUFSIZE		8192

#define RJ_IP_OFFSET	5

#define RJ_NM_OFFSET	9

#define RJ_GW_OFFSET	13

#define RJ_DNS_OFFSET	17

#define RJ_CS_OFFSET	21

#define RJ_HASH_OFFSET	78

#define RJ_DHCP_OFFSET	121

#define RJ_MAC_OFFSET	130

extern uint8_t  md5rec[16];// To store the MD5 hash sent by authenticator.

extern char  DNS[20];

struct route_info

{

	uint32_t dstAddr;

	uint32_t srcAddr;

	uint32_t gateWay;

uint8_t ifName[16];

};

void append_rgtail(struct interface_data *);

void get_rg_ssid(struct interface_data *);

void  randstr(uint8_t *);

void Hash8021x( uint8_t *);

void checksumNP(uint8_t * ,uint8_t * );

int getNP(struct interface_data *, uint8_t * , int );

int readNlSock(int , uint8_t *, int , int );

int parseRoutes(struct nlmsghdr *, struct route_info *, uint8_t * );

int gotRoute(uint8_t * );

int gotDNS(uint8_t * );

  // Store the random value sent to us for Ruijie Authentication

  if(ruijie_op==1)

  {

    memcpy(md5rec,&md5data->randval,MD5_LENGTH);

  }

  if(ruijie_op==1)// decide whether to use Ruijie Private broadbast address.

    {

      dot1x_default_dest[0] = 0x01;

      dot1x_default_dest[6] = 0xd0;

      dot1x_default_dest[6] = 0xf8;

      dot1x_default_dest[6] = 0x00;

      dot1x_default_dest[6] = 0x00;

      dot1x_default_dest[6] = 0x03;

    }

  //work->rg_sserial.ulValue = 0x1000002a;

extern int ruijie_op;

//type for algorithms from Ruijie md5 algorithm.

typedef union

{

	u_int32_t ulValue;

	u_int8_t  btValue[4];

}ULONG_BYTEARRAY;

  /* per Ruijie needed */

  char echoWhile;

  char pingWhile;

  ULONG_BYTEARRAY rg_ssid;

  ULONG_BYTEARRAY rg_sserial;  

#include <stdint.h>

   //Send echo packet every 60sec.

  if(ruijie_op==1)

  {

    if (ctx->statemachine->echoWhile == 0)

      {   

        txKeepAlive(ctx); 

        debug_printf(DEBUG_STATE, "Time to Send Red Gaint echo Packet\n");

        ctx->statemachine->echoWhile = 60;

      }

    if (ctx->statemachine->pingWhile == 0)

      {   

        debug_printf(DEBUG_STATE, "Time to ping DNS.\n");

        char pingcom[30];

        sprintf(pingcom,"ping -c 3 %s",DNS,30);

        pingcom[29]=0;

        printf("%s\n",pingcom);

        if(system( pingcom ) != 0)

        {

	        // Connection is dropped by authenticator, we reconnect

	        ctx->statemachine->eapolEap = FALSE;

	        md5rec[0]=0;

	        md5rec[2]=0;

	        ctx->statemachine->pingWhile = 17;// set next ping Check 17 sec. later

	        statemachine_change_state(ctx, CONNECTING);

        }

        else

        {

	        ctx->statemachine->pingWhile = 17;// set next ping Check 17 sec. later

        }

      }

    }

  }

  if(ruijie_op==1)// If we are using Ruijie's private algorithm, add the tail.

  {

    append_rgtail(thisint);

  }

uint8_t encodeNP(uint8_t BForencodeNP)

{             

	int a=0,b=0,c=0,d=0,iRt;

	a=BForencodeNP;

	c=a;

	d=a;

	c&=0x40;

	b=a;

	d>>=2;

	c|=d;

	d=a;

	c>>=2;

	d&=0x20;

	c|=d;

	d=a;

	c>>=2;

	d&=0x10;

	c|=d;

	d=a;

	d&=2;

	b<<=2;

	d|=b;

	b=a;

	d<<=2;

	b&=4;

	a&=8;

	d|=b;

	d<<=2;

	d|=a;

	c>>=1;

	d<<=1;

	c|=d;

	iRt=(~c)&0xff;

	return iRt;

}

int txKeepAlive(struct interface_data *thisint)

{

	uint8_t rgalivebit[] = { 0x01, 0xbf, 0x00, 0x1e, 0xff, 0xff, 0x37, 0x77, 0x7f, 0x9f, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x37, 0x77, 0x7f, 0x9f, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x37, 0x77, 0x7f, 0x3f, 0xff};

	ULONG_BYTEARRAY uCrypt1,uCrypt2,uCrypt1_After,uCrypt2_After;

	thisint->rg_sserial.ulValue++;

	uCrypt1.ulValue = thisint->rg_ssid.ulValue + thisint->rg_sserial.ulValue;

	uCrypt2.ulValue = thisint->rg_sserial.ulValue;

	uCrypt1_After.ulValue = htonl( uCrypt1.ulValue );

	uCrypt2_After.ulValue = htonl( uCrypt2.ulValue );

	rgalivebit[0x0b] = encodeNP(uCrypt1_After.btValue[0]);

	rgalivebit[0x0c] = encodeNP(uCrypt1_After.btValue[1]);

	rgalivebit[0x0d] = encodeNP(uCrypt1_After.btValue[2]);

	rgalivebit[0x0e] = encodeNP(uCrypt1_After.btValue[3]);

	rgalivebit[0x15] = encodeNP(uCrypt2_After.btValue[0]);

	rgalivebit[0x16] = encodeNP(uCrypt2_After.btValue[1]);

	rgalivebit[0x17] = encodeNP(uCrypt2_After.btValue[2]);

	rgalivebit[0x18] = encodeNP(uCrypt2_After.btValue[3]);

	memcpy(&thisint->sendframe[OFFSET_TO_EAP - 4],rgalivebit,31);

	thisint->send_size = OFFSET_TO_EAP - 4 + 31;

	cardif_sendframe(thisint);

	return XENONE;

}

#include <stdint.h>

int txKeepAlive(struct interface_data *);

uint8_t encodeNP(uint8_t);

int ruijie_op=0;

	       "[-r]"

  debug_printf(DEBUG_NORMAL, "-r : Enable Ruijie private algorithm.\n");

	case 'r':

	  // Set to use Ruijie private algorithm.

	  ruijie_op=1;

	  // added by acevery, need to control whether we use 

	  // standard EAP-md5

	  break;