dhcp.c

Go to the documentation of this file.

/***************************************************************************
 * dhcp.c
 * (C) 2011 Ivan Meleca
 * www.milos.it
 *

#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

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

#include "dhcp.h"
#include "socket.h"
#include "route.h"
#include <core/heap.h>
#include <core/system.h>
#include <common/mem.h>

#if __CONFIG_COMPILE_NET

typedef __TYPEDEF_PRE struct __dhcpBootpTag
{
    u8 op;                  
    u8 hw_addr_type;        
    u8 hw_addr_len;         
    u8 hops;                
    u32 xid;                
    u16 secs;               
    u16 flags;              
    u32 ciaddr;             
    u32 yiaddr;             
    u32 siaddr;             
    u32 giaddr;             
    u8 chaddr[16];          
    __STRING sname[64];     
    __STRING file[128];     
    u8 options[312];        
} __TYPEDEF_POST __DHCP_BOOTP, *__PDHCP_BOOTP;

typedef struct __dhcpLeaseTag
{
    u32 curr_timer;         
    u32 renewal;            
    u32 rebind;             
    u32 lease;              
} __DHCP_LEASE;

typedef struct __dhcpTag
{
    u8 state;               
    u8 next_state;          
    u8 retries;             
    u8 wait;                
    u32 timer;              
    u32 secs;               
    u32 xid;                
    __PDHCP_BOOTP bootp;    
    __PSOCKET sock;         
    __DHCP_LEASE lease;     
} __DHCP, *__PDHCP;

#define __DHCP_STATE_IDLE                   0
#define __DHCP_STATE_INIT                   1
#define __DHCP_STATE_SELECTING              2
#define __DHCP_STATE_REQUESTING             3
#define __DHCP_STATE_INIT_REBOOT            4
#define __DHCP_STATE_REBOOTING              5
#define __DHCP_STATE_BOUND                  6
#define __DHCP_STATE_RENEWING               7
#define __DHCP_STATE_REBINDING              8
#define __DHCP_STATE_WAIT                   9

#define __DHCP_OFFER_TIMEOUT                5
#define __DHCP_REQUEST_TIMEOUT              5
#define __DHCP_ACK_TIMEOUT                  5
#define __DHCP_REBOOT_ACK_TIMEOUT           10
#define __DHCP_ON_DISCOVER_FAIL_WAIT        5
#define __DHCP_ON_REQUEST_FAIL_WAIT         5
#define __DHCP_ON_OFFER_TIMEOUT_WAIT        5
#define __DHCP_ON_ACK_TIMEOUT_WAIT          5
#define __DHCP_DEFAULT_LEASE_TIME           43200

#define __DHCP_CLIENT_PORT                  68
#define __DHCP_SERVER_PORT                  67

#define __DHCP_MSGTYPE_DISCOVER             1
#define __DHCP_MSGTYPE_OFFER                2
#define __DHCP_MSGTYPE_REQUEST              3
#define __DHCP_MSGTYPE_DECLINE              4
#define __DHCP_MSGTYPE_ACK                  5
#define __DHCP_MSGTYPE_NAK                  6
#define __DHCP_MSGTYPE_RELEASE              7
#define __DHCP_MSGTYPE_INFORM               8

#define __DHCP_OPT_PAD                      0
#define __DHCP_OPT_NETMASK                  1
#define __DHCP_OPT_GATEWAY                  3
#define __DHCP_OPT_DNS                      6
#define __DHCP_OPT_HOSTNAME                 12
#define __DHCP_OPT_DOMAIN                   15
#define __DHCP_OPT_BROADCAST                28
#define __DHCP_OPT_REQIP                    50
#define __DHCP_OPT_LEASETIME                51
#define __DHCP_OPT_MSGTYPE                  53
#define __DHCP_OPT_SID                      54
#define __DHCP_OPT_PARAMSREQUEST            55
#define __DHCP_OPT_MAXMSGSIZE               57
#define __DHCP_OPT_RENEWALTIME              58
#define __DHCP_OPT_REBINDTIME               59
#define __DHCP_OPT_END                      255

#define __dhcpAdd8bitOption(op, t, v, len)  {*(op++)=t;*(op++)=1;*(op++)=v;len+=3;}
#define __dhcpAdd16bitOption(op, t, v, len) {*(op++)=t;*(op++)=2;v=__htons(v);__memCpy(op,&v,2);op+=2;len+=4;}
#define __dhcpAdd32bitOption(op, t, v, len) {*(op++)=t;*(op++)=4;v=__htonl(v);__memCpy(op,&v,4);op+=4;len+=6;}
#define __dhcpAddOption(op, t, l, v, len)   {*(op++)=t;*(op++)=l;__memCpy(op,v,l);op+=l;len+=l+2;}
#define __dhcpRenewXid(dhcp)                {dhcp->xid = __systemGetTickCount() * __systemGetTickCount();}

__STATIC __VOID __dhcpSetState(__PDHCP dhcp, u8 state)
{
    dhcp->state = state;

#if __NET_DEBUG_DHCP
    NETOUT(__NET_DEBUG_DHCP, ("[DHCP] new state: "));

    switch (state)
    {
        case __DHCP_STATE_IDLE:
            NETMSG(__NET_DEBUG_DHCP, ("IDLE"));
            break;
        case __DHCP_STATE_INIT:
            NETMSG(__NET_DEBUG_DHCP, ("INIT"));
            break;
        case __DHCP_STATE_SELECTING:
            NETMSG(__NET_DEBUG_DHCP, ("SELECTING"));
            break;
        case __DHCP_STATE_REQUESTING:
            NETMSG(__NET_DEBUG_DHCP, ("REQUESTING"));
            break;
        case __DHCP_STATE_INIT_REBOOT:
            NETMSG(__NET_DEBUG_DHCP, ("REBOOT"));
            break;
        case __DHCP_STATE_REBOOTING:
            NETMSG(__NET_DEBUG_DHCP, ("REBOOTING"));
            break;
        case __DHCP_STATE_BOUND:
            NETMSG(__NET_DEBUG_DHCP, ("BOUND"));
            break;
        case __DHCP_STATE_RENEWING:
            NETMSG(__NET_DEBUG_DHCP, ("RENEWING"));
            break;
        case __DHCP_STATE_REBINDING:
            NETMSG(__NET_DEBUG_DHCP, ("REBINDING"));
            break;
        case __DHCP_STATE_WAIT:
            NETMSG(__NET_DEBUG_DHCP, ("WAIT"));
            break;
    }
#endif /* __NET_DEBUG_DHCP */

}

