dhcp.c

用MCS51 单片机的TCIP协议的测试,很基本的程序,对新手可能有帮助!

			lease_time.cVal[3] = *p++;
		/*	
		#ifdef DHCP_DEBUG
			PutString("dhcpIPaddrLeaseTime : ");
			PutHTOA(lease_time.cVal[0]);PutByte(' ');
			PutHTOA(lease_time.cVal[1]);PutByte(' ');
			PutHTOA(lease_time.cVal[2]);PutByte(' ');
			PutHTOA(lease_time.cVal[3]);PutStringLn("");
			
			PutString(" lease time = ");
			PutLTOA(lease_time.lVal);
			PutStringLn("");
		#endif
		*/
			break;

		case dhcpServerIdentifier :
			p++;
			opt_len = *p++;
			DHCPS_IP[0] = *p++;
			DHCPS_IP[1] = *p++;
			DHCPS_IP[2] = *p++;
			DHCPS_IP[3] = *p++;
		/*
		#ifdef DHCP_DEBUG
			PutString("dhcpServerIdentifier : ");
			PutHTOA(DHCPS_IP[0]);PutByte(' ');
			PutHTOA(DHCPS_IP[1]);PutByte(' ');
			PutHTOA(DHCPS_IP[2]);PutByte(' ');
			PutHTOA(DHCPS_IP[3]);PutStringLn("");
		#endif
		*/
			break;
				
		default :
			p++;
			opt_len = *p++;
			p += opt_len;
			/*
			#ifdef DHCP_DEBUG
				PutString("opt_len : ");
				PutHTOA(opt_len);
				PutStringLn("");
			#endif
			*/
			break;
		}
	}
PARSE_END:
    return	type;
}

/*
********************************************************************************
* Description : 
* Arguments   : None
* Returns     : 
* Note        : 
********************************************************************************
*/
void check_retry(void)
{
	if (retry_count < MAX_DHCP_RETRY) {
		if (next_time < my_time) {
			my_time = 0;
			next_time = my_time + DHCP_WAIT_TIME;
			retry_count++;
			switch ( dhcp_state ) {
				case STATE_DHCP_DISCOVER :
					send_DHCP_DISCOVER(SOCK_DHCP);
				break;
		
				case STATE_DHCP_REQUEST :
					send_DHCP_REQUEST(SOCK_DHCP);
				break;

				case STATE_DHCP_REREQUEST :
					socket(SOCK_DHCP, SOCK_DGRAM, DHCP_CLIENT_PORT, 0x80);
					DHCP_XID++;
					send_DHCP_REQUEST(SOCK_DHCP);
				break;
		
				default :
				break;
			}
		}
	} else {
		if (!Debug_Off) PutStringLn("\n\r << Time Out >>");
		DHCP_Timeout = 1;
		
		my_time = 0;
		next_time = my_time + DHCP_WAIT_TIME;
		retry_count = 0;
		send_DHCP_DISCOVER(SOCK_DHCP);
		dhcp_state = STATE_DHCP_DISCOVER;
		
	}
}

/*
********************************************************************************
* Description : Check leased IP or not
* Arguments   : None
* Returns     : 
* Note        : 
********************************************************************************
*/
char check_leasedIP(void)
{
	u_char ip[10];
	u_int port, i;

	socket(SOCK_DHCP, SOCK_DGRAM, DHCP_CLIENT_PORT, 0x80);

	ip[0] = IpAddr[0];
	ip[1] = IpAddr[1];
	ip[2] = IpAddr[2];
	ip[3] = IpAddr[3];
	port = 5000;

#ifdef DHCP_DEBUG
	PutStringLn(" check leasedIP ");
#endif

	/* sendto is complete. that means there is a node which has a same IP. */
	if (sendto(SOCK_DHCP, (u_char *)ip, 10, ip, port) != -1)
	{
		
#ifdef DHCP_DEBUG
	PutStringLn("Same IP");
#endif
		for (i = 0; i < 4; i++) close(i);
		wait_10ms(100);

		COMMAND(0) = CSW_RESET;

		for (i = 0; i < 4; i++) {
			IpAddr[i] = 0;
			ip [i] = 0;
		}      
		
		setIP(ip);
		
	 	setMACAddr(&Mac);

		sysinit(0x55, 0x55);
	
		socket(SOCK_DHCP, SOCK_DGRAM, DHCP_CLIENT_PORT, 0x80);
	
		send_DHCP_DISCOVER(SOCK_DHCP);

		return 0;
	}
	
	return 1;
}	

/*
********************************************************************************
* Description :  
* Arguments   : 
* Returns     : 
* Note        : 
********************************************************************************
*/
void set_network(void)
{
	u_char i;
	char xdata str[16];

#ifdef DHCP_DEBUG
	PutStringLn(" << Set Network(DHCP) >>");
#endif	
	COMMAND(0) = CSW_RESET;
	
	for(i = 0; i < 4; i++)	{
		EEP_Write(EE_GW1 + i, Gateway[i]);
	}
	setgateway(Gateway);   

	for(i = 0; i < 4; i++)	{
		EEP_Write(EE_SM1 + i, SubMask[i]);
	}
	setsubmask(SubMask);

	for(i = 0; i < 4; i++)	{
		EEP_Write(EE_IA1 + i, IpAddr[i]);
	}
	setIP(IpAddr);
	
 	setMACAddr(&Mac);
 	
	*(TIMEOUT_PTR + 2) = 0x03; // Retry Count Register : set timeout cnt
	
	sysinit(0x55,0x55);
 	
	
	if (!Debug_Off) {
		inet_ntoa(DHCPS_IP,str);
		PutString(" DHCP Server IP : "); PutStringLn(str);
		inet_ntoa(IpAddr, str);
		PutString(" IP : "); PutStringLn(str);
		inet_ntoa(SubMask, str);
		PutString(" SM : "); PutStringLn(str);
		inet_ntoa(Gateway, str);
		PutString(" GW : "); PutStringLn(str);
	
	}
}


