void dhcp_get_ip(void) {
dhcp_send_discover(dhcp_socket);
dhcp_state = STATE_DHCP_DISCOVER;
dhcp_reset_time();
DHCP_timeout = 0;
}
/**
* DHCP: Tries o obtain DHCP parameters, refer to state-transition diagram
*/
static int32_t
dhcp_attempt(void) {
int sec;
// Send DISCOVER message and switch DHCP-client to SELECT state
dhcp_send_discover();
dhcp_state = DHCP_STATE_SELECT;
// setting up a timer with a timeout of two seconds
for (sec = 0; sec < 2; sec++) {
set_timer(TICKS_SEC);
do {
receive_ether();
// Wait until client will switch to Final state or Timeout occurs
switch (dhcp_state) {
case DHCP_STATE_SUCCESS :
return 1;
case DHCP_STATE_FAULT :
return 0;
}
} while (get_timer() > 0);
}
// timeout
return 0;
}
static void process_timeout_event(struct state *s, time_t now)
{
int ret = 0;
/*
* Is the link up? If not, try again in 1 second.
*/
if (!netdev_running(s->dev)) {
s->expire = now + 1;
s->state = s->restart_state;
return;
}
/*
* If we had an error, restore a sane state to
* restart from.
*/
if (s->state == DEVST_ERROR)
s->state = s->restart_state;
/*
* Now send a packet depending on our state.
*/
switch (s->state) {
case DEVST_BOOTP:
ret = bootp_send_request(s->dev);
s->restart_state = DEVST_BOOTP;
break;
case DEVST_DHCPDISC:
ret = dhcp_send_discover(s->dev);
s->restart_state = DEVST_DHCPDISC;
break;
case DEVST_DHCPREQ:
ret = dhcp_send_request(s->dev);
s->restart_state = DEVST_DHCPDISC;
break;
}
if (ret == -1) {
s->state = DEVST_ERROR;
s->expire = now + 10;
} else {
s->expire = now + s->retry_period;
s->retry_period *= 2;
if (s->retry_period > 60)
s->retry_period = 60;
}
}
void dhcp_check_timeout(void) {
if(retry_count < DHCP_MAX_RETRY) {
if(next_dhcp_time < dhcp_time) {
dhcp_time = 0;
next_dhcp_time = dhcp_time + DHCP_WAIT_TIME;
retry_count++;
switch(dhcp_state) {
case STATE_DHCP_DISCOVER: {
dhcp_send_discover(dhcp_socket);
break;
}
case STATE_DHCP_REQUEST: {
dhcp_send_request(dhcp_socket);
break;
}
case STATE_DHCP_REREQUEST: {
dhcp_send_request(dhcp_socket);
break;
}
default : {
break;
}
}
}
} else {
dhcp_reset_time();
DHCP_timeout = 1;
dhcp_send_discover(dhcp_socket);
dhcp_state = STATE_DHCP_DISCOVER;
}
}
void dhcp_app_call(void)
{
if(uip_newdata()) {
switch(dhcp_s.state) {
case DHCP_STATE_OFFER:
dhcp_parse_offer();
break;
case DHCP_STATE_ACK:
dhcp_parse_ack();
break;
}
}
if(uip_poll()) {
switch(dhcp_s.state) {
case DHCP_STATE_BOOT_WAIT:
if(get_clock() > dhcp_s.dhcp_renew_time)
dhcp_s.state = DHCP_STATE_DISCOVER;
break;
case DHCP_STATE_DISCOVER:
dhcp_send_discover();
break;
case DHCP_STATE_REQUEST:
dhcp_send_request();
break;
case DHCP_STATE_WAIT_RENEW:
if(get_clock() > dhcp_s.dhcp_renew_time)
dhcp_s.state = DHCP_STATE_REQUEST;
break;
}
}
}