__STATIC __BOOL __dhcpOpenSocket(__PDHCP dhcp)
{
    if (!dhcp->sock)
    {
        dhcp->sock = __socketCreate(__SOCK_TYPE_UDP, __DHCP_CLIENT_PORT);
        if (!dhcp->sock) return __FALSE;
    }

    return __TRUE;
}

__STATIC __VOID __dhcpCloseSocket(__PDHCP dhcp)
{
    __socketClose(dhcp->sock);
    __socketDestroy(dhcp->sock);
    dhcp->sock = __NULL;
}

__STATIC i32 __dhcpSendBootp(__PSOCKET sock, u32 addr, __PDHCP_BOOTP bootp, u16 opt_len)
{
    u16 len;
    bootp->options[opt_len++] = 0xFF;

    len = sizeof(__DHCP_BOOTP) - sizeof(bootp->options) + opt_len;

    if (len < 300) len = 300;

    if (__socketSendTo(sock, addr, __DHCP_SERVER_PORT, bootp, len) == len)
    {
        return 0;
    }

    return -1;
}

__STATIC u16 __dhcpPrepareBootp(__PDHCP_BOOTP bootp, u8 msgtype, u32 xid, u8* mac, u32 ciaddr, u16 sec)
{
    u8 values[3] = {1,3,6};
    u8* options;
    u16 len = 0;
    u16 val;

    bootp->op = 1;
    bootp->hw_addr_type = 1;
    bootp->hw_addr_len = 6;
    bootp->hops = 0;
    bootp->xid = xid;
    bootp->secs = sec;
    bootp->flags = __htons(0x8000); /* TODO check if needed */
    __memCpy(bootp->chaddr, mac, 6);

    options = bootp->options;

    /* Magic cookie */
    *(options++) = 0x63;
    *(options++) = 0x82;
    *(options++) = 0x53;
    *(options++) = 0x63;

    len = 4;

    /* Message type */
    __dhcpAdd8bitOption(options, __DHCP_OPT_MSGTYPE, msgtype, len);

    /* Data requested from DHCP server */
    __dhcpAddOption(options, __DHCP_OPT_PARAMSREQUEST, 3, values, len);

    /* Hostname TODO take the value from somewhere else */
    __dhcpAddOption(options, __DHCP_OPT_HOSTNAME, 5, (u8*) "milos", len);

    /* Max. DHCP message size we will accept */
    val = 576;
    __dhcpAdd16bitOption(options, __DHCP_OPT_MAXMSGSIZE, val, len);

    return len;
}

