/*
*********************************************************************************************************
* CHECK TIMEOUT
*
* Description: This function checks the timeout of DHCP in each state.
* Arguments : None.
* Returns : None.
* Note :
*********************************************************************************************************
*/
void check_DHCP_Timeout(void)
{
if (dhcp_retry_count < MAX_DHCP_RETRY)
{
if (dhcp_time > next_dhcp_time)
{
dhcp_time = 0;
next_dhcp_time = dhcp_time + DHCP_WAIT_TIME;
dhcp_retry_count++;
switch ( dhcp_state )
{
case STATE_DHCP_DISCOVER :
#ifdef DHCP_DEBUG
printf("<<timeout>> state : STATE_DHCP_DISCOVER\r\n");
#endif
send_DHCP_DISCOVER();
break;
case STATE_DHCP_REQUEST :
#ifdef DHCP_DEBUG
printf("<<timeout>> state : STATE_DHCP_REQUEST\r\n");
#endif
send_DHCP_REQUEST();
break;
case STATE_DHCP_REREQUEST :
#ifdef DHCP_DEBUG
printf("<<timeout>> state : STATE_DHCP_REREQUEST\r\n");
#endif
send_DHCP_REQUEST();
break;
default :
break;
}
}
}
else
{
reset_DHCP_time();
DHCP_timeout = 1;
send_DHCP_DISCOVER();
dhcp_state = STATE_DHCP_DISCOVER;
#ifdef DHCP_DEBUG
printf("timeout : state : STATE_DHCP_DISCOVER\r\n");
#endif
}
}
/*
*********************************************************************************************************
* CHECK TIMEOUT
*
* Description: This function checks the timeout of DHCP in each state.
* Arguments : None.
* Returns : None.
* Note :
*********************************************************************************************************
*/
void check_Timeout(uint8_t s, wiz_NetInfo *pWIZNETINFO)
{
uint8_t i, d_addr[4];
if (retry_count < MAX_DHCP_RETRY) {
if (next_time < jshGetSystemTime()) {
next_time = jshGetSystemTime() + DHCP_WAIT_TIME;
retry_count++;
switch ( dhcp_state ) {
case STATE_DHCP_DISCOVER :
// jsiConsolePrintf("<<timeout>> state : STATE_DHCP_DISCOVER\r\n");
send_DHCP_DISCOVER(s, pWIZNETINFO);
break;
case STATE_DHCP_REQUEST :
// jsiConsolePrintf("<<timeout>> state : STATE_DHCP_REQUEST\r\n");
for (i = 0; i < 4; i++) d_addr[i] = 0xff;
send_DHCP_REQUEST(s, Cip, d_addr, pWIZNETINFO);
break;
case STATE_DHCP_REREQUEST :
// jsiConsolePrintf("<<timeout>> state : STATE_DHCP_REREQUEST\r\n");
for (i = 0; i < 4; i++) d_addr[i] = DHCP_SIP[i];
send_DHCP_REQUEST(s, (*pWIZNETINFO).ip, d_addr, pWIZNETINFO);
break;
default :
break;
}
}
} else {
next_time = jshGetSystemTime() + DHCP_WAIT_TIME;
retry_count = 0;
DHCP_timeout = 1;
/* open a socket in IP RAW mode for DHCP */
socket(s, Sn_MR_UDP, DHCP_CLIENT_PORT, 0x00);
send_DHCP_DISCOVER(s, pWIZNETINFO);
dhcp_state = STATE_DHCP_DISCOVER;
}
}
/*
*********************************************************************************************************
* Get an IP from the DHCP server.
*
* Description:
* Arguments : None.
* Returns : None.
* Note :
*********************************************************************************************************
*/
uint8_t getIP_DHCPS(uint8_t s, wiz_NetInfo *pWIZNETINFO)
{
uint8_t tmpip[4];
DHCP_XID = 0x12345678;
setSHAR((*pWIZNETINFO).mac);
// SRC IP
tmpip[0] = 0;
tmpip[1] = 0;
tmpip[2] = 0;
tmpip[3] = 0;
setSIPR(tmpip);
setGAR(tmpip);
setSUBR(tmpip);
//sysinit(tx_mem_conf, rx_mem_conf);
socket(s, Sn_MR_UDP, DHCP_CLIENT_PORT, 0x00);
// Create UDP socket for network configuration
//socket(SOCK_CONFIG, Sn_MR_UDP, REMOTE_CLIENT_PORT, 0x00);
send_DHCP_DISCOVER(s, pWIZNETINFO);
dhcp_state = STATE_DHCP_DISCOVER;
DHCP_timeout = 0;
next_time = jshGetSystemTime() + DHCP_WAIT_TIME;
retry_count = 0;
while (dhcp_state != STATE_DHCP_LEASED)
{
//*************
// Add James Kim for IWatchDog
#ifdef _IWDG
/* Reload IWDG counter */
IWDG_ReloadCounter();
#endif
//
//**************
//if (Recv_ConfigMsg() == MSG_SETTING_REQ) return(2);
if (DHCP_timeout == 1 || jspIsInterrupted()) {
jsiConsolePrintf("> => DHCP Timeout occurred\r\n");
return(0);
}
check_DHCP_state(s, pWIZNETINFO);
}
return 1;
}
/*
*********************************************************************************************************
* CHECK DHCP STATE
*
* Description: This function checks the state of DHCP.
* Arguments : None.
* Returns : None.
* Note :
*********************************************************************************************************
*/
uint8 check_DHCP_state(SOCKET s)
{
uint16 len;
uint8 type;
type = 0;
if(getSn_SR(s)!=SOCK_CLOSED)
{
if ((len = getSn_RX_RSR(s)) > 0)
{
type = parseDHCPMSG(len);
}
}
else
{
if(dhcp_state == STATE_DHCP_READY)
{
//init_dhcp_client();
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_READY\r\n");
#endif
}
if(!socket(SOCK_DHCP,Sn_MR_UDP,DHCP_CLIENT_PORT,0x00))
{
#ifdef DHCP_DEBUG
printf("Fail to create the DHCPC_SOCK(%u)\r\n",SOCK_DHCP);
#endif
return DHCP_RET_ERR;
}
}
switch ( dhcp_state )
{
case STATE_DHCP_READY:
DHCP_timeout = 0;
reset_DHCP_time();
send_DHCP_DISCOVER();
DHCP_timer = 0;//set_timer0(DHCP_timer_handler);
dhcp_state = STATE_DHCP_DISCOVER;
break;
case STATE_DHCP_DISCOVER :
if (type == DHCP_OFFER)
{
reset_DHCP_time();
send_DHCP_REQUEST();
dhcp_state = STATE_DHCP_REQUEST;
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_REQUEST\r\n");
#endif
}
else
check_DHCP_Timeout();
break;
case STATE_DHCP_REQUEST :
if (type == DHCP_ACK)
{
reset_DHCP_time();
if (check_leasedIP())
{
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_LEASED\r\n");
#endif
dhcp_state = STATE_DHCP_LEASED;
return DHCP_RET_UPDATE;
}
else
{
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_DISCOVER\r\n");
#endif
dhcp_state = STATE_DHCP_DISCOVER;
return DHCP_RET_CONFLICT;
}
}
else if (type == DHCP_NAK)
{
reset_DHCP_time();
dhcp_state = STATE_DHCP_DISCOVER;
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_DISCOVER\r\n");
#endif
}
else
check_DHCP_Timeout();
break;
case STATE_DHCP_LEASED :
if ((dhcp_lease_time != 0xffffffff) && (dhcp_time>(dhcp_lease_time/2)))
{
type = 0;
memcpy(OLD_SIP,GET_SIP,4);
DHCP_XID++;
send_DHCP_REQUEST();
dhcp_state = STATE_DHCP_REREQUEST;
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_REREQUEST\r\n");
#endif
reset_DHCP_time();
}
break;
case STATE_DHCP_REREQUEST :
if (type == DHCP_ACK)
{
if(memcmp(OLD_SIP,GET_SIP,4)!=0)
{
#ifdef DHCP_DEBUG
printf("The IP address from the DHCP server is updated.\r\n");
printf("OLD_SIP=%u.%u.%u.%u",OLD_SIP[0],OLD_SIP[1],OLD_SIP[2],OLD_SIP[3]);
printf("GET_SIP=%u.%u.%u.%u\r\n",GET_SIP[0],GET_SIP[1],GET_SIP[2],GET_SIP[3]);
#endif
return DHCP_RET_UPDATE;
}
#ifdef DHCP_DEBUG
else
{
printf("state : STATE_DHCP_LEASED : same IP\r\n");
}
#endif
reset_DHCP_time();
dhcp_state = STATE_DHCP_LEASED;
}
else if (type == DHCP_NAK)
{
reset_DHCP_time();
dhcp_state = STATE_DHCP_DISCOVER;
#ifdef DHCP_DEBUG
printf("state : STATE_DHCP_DISCOVER\r\n");
#endif
}
else
check_DHCP_Timeout();
break;
default :
dhcp_state = STATE_DHCP_READY;
break;
}
if (DHCP_timeout == 1)
{
//kill_timer0(DHCP_timer);
dhcp_state = STATE_DHCP_READY;
return DHCP_RET_TIMEOUT;
}
return DHCP_RET_NONE;
}