/*
********************************************************************************
* Description : 
* Arguments   : 
* Returns     : 
* Note        : 
********************************************************************************
*/
void check_dhcp(void) 
{
	u_int len;
	u_char i, flag, type = 0;

	if ((len = select(SOCK_DHCP, SEL_RECV)) > 0) {
		EX0 = 0;
		type = parseDHCPMSG(SOCK_DHCP, len);
		EX0 = 1;
	}
	
	switch ( dhcp_state ) {
		case STATE_DHCP_DISCOVER :
			if (type == DHCP_OFFER) {
				#ifdef DHCP_DEBUG
					PutStringLn("Receive DHCP_Offer");
				#endif
				send_DHCP_REQUEST(SOCK_DHCP);
				dhcp_state = STATE_DHCP_REQUEST;
				#ifdef DHCP_DEBUG
				  PutString("state : STATE_DHCP_REQUEST\r\n");
				#endif
				
			} else check_retry(); // resend DISCOVER message
		break;

		case STATE_DHCP_REQUEST :
			if (type == DHCP_ACK) {
				#ifdef DHCP_DEBUG
				  PutStringLn(" Receive ACK");
				#endif
				if (check_leasedIP()) {
					set_network();
					dhcp_state = STATE_DHCP_LEASED;
					my_time = 0;
					next_time = my_time + DHCP_WAIT_TIME;
					retry_count = 0;
					#ifdef DHCP_DEBUG
						PutString("state : STATE_DHCP_LEASED\r\n");
					#endif
				} else {
					my_time = 0;
					next_time = my_time + DHCP_WAIT_TIME;
					retry_count = 0;
					dhcp_state = STATE_DHCP_DISCOVER;
					#ifdef DHCP_DEBUG
						PutString("==>state : STATE_DHCP_DISCOVER\r\n");
					#endif
				}
			} else if (type == DHCP_NAK) {
				#ifdef DHCP_DEBUG
				  PutStringLn(" Receive NACK");
				#endif
				my_time = 0;
				next_time = my_time + DHCP_WAIT_TIME;
				retry_count = 0;
				dhcp_state = STATE_DHCP_DISCOVER;
			} else check_retry();	// resend REQUEST message
		break;

		case STATE_DHCP_LEASED :
			if ((lease_time.lVal != 0xffffffff) && ((lease_time.lVal/2) < my_time)) {
				#ifdef DHCP_DEBUG
					PutStringLn(">>>> STATE_DHCP_LEASED");
				#endif
				
				type = 0;
				for (i = 0; i < 4; i++)	OLD_SIP[i] = IpAddr[i];
				
				socket(SOCK_DHCP, SOCK_DGRAM, DHCP_CLIENT_PORT, 0x80);
				DHCP_XID++;
				send_DHCP_REQUEST(SOCK_DHCP);
				
				dhcp_state = STATE_DHCP_REREQUEST;
				my_time = 0;
				next_time = my_time + DHCP_WAIT_TIME;
			}
			break;

		case STATE_DHCP_REREQUEST :
			#ifdef DHCP_DEBUG
				PutStringLn(" < STATE_DHCP_REREQUEST >");
				PutString("type : ");PutHTOA(type);PutStringLn("");
			#endif
			if (type == DHCP_ACK) {
				retry_count = 0;
				flag = 0;
				
				for (i = 0; i < 4; i++)	{
					if (OLD_SIP[i] != IpAddr[i]) {
						flag = 1;
						break;
					}
				}
				
				if (flag) {
					my_time = 0;
					set_network(); // re-setting
				} else {
					//if (!Debug_Off) PutString("Same IP\r\n");
				}
				
				my_time = 0;
				next_time = my_time + DHCP_WAIT_TIME;
				dhcp_state = STATE_DHCP_LEASED;
			} else if (type == DHCP_NAK) {
				my_time = 0;
				next_time = my_time + DHCP_WAIT_TIME;
				retry_count = 0;
				dhcp_state = STATE_DHCP_DISCOVER;
				//PutString("state : STATE_DHCP_DISCOVER\r\n");
			} 
			else {
				#ifdef DHCP_DEBUG
					PutStringLn(" Check Retry ");
				#endif
				check_retry();
			}
			
		break;

		case STATE_DHCP_RELEASE :
		break;

		default :
		break;
	}
}

/*
********************************************************************************
* Description : DHCP main routine
* Arguments   : None
* Returns     : 0 when timeout occured else 1
* Note        : 
********************************************************************************
*/
char DHCP_SetIP()
{
	if (!Debug_Off) PutStringLn("\n\r> DHCP is ON");	
	
	DHCP_XID = 0x12345678;

	if (!Debug_Off) PutString(" DHCP socket : ");
	socket(SOCK_DHCP, SOCK_DGRAM, DHCP_CLIENT_PORT, 0x80);
	if (!Debug_Off) {
		PutHTOA(SOCK_DHCP);PutStringLn("th create");
	}
	
	send_DHCP_DISCOVER(SOCK_DHCP);
	dhcp_state = STATE_DHCP_DISCOVER;

	my_time = 0;
	next_time = my_time + DHCP_WAIT_TIME;
	retry_count = 0;
	Enable_DHCP_Timer = 1;
	
	while (dhcp_state != STATE_DHCP_LEASED) {
		check_dhcp();
		if (DHCP_Timeout == 1) return(0);
	}
	
	return 1;
}