__STATIC i32 __dhcpSendDiscover(__PNETIF netif)
{
    __PDHCP dhcp = (__PDHCP) netif->dhcp;
    __PDHCP_BOOTP bootp;
    u16 len = 0;

    if (!__dhcpOpenSocket(dhcp)) return -1;

    if (dhcp->bootp == __NULL)
    {
        dhcp->bootp = __heapAlloc(sizeof(__DHCP_BOOTP));
        if (!dhcp->bootp)
        {
            __dhcpCloseSocket(dhcp);
            return -1;
        }
    }

    __memSet(dhcp->bootp, 0, sizeof(__DHCP_BOOTP));

    __dhcpRenewXid(dhcp);
    bootp = dhcp->bootp;

    len = __dhcpPrepareBootp(bootp, __DHCP_MSGTYPE_DISCOVER, dhcp->xid, netif->addr.type.mac, 0, 0);

    return __dhcpSendBootp(dhcp->sock, 0xFFFFFFFF, bootp, len);
}

__STATIC __VOID __dhcpWait(__PDHCP dhcp, u8 next_state, u8 wait)
{
    __dhcpSetState(dhcp, __DHCP_STATE_WAIT);
    dhcp->next_state = next_state;
    dhcp->timer = __systemGetSecondsCount();
    dhcp->wait = wait;
}

__STATIC i32 __dhcpRecvBootp(__PDHCP dhcp)
{
    u32 addr;
    u16 port;
    i32 ret;

    if (!__dhcpOpenSocket(dhcp)) return -1;

    if (dhcp->bootp == __NULL)
    {
        dhcp->bootp = __heapAlloc(sizeof(__DHCP_BOOTP));
        if (!dhcp->bootp) return -1;
    }

    __memSet(dhcp->bootp, 0, sizeof(__DHCP_BOOTP));

    ret = __socketRecvFrom(dhcp->sock, &addr, &port, dhcp->bootp, sizeof(__DHCP_BOOTP));

    if (ret > 0)
    {
        /* Check for (at least) the size of a BOOTP structure plus 4 byte for
         * the magic cookie plus 1 byte for the termination 0xFF */
        if (ret > sizeof(__DHCP_BOOTP) - sizeof(dhcp->bootp->options) + 4 + 1)
        {
            /* Packet should be OK */
            return 0;
        }
    }

    return -1;
}

__STATIC u8 __dhcpGetMsgIdFromBootp(__PDHCP_BOOTP bootp)
{
    u8* options;
    u32 len;

    options = bootp->options;
    options += 4;
    len = sizeof(bootp->options);

    while (*options != __DHCP_OPT_END && len--)
    {
        if (*(options+1) > len) return __FALSE;

        switch (*options)
        {
            /* Message type */
            case __DHCP_OPT_MSGTYPE:
                /* Check size */
                if (*(++options) != 1) return __FALSE;
                return (*(++options));
        }
    }

    return 0;
}

__STATIC __BOOL __dhcpProcessAck(__PNETIF netif, __PDHCP dhcp)
{
    u32 ip = dhcp->bootp->yiaddr;
    u32 gw;
    u32 dns;
    u32 mask;
    u8* options;
    u32 len;

    dns = gw = mask = 0;

    options = dhcp->bootp->options;
    options += 4;
    len = sizeof(dhcp->bootp->options);

    __memSet(&dhcp->lease, 0, sizeof(__DHCP_LEASE));

    while (*options != __DHCP_OPT_END && len--)
    {
        if (*(options+1) > len) return __FALSE;

        switch (*options)
        {
            /* DNS */
            case __DHCP_OPT_DNS:
                /* Check size */
                if (*(++options) != 4) return __FALSE;
                __memCpy(&dns, ++options, 4);
                options += 4;
                break;

            /* Gateway */
            case __DHCP_OPT_GATEWAY:
                /* Check size */
                if (*(++options) != 4) return __FALSE;
                __memCpy(&gw, ++options, 4);
                options += 4;
                break;

            /* Network mask */
            case __DHCP_OPT_NETMASK:
                /* Check size */
                if (*(++options) != 4) return __FALSE;
                __memCpy(&mask, ++options, 4);
                options += 4;
                break;

            case __DHCP_OPT_LEASETIME:
                /* Check size */
                if (*(++options) != 4) return __FALSE;
                __memCpy(&dhcp->lease.lease, ++options, 4);
                options += 4;

                dhcp->lease.lease = __ntohl(dhcp->lease.lease);
                break;

            case __DHCP_OPT_RENEWALTIME:
                if (*(++options) != 4) return __FALSE;
                __memCpy(&dhcp->lease.renewal, ++options, 4);
                options += 4;

                dhcp->lease.renewal = __ntohl(dhcp->lease.renewal);
                break;

            case __DHCP_OPT_REBINDTIME:
                if (*(++options) != 4) return __FALSE;
                __memCpy(&dhcp->lease.rebind, ++options, 4);
                options += 4;

                dhcp->lease.rebind = __ntohl(dhcp->lease.rebind);
                break;

            default:
                ++options;
                options += *options;
                ++options;
                break;
        }
    }

    if (dhcp->lease.lease == 0)
        dhcp->lease.lease = __DHCP_DEFAULT_LEASE_TIME;

    if (dhcp->lease.renewal == 0)
        dhcp->lease.renewal = dhcp->lease.lease / 2;

    if (dhcp->lease.rebind == 0)
        dhcp->lease.rebind = (dhcp->lease.lease - ((dhcp->lease.renewal / 2) / 2));

    dhcp->lease.curr_timer = __systemGetSecondsCount();

    netif->ip = ip;
    netif->mask = mask;
    netif->dns1 = dns;
    netif->gateway = gw;

    __routeAdd(netif, 0, 0, netif->gateway);
    __routeAdd(netif, netif->ip, netif->mask, 0);

    __dhcpCloseSocket(dhcp);
    __heapFree(dhcp->bootp);
    dhcp->bootp = __NULL;

    return __TRUE;
}

__STATIC __BOOL __dhcpProcessOffer(__PNETIF netif, __PDHCP dhcp)
{
    u32 ouraddr = __ntohl(dhcp->bootp->yiaddr);
    u32 servaddr = __ntohl(dhcp->bootp->siaddr);
    u32 len;
    i32 ret;
    u8* options;

    /* Don't get too greedy. By now just accept the first offer. */
    __memSet(dhcp->bootp, 0, sizeof(__DHCP_BOOTP));

    len = __dhcpPrepareBootp(dhcp->bootp, __DHCP_MSGTYPE_REQUEST, dhcp->xid, netif->addr.type.mac, 0, 0);

    options = dhcp->bootp->options + len;

    __dhcpAdd32bitOption(options, __DHCP_OPT_SID, servaddr, len);
    __dhcpAdd32bitOption(options, __DHCP_OPT_REQIP, ouraddr, len);

    ret = __dhcpSendBootp(dhcp->sock, 0xFFFFFFFF, dhcp->bootp, len);

    return (ret == 0) ? __TRUE : __FALSE;
}

__STATIC __BOOL __dhcpRenew(__PNETIF netif, __PDHCP dhcp, u32 serv_addr)
{
    u32 ouraddr = netif->ip;
    u32 servaddr = serv_addr;
    u32 len;
    i32 ret;

    if (!__dhcpOpenSocket(dhcp)) return __FALSE;

    if (dhcp->bootp == __NULL)
    {
        dhcp->bootp = __heapAllocZero(sizeof(__DHCP_BOOTP));
        if (!dhcp->bootp) return __FALSE;
    }

    __dhcpRenewXid(dhcp);

    len = __dhcpPrepareBootp(dhcp->bootp, __DHCP_MSGTYPE_REQUEST, dhcp->xid, netif->addr.type.mac, 0, 0);

    dhcp->bootp->ciaddr = ouraddr;

    ret = __dhcpSendBootp(dhcp->sock, servaddr, dhcp->bootp, len);

    return (ret == 0) ? __TRUE : __FALSE;
}

__STATIC __VOID __dhcpReceiveAck(__PNETIF netif, __PDHCP dhcp, u8 success_state, u8 fail_state)
{
    /* Read bootp from socket */
    if (__dhcpRecvBootp(dhcp) == 0)
    {
        /* Check for BOOTP == REPLY and same XID */
        if (dhcp->bootp->op == 2 && dhcp->bootp->xid == dhcp->xid)
        {
            /* If msg id == ACK */
            if (__dhcpGetMsgIdFromBootp(dhcp->bootp) == __DHCP_MSGTYPE_ACK)
            {
                NETMSG(__NET_DEBUG_DHCP, ("[DHCP] ACK received"));
                if (__dhcpProcessAck(netif, dhcp))
                {
                    __dhcpSetState(dhcp, success_state);
                }
            } else if (__dhcpGetMsgIdFromBootp(dhcp->bootp) == __DHCP_MSGTYPE_NAK)
            {
                NETMSG(__NET_DEBUG_DHCP, ("[DHCP] NAK received"));
                __dhcpWait(dhcp, fail_state, 1);
            }
        }
    }
}

__VOID __dhcpSm(__PNETIF netif)
{
    __PDHCP dhcp;

    if (!netif->dhcp)
    {
        /* first time here */
        netif->dhcp = (__PDHCP) __heapAllocZero(sizeof(__DHCP));
        if (!netif->dhcp) return;

        dhcp = (__PDHCP) netif->dhcp;
        __dhcpSetState(dhcp, __DHCP_STATE_INIT);
    }

    dhcp = (__PDHCP) netif->dhcp;

    switch (dhcp->state)
    {
        /*
         * Do nothing.
         */
        case __DHCP_STATE_IDLE:
            return;

        /*
         * Try to send a discover packet. If sent, jump to __DHCP_STATE_SELECTING.
         */
        case __DHCP_STATE_INIT:

            /* Send DHCP discover */
            if (__dhcpSendDiscover(netif) == 0)
            {
                __dhcpSetState(dhcp, __DHCP_STATE_SELECTING);
                dhcp->timer = __systemGetSecondsCount();
            } else {
                __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_DISCOVER_FAIL_WAIT);
            }
            break;

        /*
         * Wait for an OFFER.
         */
        case __DHCP_STATE_SELECTING:
            /* Wait for DHCPOFFER or timeout */
            if (__systemGetSecondsCount() - dhcp->timer > __DHCP_OFFER_TIMEOUT)
            {
                __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_OFFER_TIMEOUT_WAIT);
                break;
            }

            /* Read bootp from socket */
            if (__dhcpRecvBootp(dhcp) == 0)
            {
                /* Check for BOOTP == REPLY and same XID */
                if (dhcp->bootp->op == 2 && dhcp->bootp->xid == dhcp->xid)
                {
                    /* If Msg id == OFFER */
                    if (__dhcpGetMsgIdFromBootp(dhcp->bootp) == __DHCP_MSGTYPE_OFFER)
                    {
                        /* Send request */
                        if (__dhcpProcessOffer(netif, dhcp))
                        {
                            __dhcpSetState(dhcp, __DHCP_STATE_REQUESTING);
                            dhcp->timer = __systemGetSecondsCount();
                        }
                    }
                }
            }

            /*
             * If the BOOTP received has errors or it's not for us, let the timeout counter
             * throw us out of here
             */
            break;

        /*
         * Request sent. Wait for ACK, NAK or timeout.
         */
        case __DHCP_STATE_REQUESTING:
            /* Waiting for ACK or NACK */
            if (__systemGetSecondsCount() - dhcp->timer > __DHCP_ACK_TIMEOUT)
            {
                __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_ACK_TIMEOUT_WAIT);
                break;
            }

            __dhcpReceiveAck(netif, dhcp, __DHCP_STATE_BOUND, __DHCP_STATE_INIT);
            break;


        /*
         * Start reboot procedure. Try to renew the address.
         */
        case __DHCP_STATE_INIT_REBOOT:
            if (__dhcpRenew(netif, dhcp, netif->gateway))
            {
                dhcp->timer = __systemGetSecondsCount();
                __dhcpSetState(dhcp, __DHCP_STATE_REBOOTING);
            } else {
                /* Failed to send renew request, go to INIT */
                __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_ACK_TIMEOUT_WAIT);
            }
            break;

        /*
         * Request sent, wait for ACK, NAK or timeout.
         */
        case __DHCP_STATE_REBOOTING:
            /* Waiting for ACK or NACK */
            if (__systemGetSecondsCount() - dhcp->timer > __DHCP_REBOOT_ACK_TIMEOUT)
            {
                if (dhcp->retries)
                {
                    dhcp->retries--;
                    __dhcpWait(dhcp, __DHCP_STATE_INIT_REBOOT, __DHCP_ON_ACK_TIMEOUT_WAIT);
                    break;
                } else {
                    __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_ACK_TIMEOUT_WAIT);
                    break;
                }
            }

            __dhcpReceiveAck(netif, dhcp, __DHCP_STATE_BOUND, __DHCP_STATE_INIT);
            break;

        /*
         * Request accepted.
         */
        case __DHCP_STATE_BOUND:
            /* Check timer for renewal */
            if (__systemGetSecondsCount() - dhcp->lease.curr_timer > dhcp->lease.renewal)
            {
                /* Send request to the current server */
                if (__dhcpRenew(netif, dhcp, netif->gateway))
                {
                    dhcp->timer = __systemGetSecondsCount();
                    __dhcpSetState(dhcp, __DHCP_STATE_RENEWING);
                }
            }
            break;

        /*
         * Start the renew procedure. The request was already sent from the BOUND state.
         * Here wait for the server ACK and check for the rebind timer to timeout. If so,
         * broadcast a request to any DHCP server and then transit to the REBINDING state.
         */
        case __DHCP_STATE_RENEWING:
            /* T1 elapsed */
            if (__systemGetSecondsCount() - dhcp->lease.curr_timer > dhcp->lease.rebind)
            {
                /* No response, broadcast request and go to rebinding */
                if (__dhcpRenew(netif, dhcp, 0xFFFFFFFF))
                {
                    dhcp->timer = __systemGetSecondsCount();
                    __dhcpSetState(dhcp, __DHCP_STATE_REBINDING);
                    break;
                } else {
                    /* Failed to send renew request, go to INIT */
                    __dhcpWait(dhcp, __DHCP_STATE_INIT, __DHCP_ON_ACK_TIMEOUT_WAIT);
                    break;
                }
            }

            /* Wait for ACK or NACK, or timeout */
            if (__systemGetSecondsCount() - dhcp->timer > __DHCP_ACK_TIMEOUT)
            {
                __dhcpRenew(netif, dhcp, netif->gateway);
                dhcp->timer = __systemGetSecondsCount();
            }

            __dhcpReceiveAck(netif, dhcp, __DHCP_STATE_BOUND, __DHCP_STATE_INIT);
            break;

        /*
         * Wait for an ACK from a DHCP server, while sending periodic requests.
         * If the lease expires, go to the INIT state.
         */
        case __DHCP_STATE_REBINDING:
            /* No server is answering our requests, check for lease expiration */
            if (__systemGetSecondsCount() - dhcp->lease.curr_timer > dhcp->lease.lease)
            {
                /* Go to INIT */
                __dhcpSetState(dhcp, __DHCP_STATE_INIT);
                break;
            }

            if (__systemGetSecondsCount() - dhcp->timer > __DHCP_ACK_TIMEOUT)
            {
                __dhcpRenew(netif, dhcp, 0xFFFFFFFF);
                dhcp->timer = __systemGetSecondsCount();
            }

            __dhcpReceiveAck(netif, dhcp, __DHCP_STATE_BOUND, __DHCP_STATE_INIT);
            break;

        case __DHCP_STATE_WAIT:
            if (__systemGetSecondsCount() - dhcp->timer >= dhcp->wait)
            {
                __dhcpSetState(dhcp, dhcp->next_state);
            }
            break;
    }
}

__VOID __dhcpInitReboot(__PNETIF netif)
{
    __PDHCP dhcp = netif->dhcp;

    /* Check if we had a valid address from DHCP */
    if (netif->ip && netif->gateway && netif->mask)
    {
        /* jump to init reboot */
        if (dhcp)
        {
            dhcp->retries = 5;
            __dhcpSetState(dhcp, __DHCP_STATE_INIT_REBOOT);
        }
    }
}

#endif /* __CONFIG_COMPILE_NET */