dhcpc.c

Go to the documentation of this file.

/*
 * Copyright (C) 2001-2005 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 * -
 * Portions Copyright (c) 1983, 1993 by
 *  The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * -
 * Portions Copyright (c) 1993 by Digital Equipment Corporation.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies, and that
 * the name of Digital Equipment Corporation not be used in advertising or
 * publicity pertaining to distribution of the document or software without
 * specific, written prior permission.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

#include <cfg/os.h>
#include <sys/thread.h>
#include <sys/event.h>
#include <sys/timer.h>
#include <sys/confnet.h>
#include <sys/confos.h>

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <memdebug.h>

#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <net/route.h>
#include <sys/socket.h>
#include <pro/dhcp.h>

#ifdef NUTDEBUG
#include <net/netdebug.h>
#endif

#if 0
/* Use for local debugging. */
#define NUTDEBUG
#include <stdio.h>
#define __tcp_trs stdout
static uint_fast8_t __tcp_trf = 1;
#endif



#ifndef DHCP_SERVERPORT
#define DHCP_SERVERPORT      67
#endif

#ifndef DHCP_CLIENTPORT
#define DHCP_CLIENTPORT      68
#endif

#ifndef MAX_DHCP_MSGSIZE
#define MAX_DHCP_MSGSIZE    576
#endif

#ifndef MIN_DHCP_MSGSIZE
#define MIN_DHCP_MSGSIZE    300
#endif

#ifndef MAX_DHCP_BUFSIZE
#define MAX_DHCP_BUFSIZE    1728
#endif

#ifndef MIN_DHCP_WAIT
#define MIN_DHCP_WAIT       4000
#endif

#ifndef MAX_DHCP_WAIT
#define MAX_DHCP_WAIT       64000
#endif

#ifndef MAX_DCHP_RETRIES
#define MAX_DCHP_RETRIES    3
#endif

#ifndef MAX_DCHP_RELEASE_RETRIES
#define MAX_DCHP_RELEASE_RETRIES    0
#endif

#ifndef DHCP_DEFAULT_LEASE
#define DHCP_DEFAULT_LEASE  43200
#endif

#ifndef MAX_DHCP_NAPTIME
#define MAX_DHCP_NAPTIME    4294967
#endif

#ifndef NUT_THREAD_DHCPSTACK
#if defined(__AVR__)
#if defined(__GNUC__)
/* avr-gcc size optimized code used 192 bytes. */
#define NUT_THREAD_DHCPSTACK    288
#else
/* icc-avr v7.19 used 360 bytes. */
#define NUT_THREAD_DHCPSTACK    512
#endif
#else
/* arm-elf-gcc used 276 bytes with size optimized, 680 bytes with debug code. */
/* arm-none-eabi creates stack overflow with 384 bytes on EIR 1.0 board. */
#define NUT_THREAD_DHCPSTACK    512
#endif
#endif


#define DHCP_DISCOVER   1

#define DHCP_OFFER      2

#define DHCP_REQUEST    3

#define DHCP_DECLINE    4

#define DHCP_ACK        5

#define DHCP_NAK        6

#define DHCP_RELEASE    7

#define DHCP_INFORM     8


#define DHCPOPT_PAD          0

#define DHCPOPT_NETMASK      1

#define DHCPOPT_GATEWAY      3

#define DHCPOPT_DNS          6

#define DHCPOPT_HOSTNAME     12

#define DHCPOPT_DOMAIN       15

#define DHCPOPT_BROADCAST    28

#define DHCPOPT_REQESTIP     50

#define DHCPOPT_LEASETIME    51

#define DHCPOPT_MSGTYPE      53

#define DHCPOPT_SID          54

#define DHCPOPT_PARAMREQUEST 55

#define DHCPOPT_MAXMSGSIZE   57

#define DHCPOPT_RENEWALTIME  58

#define DHCPOPT_REBINDTIME   59

#define DHCPOPT_END          255

typedef struct bootp BOOTP;

struct __attribute__ ((packed)) bootp {
    uint8_t bp_op;              
    uint8_t bp_htype;           
    uint8_t bp_hlen;            
    uint8_t bp_hops;            
    uint32_t bp_xid;              
    uint16_t bp_secs;            
    uint16_t bp_flags;           
    uint32_t bp_ciaddr;           
    uint32_t bp_yiaddr;           
    uint32_t bp_siaddr;           
    uint32_t bp_giaddr;           
    uint8_t bp_chaddr[16];      
    char bp_sname[64];          
    char bp_file[128];          
    uint8_t bp_options[312];    
};

typedef struct dyn_cfg DYNCFG;

struct dyn_cfg {
    uint8_t dyn_msgtyp;         
    uint32_t dyn_yiaddr;          
    uint32_t dyn_netmask;         
    uint32_t dyn_broadcast;       
    uint32_t dyn_gateway;         
    uint32_t dyn_pdns;            
    uint32_t dyn_sdns;            
    uint32_t dyn_sid;             
    uint32_t dyn_renewalTime;     
    uint32_t dyn_rebindTime;      
    uint32_t dyn_leaseTime;       
    uint8_t *dyn_hostname;      
    uint8_t *dyn_domain;        
};

static DYNCFG *dhcpConfig;

static HANDLE dhcpThread;

static uint8_t dhcpState;

static int dhcpError;

static HANDLE dhcpWake;

static HANDLE dhcpDone;

static uint32_t dhcpApiTimeout;

static uint32_t dhcpApiStart;

#ifdef __arm__
static NUTDEVICE *dhcpDev;
#endif

static void copy_str(uint8_t ** dst, void *src, int len)
{
    if (*dst) {
        free(*dst);
    }
    if ((*dst = malloc(len + 1)) != 0) {
        if (len) {
            memcpy(*dst, src, len);
        }
        *(*dst + len) = 0;
    }
}

static void ReleaseDynCfg(DYNCFG * dyncfg)
{
    if (dyncfg) {
        if (dyncfg->dyn_hostname) {
            free(dyncfg->dyn_hostname);
        }
        if (dyncfg->dyn_domain) {
            free(dyncfg->dyn_domain);
        }
        free(dyncfg);
    }
}

static DYNCFG *ParseReply(BOOTP *bp, int len)
{
    uint8_t *op;
    int left;
    DYNCFG *cfgp;

    /* Allocate and initialize a new structure. */
    if ((cfgp = malloc(sizeof(DYNCFG))) == 0) {
        return 0;
    }
    memset(cfgp, 0, sizeof(DYNCFG));
    cfgp->dyn_leaseTime = DHCP_DEFAULT_LEASE;

    /* Set the assigned IP address. */
    memcpy(&cfgp->dyn_yiaddr, &bp->bp_yiaddr, 4);

    /*
     * Parse options until an end option is found or until we reached
     * the end of the message.
     */
    op = bp->bp_options + 4;
    left = len - (sizeof(*bp) - sizeof(bp->bp_options)) - 4;
    while (*op != DHCPOPT_END && left > 0) {
        uint8_t ol;

#ifdef NUTDEBUG
        if (__tcp_trf) {
            fprintf(__tcp_trs, "[DHCP-Opt-%u]", *op);
        }
#endif
        /* Pad option is used for boundary alignment. */
        if (*op == DHCPOPT_PAD) {
            op++;
            left--;
            continue;
        }

        /* Reject if option length exceeds total length. */
        if ((ol = *(op + 1)) > left) {
            break;
        }

        /* Type of this message. */
        if (*op == DHCPOPT_MSGTYPE) {
            if (ol != 1) {
                break;
            }
            cfgp->dyn_msgtyp = *(op + 2);

#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) {
                switch(cfgp->dyn_msgtyp) {
                    case DHCP_OFFER:
                        fprintf(__tcp_trs, "+MSGT-OFFER+\n");
                        break;
                    case DHCP_ACK:
                        fprintf(__tcp_trs, "+MSGT-ACK+\n");
                        break;
                    case DHCP_NAK:
                        fprintf(__tcp_trs, "-MSGT-NAK-\n");
                        break;
                    default:
                        fprintf(__tcp_trs, "#MSGT-UNK#\n");
                        break;
                }
            }
#endif
        }
        /* Our host name. May or may not include the domain. */
        else if (*op == DHCPOPT_HOSTNAME) {
            copy_str(&cfgp->dyn_hostname, op + 2, ol);
        }
        /* Name of the domain we are in. */
        else if (*op == DHCPOPT_DOMAIN) {
            copy_str(&cfgp->dyn_domain, op + 2, ol);
        }

        /* All remaining options require at least 4 octets. */
        else if (ol >= 4) {
            /* Preset most often used long value. */
            uint32_t lval = *(op + 2);
            lval += (uint32_t)(*(op + 3)) << 8;
            lval += (uint32_t)(*(op + 4)) << 16;
            lval += (uint32_t)(*(op + 5)) << 24;

            /* Our IP network mask. */
            if (*op == DHCPOPT_NETMASK) {
                cfgp->dyn_netmask = lval;
            }
            /* Our IP broadcast address. */
            else if (*op == DHCPOPT_BROADCAST) {
                cfgp->dyn_broadcast = lval;
            }
            /* Our IP default gate. More than one gateway may be
               specified. We take the fist one only and ignore the
               rest. */
            else if (*op == DHCPOPT_GATEWAY) {
                cfgp->dyn_gateway = lval;
            }
            /* Our DNS server. Updated by Jelle Martijn Kok to
               support a secondary DNS. */
            else if (*op == DHCPOPT_DNS) {
                cfgp->dyn_pdns = lval;
                if (ol >= 8) {
                    cfgp->dyn_sdns = *(op + 6);
                    cfgp->dyn_sdns += (uint32_t)(*(op + 7)) << 8;
                    cfgp->dyn_sdns += (uint32_t)(*(op + 8)) << 16;
                    cfgp->dyn_sdns += (uint32_t)(*(op + 9)) << 24;
                }
            }
            /* Server identifier. */
            else if (*op == DHCPOPT_SID) {
                cfgp->dyn_sid = lval;
            }
            /* Renewal time. */
            else if (*op == DHCPOPT_RENEWALTIME) {
                cfgp->dyn_renewalTime = ntohl(lval);
            }
            /* Rebinding time. */
            else if (*op == DHCPOPT_REBINDTIME) {
                cfgp->dyn_rebindTime = ntohl(lval);
            }
            /* Total lease time granted. */
            else if (*op == DHCPOPT_LEASETIME) {
                cfgp->dyn_leaseTime = ntohl(lval);
            }
        }
        op += ol + 2;
        left -= ol + 2;
    }

    /*
     * Discard this configuration if parsing stopped before reaching
     * the end option or if we didn't receive an expected message type.
     */
    if (*op != DHCPOPT_END ||
        (cfgp->dyn_msgtyp != DHCP_OFFER &&
         cfgp->dyn_msgtyp != DHCP_ACK &&
         cfgp->dyn_msgtyp != DHCP_NAK)) {
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) {
            fprintf(__tcp_trs, "[DHCP-Parse Error]");
        }
#endif
        ReleaseDynCfg(cfgp);
        return 0;
    }

    /* Calculate renewal and rebind times. */
    if (cfgp->dyn_renewalTime == 0) {
        cfgp->dyn_renewalTime = cfgp->dyn_leaseTime / 2;
    }
    if (cfgp->dyn_rebindTime == 0) {
        cfgp->dyn_rebindTime = cfgp->dyn_renewalTime +  /* */
            cfgp->dyn_renewalTime / 2 + /* */
            cfgp->dyn_renewalTime / 4;
    }
    return cfgp;
}

static size_t DhcpAddOption(uint8_t * op, uint8_t ot, void *ov, uint8_t len)
{
    *op++ = ot;
    *op++ = len;
    memcpy(op, ov, len);

    return 2 + len;
}

static size_t DhcpAddByteOption(uint8_t * op, uint8_t ot, uint8_t ov)
{
    *op++ = ot;
    *op++ = 1;
    *op++ = ov;

    return 3;
}

static size_t DhcpAddShortOption(uint8_t * op, uint8_t ot, uint16_t ov)
{
    *op++ = ot;
    *op++ = 2;
    ov = htons(ov);
    memcpy(op, &ov, 2);

    return 4;
}

static size_t DhcpAddParmReqOption(uint8_t * op)
{
    *op++ = DHCPOPT_PARAMREQUEST;
    *op++ = 3;                  /* Adjust when adding more options! */
    *op++ = DHCPOPT_NETMASK;    /* Typically sent by default, but play safe. */
    *op++ = DHCPOPT_GATEWAY;    /* We want a default gateway. */
    *op++ = DHCPOPT_DNS;        /* We want the DNS' IP. */
    return 5;                   /* Adjust when adding more options! */
}

static unsigned int DhcpPrepHeader(BOOTP *bp, uint8_t msgtyp, uint32_t xid, uint32_t ciaddr, uint16_t secs)
{
    uint8_t *op;

    memset(bp, 0, sizeof(*bp));
    /* Clients send bootp requests (op code 1) only. */
    bp->bp_op = 1;
    /* Ethernet addresses are type 1 with 6 octets. */
    bp->bp_htype = 1;
    bp->bp_hlen = 6;
    memcpy(bp->bp_chaddr, confnet.cdn_mac, 6);
    /* Transaction identifier. */
    bp->bp_xid = xid;
    /* Seconds elapsed since address acquisition. */
    bp->bp_secs = htons(secs);

#ifdef DHCP_BROADCAST_FLAG
    /*
     * We do not need the broadcast flag, because our stack accepts IP
     * messages to any destination if no local address has been assigned,
     * However, we continue supporting this compile time option.
     */
    bp->bp_flags = htons(0x8000);
#endif

    bp->bp_ciaddr = ciaddr;

    /* Add the DHCP magic cookie according to RFC 1497. */
    op = bp->bp_options;
    *op++ = 0x63;
    *op++ = 0x82;
    *op++ = 0x53;
    *op++ = 0x63;

    /* Add the DHCP message type option. */
    return DhcpAddByteOption(op, DHCPOPT_MSGTYPE, msgtyp) + 4;
}

static int DhcpSendMessage(UDPSOCKET * sock, uint32_t addr, BOOTP *bp, size_t len)
{
    /* Add 'end of options'. */
    bp->bp_options[len++] = DHCPOPT_END;

    /* Maintain a BOOTP compatible minimum packet size of 300 octets.
       Thanks to Tomohiro Haraikawa. */
    if ((len += sizeof(BOOTP) - sizeof(bp->bp_options)) < MIN_DHCP_MSGSIZE) {
        len = MIN_DHCP_MSGSIZE;
    }
#ifdef NUTDEBUG
    if (__tcp_trf & NET_DBG_DHCP) {
        fprintf(__tcp_trs, "[DHCP-Send to %s]", inet_ntoa(addr));
    }
#endif
    if (NutUdpSendTo(sock, addr, DHCP_SERVERPORT, bp, len) < 0) {
        dhcpError = DHCPERR_TRANSMIT;
        return -1;
    }
    return 0;
}

static int DhcpRecvMessage(UDPSOCKET * sock, uint32_t xid, BOOTP *bp, uint32_t tmo)
{
    int rc;
    uint16_t port;
    uint32_t addr;
    uint32_t etim;
    uint32_t wtim;

    /* Set our start time. */
    etim = NutGetMillis();
    /* Set the initial receive timeout. */
    wtim = tmo;
    for (;;) {
        rc = NutUdpReceiveFrom(sock, &addr, &port, bp, sizeof(BOOTP), wtim);
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) {
            if (rc > 0) {
                fprintf(__tcp_trs, "[DHCP-Recv from %s]", inet_ntoa(addr));
            } else if (rc < 0) {
                fprintf(__tcp_trs, "[DHCP-Recv Error]");
            } else {
                fprintf(__tcp_trs, "[DHCP-Recv Timeout %lu]", tmo);
            }
        }
#endif
        /* Immediately return on receive errors and timeouts. */
        if (rc <= 0) {
            if (rc < 0) {
                dhcpError = DHCPERR_RECEIVE;
            }
            break;
        }
        /* The message must at least include the BOOTP header plus five
           bytes of options (magic and end). We are quite liberal here. */
        if (rc > sizeof(BOOTP) - sizeof(bp->bp_options) + 5) {
            /* The message must be a BOOTP reply with the expected XID. */
            if (bp->bp_op == 2 && bp->bp_xid == xid) {
                /* Message is acceptable. */
                break;
            }
        }
        /* Calculate the remaining timeout for not getting trapped here
           on a busy network, which regularly broadcasts DHCP messages. */
        wtim = NutGetMillis() - etim;
        if (wtim >= tmo - 250) {
            /* Less than 250 ms left, return timeout. */
            rc = 0;
            break;
        }
        wtim = tmo - wtim;
    }
    return rc;
}

static int DhcpBroadcastDiscover(UDPSOCKET * sock, BOOTP *bp, uint32_t xid, uint32_t raddr, uint16_t secs)
{
    size_t optlen;
    int len;
    uint8_t *op = bp->bp_options;

    optlen = DhcpPrepHeader(bp, DHCP_DISCOVER, xid, 0, secs);

    /* Request a specific IP if one had been assigned previously. */
    if (raddr) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_REQESTIP, &raddr, sizeof(raddr));
    }

    optlen += DhcpAddParmReqOption(op + optlen);

    /* Pass host name if specified in confos structure.
     * Win2k DHCP server can register this as dynamic DNS entry.
     * Also viewing DHCP lease table shows something sensible.
     */
    len = strlen(confos.hostname);
    if (len > 0) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_HOSTNAME, confos.hostname, len);
    }

    /* Request a maximum message size. */
    optlen += DhcpAddShortOption(op + optlen, DHCPOPT_MAXMSGSIZE, MAX_DHCP_MSGSIZE);

    return DhcpSendMessage(sock, INADDR_BROADCAST, bp, optlen);
}


static int DhcpSendRequest(UDPSOCKET * sock, uint32_t daddr, BOOTP *bp, uint32_t xid,        /* */
                           uint32_t caddr, uint32_t raddr, uint32_t sid, uint16_t secs)
{
    size_t optlen;
    int len;
    uint8_t *op = bp->bp_options;

    /* Initialize the BOOTP header. */
    optlen = DhcpPrepHeader(bp, DHCP_REQUEST, xid, caddr, secs);

    /* Add specified options. */
    if (raddr) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_REQESTIP, &raddr, sizeof(raddr));
    }
    if (sid) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_SID, &sid, sizeof(sid));
    }
    optlen += DhcpAddParmReqOption(op + optlen);

    /* Pass host name if specified in confos structure.  */
    /* viewing DHCP lease table shows something sensible. */
    len = strlen(confos.hostname);
    if (len > 0) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_HOSTNAME, confos.hostname, len);
    }

    return DhcpSendMessage(sock, daddr, bp, optlen);
}

static int DhcpBroadcastRequest(UDPSOCKET * sock, BOOTP *bp, uint32_t xid, /* */
                                uint32_t caddr, uint32_t raddr, uint32_t sid, uint16_t secs)
{
    return DhcpSendRequest(sock, INADDR_BROADCAST, bp, xid, caddr, raddr, sid, secs);
}

static int DhcpSendRelease(UDPSOCKET * sock, uint32_t daddr, BOOTP *bp, uint32_t xid, uint32_t caddr, uint32_t sid)
{
    size_t optlen;
    uint8_t *op = bp->bp_options;

    /* Prepare BOOTP header. 'secs' is set to zero. */
    optlen = DhcpPrepHeader(bp, DHCP_RELEASE, xid, caddr, 0);

    /* Optionally add server identifier. */
    if (sid) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_SID, &sid, sizeof(sid));
    }
    return DhcpSendMessage(sock, daddr, bp, optlen);
}

static int DhcpSendInform(UDPSOCKET * sock, uint32_t daddr, BOOTP *bp, uint32_t xid, uint32_t caddr)
{
    size_t optlen;
    size_t len;
    uint8_t *op = bp->bp_options;

    /* Prepare BOOTP header. 'secs' is set to zero. */
    optlen = DhcpPrepHeader(bp, DHCP_INFORM, xid, caddr, 0);

    /* Additional options we want. */
    optlen += DhcpAddParmReqOption(op + optlen);

    /* Add our configured host name. */
    len = strlen(confos.hostname);
    if (len > 0) {
        optlen += DhcpAddOption(op + optlen, DHCPOPT_HOSTNAME, confos.hostname, len);
    }

    /* We should provide the maximum message size. */
    optlen += DhcpAddShortOption(op + optlen, DHCPOPT_MAXMSGSIZE, MAX_DHCP_MSGSIZE);

    return DhcpSendMessage(sock, daddr, bp, optlen);
}


static DYNCFG *CheckOffer(DYNCFG * dyncfg, BOOTP *bp, size_t len)
{
    DYNCFG *offer;

#ifdef NUTDEBUG
    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "\n[chkoffer %s ", inet_ntoa( dyncfg->dyn_yiaddr));
#endif

    /* Parse the new offer. If it's invalid, return the current
       configuration. */
    if ((offer = ParseReply(bp, len)) == 0) {
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "TAKE: %s]", inet_ntoa( offer->dyn_yiaddr));
#endif
        return dyncfg;
    }

    /* Discard anything which is not an offer. */
    if (offer->dyn_msgtyp != DHCP_OFFER) {
        ReleaseDynCfg(offer);
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "NO-OFFER]");
#endif
        return dyncfg;
    }

    /* First offer, take it. */
    if (dyncfg == 0) {
        dyncfg = offer;
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "FIRST: %s]", inet_ntoa(offer->dyn_yiaddr));
#endif
    }

    /*
     * Check if the new offer is better than the current configuration:
     */
    else {
        /* If we remember a previously allocated IP which isn't in the
           current configuration but in the new offer, then let's take
           the new one. */
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "PREV ");
#endif
        if (confnet.cdn_ip_addr & confnet.cdn_ip_mask) {
            if (dyncfg->dyn_yiaddr != confnet.cdn_ip_addr &&    /* */
                offer->dyn_yiaddr == confnet.cdn_ip_addr) {
                ReleaseDynCfg(dyncfg);
                dyncfg = offer;
#ifdef NUTDEBUG
                if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "OLD: %s]", inet_ntoa( dyncfg->dyn_yiaddr));
#endif
            }
        }
        /* In the second place prefer long lease times. */
        else if (offer->dyn_leaseTime > dyncfg->dyn_leaseTime) {
            ReleaseDynCfg(dyncfg);
            dyncfg = offer;
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "LONG: %s]", inet_ntoa( dyncfg->dyn_yiaddr));
#endif
        }
        /* The new one deosn't offer anything interesting. Discard it. */
        else {
            ReleaseDynCfg(offer);
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "DSIC]");
#endif
        }
    }
    return dyncfg;
}

#ifdef NUTDEBUG
void DhcpStateDebug( uint_fast8_t n, uint_fast8_t s, int li, int lt, ureg_t retries)
{
    if (__tcp_trf & NET_DBG_DHCP) {
        if( n)
            fprintf(__tcp_trs, "\n[%u.DHCP-", retries + 1);
        else
            fprintf(__tcp_trs, "\n->[%u.DHCP-", retries + 1);

        switch (dhcpState) {
        case DHCPST_INIT:
            fprintf(__tcp_trs, "INIT]");
            break;
        case DHCPST_SELECTING:
            fprintf(__tcp_trs, "SELECTING]");
            break;
        case DHCPST_REQUESTING:
            fprintf(__tcp_trs, "REQUESTING]");
            break;
        case DHCPST_REBOOTING:
            fprintf(__tcp_trs, "REBOOTING %s]", inet_ntoa(li));
            break;
        case DHCPST_BOUND:
            fprintf(__tcp_trs, "BOUND %lu]", NutGetSeconds() - lt);
            break;
        case DHCPST_RENEWING:
            fprintf(__tcp_trs, "RENEWING %lu]", NutGetSeconds() - lt);
            break;
        case DHCPST_REBINDING:
            fprintf(__tcp_trs, "REBINDING %lu]", NutGetSeconds() - lt);
            break;
        case DHCPST_INFORMING:
            fprintf(__tcp_trs, "INFORMING]");
            break;
        case DHCPST_RELEASING:
            fprintf(__tcp_trs, "RELEASING]");
            break;
        case DHCPST_IDLE:
            if (dhcpError) {
                fprintf(__tcp_trs, "ERROR %u]", dhcpError);
            } else {
                fprintf(__tcp_trs, "IDLE]");
            }
            break;
        default:
            fprintf(__tcp_trs, "UNKNOWN %u]", dhcpState);
            break;
        }
    }
}
#endif

THREAD(NutDhcpClient, arg)
{
    DYNCFG *reply = 0;
    UDPSOCKET *sock = 0;
    BOOTP *bp = 0;
    int n;
    uint32_t xid;
    IFNET *nif;
    uint16_t secs = 0;
    uint32_t aqsTime = NutGetSeconds();
    uint32_t leaseTime = 0;
    uint32_t napTime;
    ureg_t retries;
    uint32_t tmo = MIN_DHCP_WAIT;
    uint32_t last_ip = confnet.cdn_ip_addr;
    uint32_t server_ip;

    /*
     * Hack alert: Our ARM port doesn't allow parameter
     * passing to threads.
     */
#ifdef __arm__
    nif = dhcpDev->dev_icb;
#else
    nif = ((NUTDEVICE *) arg)->dev_icb;
#endif

    /*
     * Generate a random transaction identifier based on our MAC
     * address with the least significant byte of the MAC address
     * becoming the most significant byte of the identifier. This
     * should give a sufficient unique value when several Ethernuts
     * are started concurrently.
     */
    xid = 0;
    for (retries = 0; retries < sizeof(xid); retries++) {
        xid <<= 8;
        xid += nif->if_mac[5 - retries];
    }
    retries = 0;

    for (;;) {

#ifdef NUTDEBUG
        DhcpStateDebug( 0, dhcpState, last_ip, leaseTime, retries);
#endif

        /*
         * Setup some values based on the number of retry attempts.
         */
        server_ip = INADDR_BROADCAST;   /* Broadcasting is default. */
        if (retries) {
            /* Double our timeout on each retry. */
            tmo += tmo;
            if (tmo > MAX_DHCP_WAIT) {
                tmo = MAX_DHCP_WAIT;
            }
        } else {
            /* Start with minimum timeout first. */
            tmo = MIN_DHCP_WAIT;
            /* Use a new xid for the first message in each state except
             * when requesting, where we should continue using the xid
             * from the offer message we received.
             */
            if (dhcpState != DHCPST_REQUESTING) {
                xid++;
            }

            /* If we know the server's IP, try to unicast on the first
               attempt. */
            if (dhcpConfig && dhcpConfig->dyn_sid) {
                server_ip = dhcpConfig->dyn_sid;
            }
        }

        /*
         * Keep track of the API timeout.
         */
        if (dhcpState != DHCPST_IDLE && dhcpApiTimeout != NUT_WAIT_INFINITE) {
            uint32_t tt = NutGetMillis() - dhcpApiStart;

            if (dhcpApiTimeout <= tt) {
                dhcpError = DHCPERR_TIMEOUT;
                dhcpState = DHCPST_IDLE;
                continue;
            }
            if ((tt = dhcpApiTimeout - tt) < tmo) {
                tmo = tt;
            }
        }

        /*
         * Keep track of acquisition time.
         */
        if ((dhcpState == DHCPST_SELECTING) || (dhcpState == DHCPST_RENEWING) || (dhcpState == DHCPST_REBINDING)) {
            /* For retries make sure that secs doesn't overflow. */
            if (retries) {
                if (NutGetSeconds() - aqsTime > 0xffffUL) {
                    secs = 0xffff;
                } else {
                    secs = (uint16_t) (NutGetSeconds() - aqsTime);
                }
            }
            /* For first transmissions make sure that secs is zero. */
            else {
                aqsTime = NutGetSeconds();
                secs = 0;
            }
        }

        /*
         * Release UDP socket and buffer in states with long inactive time.
         */
        if ((dhcpState == DHCPST_BOUND) || (dhcpState == DHCPST_IDLE)) {
            if (sock) {
                NutUdpDestroySocket(sock);
                sock = 0;
            }
            if (bp) {
                free(bp);
                bp = 0;
            }
        }

        /*
         * In all other states we need the socket and the buffer.
         */
        else {
            /*
             * Check if something else configured our interface.
             */
            if (dhcpConfig == 0 && nif->if_local_ip) {
                /* If we need additional configuration, we can sent
                   a DHCP Inform message here. */
                dhcpState = DHCPST_IDLE;
                continue;
            }

            if ((sock == 0) || (bp == 0)) {
                if (sock == 0) {
                    sock = NutUdpCreateSocket(DHCP_CLIENTPORT);
                }
                if (bp == 0) {
                    bp = malloc(sizeof(BOOTP));
                }
                if ((sock == 0) || (bp == 0)) {
                    /* Looks like we are out of memory. */
                    dhcpError = DHCPERR_SYSTEM;
                    dhcpState = DHCPST_IDLE;
                    /* At this point either socket or buffer may be allocated.
                       Thus we need to jump back to the top of our state loop
                       to release it. */
                    continue;
                }
#if MAX_DHCP_BUFSIZE
                {
                    uint16_t max_ms = MAX_DHCP_BUFSIZE;
                    NutUdpSetSockOpt(sock, SO_RCVBUF, &max_ms, sizeof(max_ms));
                }
#endif
            }
        }

        /*
         * (Re)Start.
         */
        if (dhcpState == DHCPST_INIT) {
            /* Clear the retry counter. */
            retries = 0;
            /* Use a new XID on each attempt. */
            xid++;
            /* Determine whether this is an initial boot or a reboot. */
            if ((last_ip & confnet.cdn_ip_mask) == 0) {
                /* No previous IP, start from ground up. */
                dhcpState = DHCPST_SELECTING;
            } else {
                /* We got a previously allocated IP configuration from
                 * non-volatile configuration memory. Try to re-use it. */
                dhcpState = DHCPST_REBOOTING;
            }
        }

#ifdef NUTDEBUG
//        DhcpStateDebug( 1, dhcpState, last_ip, leaseTime, retries);
#endif
        /*
         * Broadcast discover and collect incoming offers.
         */
        else if (dhcpState == DHCPST_SELECTING) {
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[SEL: TICK %p]", dhcpConfig);
#endif

            if (retries++ > MAX_DCHP_RETRIES) {
                if( dhcpConfig) {
                    /* Ulrich says: we got at least one valid offer from a DHCP server */
                    reply = 0;
                    leaseTime = aqsTime;
                    dhcpState = DHCPST_BOUND;
                }
                else {
                    /* Too many retries while discovering DHCP. Give up. */
                    dhcpError = DHCPERR_TIMEOUT;
                    dhcpState = DHCPST_IDLE;
                }
            }
            /* Send the discovering broadcast. */
            else if (DhcpBroadcastDiscover(sock, bp, xid, last_ip, secs) < 0) {
                /* Fatal transmit error on broadcast. */
#ifdef NUTDEBUG
                if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[SEL-TXERR]");
#endif
                dhcpState = DHCPST_IDLE;
            } else {
                /* Collect incoming offers. */
                while ((n = DhcpRecvMessage(sock, xid, bp, tmo)) > 0) {
                    /* Check if this is a valid offer. */
                    if ((dhcpConfig = CheckOffer(dhcpConfig, bp, n)) != 0) {
#ifdef NUTDEBUG
                        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[SEL-OFFER n=%d]", n);
#endif
                        /* If the callers timeout is low, do not collect
                           more than one. Thanks to Jelle Kok. */
                        if (dhcpApiTimeout < MIN_DHCP_WAIT * 3) {
#ifdef NUTDEBUG
                            if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[NOTL]");
#endif
                            break;
                        }
                        /* Switch to lowest timeout after we received
                           a first response. */
                        tmo = MIN_DHCP_WAIT;
                    }
                }
                /* Change to ERROR state on fatal receive errors. */
                if (n < 0) {
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[SEL-FATERR]");
#endif
                    dhcpState = DHCPST_IDLE;
                }
                /* Change to REQUESTING state if we got a valid offer.
                   Otherwise we stay in SELECTING state. */
                else if (dhcpConfig) {
                    /* Wait for at least one period for other DHCP servers to offer */
                    retries = MAX_DCHP_RETRIES+1;
//                    dhcpState = DHCPST_REQUESTING;
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[SEL-WAIT]");
#endif
                }
            }
        }

        /*
         * Send request and wait for an acknowledge.
         */
        else if (dhcpState == DHCPST_REQUESTING) {
            if (retries++ > MAX_DCHP_RETRIES) {
                /* Too many retries with this server, fall back to discovery. */
                dhcpState = DHCPST_INIT;
            }
            /* Request an offered configuration. According to RFC 2131 this
               has to be broadcasted. */
            else if (DhcpBroadcastRequest(sock, bp, xid, 0, dhcpConfig->dyn_yiaddr, dhcpConfig->dyn_sid, secs) < 0) {
                /* Fatal transmit error on broadcast. Give up. */
                dhcpState = DHCPST_IDLE;
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) < 0) {
                /* Fatal receive error. */
                dhcpState = DHCPST_IDLE;
            } else if (n > 0 && (reply = ParseReply(bp, n)) != 0) {
                /* The server accepted our request. We are bound. */
                if (reply->dyn_msgtyp == DHCP_ACK) {
                    ReleaseDynCfg(dhcpConfig);
                    dhcpConfig = reply;
                    reply = 0;
                    leaseTime = aqsTime;
                    dhcpState = DHCPST_BOUND;
                }
                /* The server declines a previously offered configuration.
                   Restart discovery. */
                else if (reply->dyn_msgtyp == DHCP_NAK) {
#ifdef NUTDEBUG
        if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[DHCP-NAK1]");
#endif
                    dhcpState = DHCPST_INIT;
                }
            }
        }

        /*
         * Reusing a previously allocated network address after reboot.
         */
        else if (dhcpState == DHCPST_REBOOTING) {
            if (++retries > MAX_DCHP_RETRIES) {
                /* Too many retries, fall back to discovery. */
                last_ip = 0;
                dhcpState = DHCPST_INIT;
            }
            /* Broadcast a request for our previous configuration. */
            else if (DhcpBroadcastRequest(sock, bp, xid, 0, last_ip, 0, secs) < 0) {
                /* Fatal transmit error on broadcast. Give up. */
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[BC-FATAL]");
#endif
                dhcpState = DHCPST_IDLE;
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) < 0) {
                /* Fatal receive error. */
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[RCV-FATAL]");
#endif
                dhcpState = DHCPST_IDLE;
            } else if (n > 0 && (reply = ParseReply(bp, n)) != 0) {
                if (reply->dyn_msgtyp == DHCP_ACK) {
                    ReleaseDynCfg(dhcpConfig);
                    dhcpConfig = reply;
                    reply = 0;
                    leaseTime = aqsTime;
                    dhcpState = DHCPST_BOUND;
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[OK]");
#endif
                } else if (reply->dyn_msgtyp == DHCP_NAK) {
                    /* Either our previous address had been allocated by
                       someone else or we changed the network. Remove the
                       previous address and restart. */
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[DHCP-NAK2]");
#endif
                    last_ip = 0;
                    dhcpState = DHCPST_INIT;
                }
            }
        }

        /*
         * Maintain lease time.
         */
        else if (dhcpState == DHCPST_BOUND) {
            retries = 0;
            NutEventBroadcast(&dhcpDone);
            if (dhcpConfig->dyn_renewalTime <= NutGetSeconds() - leaseTime) {
                dhcpState = DHCPST_RENEWING;
            } else {
                /* Calculate the remaining lease time and take a nap. */
                napTime = dhcpConfig->dyn_renewalTime - (NutGetSeconds() - leaseTime);
                if (napTime > MAX_DHCP_NAPTIME) {
                    napTime = MAX_DHCP_NAPTIME;
                }
                NutEventWait(&dhcpWake, napTime * 1000UL);
            }
        }

        /*
         * Waiting for an acknowledge of our renewal request.
         */
        else if (dhcpState == DHCPST_RENEWING) {
            retries++;
            if (tmo / 1000 > dhcpConfig->dyn_rebindTime - (NutGetSeconds() - leaseTime)) {
                tmo = dhcpConfig->dyn_rebindTime - (NutGetSeconds() - leaseTime) * 1000;
            }
            if (dhcpConfig->dyn_rebindTime <= NutGetSeconds() - leaseTime) {
                retries = 0;
                dhcpState = DHCPST_REBINDING;
            }
            /* Send a request to our leasing server. We must not include
               the server identifier. */
            else if (DhcpSendRequest(sock, dhcpConfig->dyn_sid, bp, xid, dhcpConfig->dyn_yiaddr, dhcpConfig->dyn_yiaddr, 0, secs) <
                     0) {
                /* Unicast transmit error. */
                retries = 0;
                dhcpState = DHCPST_REBINDING;
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) < 0) {
                /* Fatal receive error. */
                dhcpState = DHCPST_IDLE;
            } else if (n > 0 && (reply = ParseReply(bp, n)) != 0) {
                if (reply->dyn_msgtyp == DHCP_ACK) {
                    /* Got an acknowledge, return to bound state. */
                    ReleaseDynCfg(dhcpConfig);
                    dhcpConfig = reply;
                    reply = 0;
                    leaseTime = aqsTime;
                    dhcpState = DHCPST_BOUND;
                } else if (reply->dyn_msgtyp == DHCP_NAK) {
                    /* Unexpected NAK. */
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[DHCP-UXNAK]");
#endif
                    retries = 0;
                    dhcpState = DHCPST_REBINDING;
                }
            }
        }

        /*
         * Waiting for an acknowledge of our rebind request.
         */
        else if (dhcpState == DHCPST_REBINDING) {
            retries++;
            if (tmo > dhcpConfig->dyn_rebindTime - (NutGetSeconds() - leaseTime)) {
                tmo = dhcpConfig->dyn_rebindTime - NutGetSeconds() - leaseTime;
            }
            if (dhcpConfig->dyn_rebindTime <= NutGetSeconds() - leaseTime) {
                retries = 0;
                dhcpState = DHCPST_REBINDING;
            }
            /* Broadcast a request for our previous configuration. We
               must not include a server identifier. */
            else if (DhcpBroadcastRequest(sock, bp, xid, dhcpConfig->dyn_yiaddr, dhcpConfig->dyn_yiaddr, 0, secs) < 0) {
                /* Fatal transmit error on broadcast. Give up. */
                dhcpState = DHCPST_IDLE;
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) < 0) {
                /* Fatal receive error. */
                dhcpState = DHCPST_IDLE;
            } else if (n > 0 && (reply = ParseReply(bp, n)) != 0) {
                if (reply->dyn_msgtyp == DHCP_ACK) {
                    /* Got an acknowledge, return to bound state. */
                    ReleaseDynCfg(dhcpConfig);
                    dhcpConfig = reply;
                    reply = 0;
                    leaseTime = aqsTime;
                    dhcpState = DHCPST_BOUND;
                } else if (reply->dyn_msgtyp == DHCP_NAK) {
                    /*
                     * We have a problem here if the last DHCP server died.
                     * If a backup server exists, it may probe our IP address
                     * using ARP or ICMP. Our interface is up and responding,
                     * so the backup server may think that the IP address
                     * is in use and respond with NAK. Without shutting
                     * down our interface (not yet implemented) we are stuck.
                     * We switch to discovery state, but the problem remains.
                     */
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[DHCP-NAK3]");
#endif
                    dhcpState = DHCPST_INIT;
                }
            }
        }

        /*
         * Send an inform and wait for its (optional) echo.
         */
        else if (dhcpState == DHCPST_INFORMING) {
            if (retries++ > MAX_DCHP_RETRIES) {
                dhcpState = DHCPST_IDLE;
            } else if (DhcpSendInform(sock, server_ip, bp, xid, nif->if_local_ip) < 0) {
                if (server_ip == INADDR_BROADCAST) {
                    dhcpState = DHCPST_IDLE;
                }
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) != 0) {
                if (n > 0 &&    /* No receive error. */
                    (reply = ParseReply(bp, n)) != 0 && /* No parser error. */
                    reply->dyn_msgtyp == DHCP_ACK) {    /* Acknowledged. */
                    /* Take over this configuration. */
                    ReleaseDynCfg(dhcpConfig);
                    dhcpConfig = reply;
                    reply = 0;
                }
                dhcpState = DHCPST_IDLE;
            }
        }

        /*
         * Send a release and wait for its (optional) echo.
         */
        else if (dhcpState == DHCPST_RELEASING) {
            if (dhcpConfig == 0 ||      /* Not configured. */
                retries++ > MAX_DCHP_RELEASE_RETRIES || /* Too many retries. */
                DhcpSendRelease(sock, server_ip, bp, xid, dhcpConfig->dyn_yiaddr, dhcpConfig->dyn_sid) < 0) {
                if (server_ip == INADDR_BROADCAST) {
                    dhcpState = DHCPST_IDLE;
                }
            } else if ((n = DhcpRecvMessage(sock, xid, bp, tmo)) < 0) {
                /* Fatal receive error. */
                dhcpState = DHCPST_IDLE;
            } else if (n > 0 && (reply = ParseReply(bp, n)) != 0) {
                if (reply->dyn_msgtyp == DHCP_ACK) {
                    dhcpState = DHCPST_IDLE;
                } else if (reply->dyn_msgtyp == DHCP_NAK) {
#ifdef NUTDEBUG
                    if (__tcp_trf & NET_DBG_DHCP) fprintf(__tcp_trs, "[DHCP-FNAK]");
#endif
                    dhcpState = DHCPST_IDLE;
                }
            }
        }

        /*
         * We are done somehow. Either a fatal error occured or we
         * reached the specified timeout time or our lease has been
         * release or something else configured our interface.
         * Release all resources and wait for a new API call to
         * wake us up.
         */
        else if (dhcpState == DHCPST_IDLE) {
            ReleaseDynCfg(dhcpConfig);
            dhcpConfig = 0;
            retries = 0;
            NutEventBroadcast(&dhcpDone);
            NutEventWait(&dhcpWake, NUT_WAIT_INFINITE);
        }

        /* Release any received reply. */
        if (reply) {
            ReleaseDynCfg(reply);
            reply = 0;
        }
    }
}

static int DhcpKick(CONST char *name, uint8_t state, uint32_t timeout)
{
    NUTDEVICE *dev;
    IFNET *nif;

    /* Lookup the Ethernet device. */
    if ((dev = NutDeviceLookup(name)) == 0 ||   /* No device */
        dev->dev_type != IFTYP_NET ||   /* Wrong type */
        (nif = dev->dev_icb) == 0 ||    /* No netif */
        nif->if_type != IFT_ETHER) {    /* Wrong if type */
        dhcpError = DHCPERR_BADDEV;
        return -1;
    }

    /* Initialize timeout checking. */
    dhcpApiStart = NutGetMillis();
    dhcpApiTimeout = timeout;

    dhcpState = state;
    if (dhcpThread == 0) {
#ifdef __arm__
        dhcpDev = dev;
#endif
        dhcpThread = NutThreadCreate("dhcpc", NutDhcpClient, dev,
            (NUT_THREAD_DHCPSTACK * NUT_THREAD_STACK_MULT) + NUT_THREAD_STACK_ADD);
    }
    NutEventPost(&dhcpWake);
    NutEventWait(&dhcpDone, NUT_WAIT_INFINITE);

    return 0;
}

int NutDhcpIfConfig(CONST char *name, uint8_t * mac, uint32_t timeout)
{
    uint8_t mac0[6];
    uint8_t macF[6];
    NUTDEVICE *dev;
    IFNET *nif;

    /*
     * Lookup the Ethernet device.
     */
    if ((dev = NutDeviceLookup(name)) == 0 ||   /* No device */
        dev->dev_type != IFTYP_NET ||   /* Wrong type */
        (nif = dev->dev_icb) == 0 ||    /* No netif */
        nif->if_type != IFT_ETHER) {    /* Wrong if type */
        dhcpError = DHCPERR_BADDEV;
        return -1;
    }

    /*
     * We determine whether the interface is enabled by checking
     * the MAC address. This is so bloody brain dead.
     */
    memset(mac0, 0x00, sizeof(mac0));   /* Uses more code but less RAM... */
    memset(macF, 0xFF, sizeof(macF));   /* ...than init in declaration.   */
    if (memcmp(nif->if_mac, mac0, 6) == 0 || memcmp(nif->if_mac, macF, 6) == 0) {
        /*
         * If the caller specified a MAC address, we use it and
         * overwrite the configuration.
         */
        if (mac) {
            memcpy(confnet.cdn_mac, mac, sizeof(confnet.cdn_mac));
        }

        /*
         * If no MAC address has been specified, read the configuration
         * from EEPROM. If this fails, we do not continue any further,
         * but let the caller know that something is wrong. He may call
         * us again with a valid MAC address.
         */
        else if (NutNetLoadConfig(name)) {
            dhcpError = DHCPERR_NOMAC;
            return -1;
        }

        /*
         * Copy the MAC address to the interface structure. This will
         * magically brain dead enable the interface.
         */
        memcpy(nif->if_mac, confnet.cdn_mac, 6);
        NutSleep(500);
    }

    /*
     * Zero out the ip address and mask. This allows to switch between
     * DHCP and static IP addresses without resetting/power cycling.
     * See patch #2903940.
     */
    nif->if_local_ip = 0;
    nif->if_mask = confnet.cdn_ip_mask;

    /*
     * If the EEPROM contains a fixed network configuration, we skip DHCP.
     */
    if ((confnet.cdn_cip_addr & confnet.cdn_ip_mask) != 0) {
        /* Give up a previously allocated lease. See patch #2903940. */
        (void)NutDhcpRelease(name, (3*MIN_DHCP_WAIT));
        confnet.cdn_ip_addr = confnet.cdn_cip_addr;
        NutNetIfConfig2(name,
                        confnet.cdn_mac,
                        confnet.cdn_ip_addr,
                        confnet.cdn_ip_mask,
                        confnet.cdn_gateway);
        return 0;
    }

    /*
     * Start the DHCP thread if not running or wake it up. Pass the caller's
     * timeout to the thread and wait an infinite time. We rely on the thread
     * to wake us up on timeout.
     */
    if (DhcpKick(name, DHCPST_INIT, timeout) == 0) {
        /*
         * The thread finished its task. If it reached the bound state, then
         * we got a valid configuration from DHCP.
         */
        if (dhcpState == DHCPST_BOUND) {
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) {
                fprintf(__tcp_trs, "[DHCP-Config %s]", inet_ntoa(dhcpConfig->dyn_yiaddr));
            }
#endif
            NutNetIfSetup(dev, dhcpConfig->dyn_yiaddr, dhcpConfig->dyn_netmask, dhcpConfig->dyn_gateway);
            NutDnsConfig2(NULL, NULL, dhcpConfig->dyn_pdns, dhcpConfig->dyn_sdns);
            return 0;
        }

        /*
         * Our interface has been configured externally, possibly by auto
         * ARP or a similar function implemented by the application.
         */
        if (nif->if_local_ip) {
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) {
                fprintf(__tcp_trs, "[DHCP-External %s]", inet_ntoa(nif->if_local_ip));
            }
#endif
            return 0;
        }

        /*
         * DHCP failed. In case we remember a previously allocated address,
         * then let's use it.
         */
        if ((confnet.cdn_ip_addr & confnet.cdn_ip_mask) != 0) {
#ifdef NUTDEBUG
            if (__tcp_trf & NET_DBG_DHCP) {
                fprintf(__tcp_trs, "[DHCP-Reusing %s]", inet_ntoa(confnet.cdn_ip_addr));
            }
#endif
            NutNetIfConfig2(name, confnet.cdn_mac, confnet.cdn_ip_addr, confnet.cdn_ip_mask, confnet.cdn_gateway);
            return 0;
        }
    }
    return -1;
}

int NutDhcpRelease(CONST char *name, uint32_t timeout)
{
    /* Check the state. */
    if (dhcpState != DHCPST_BOUND) {
        dhcpError = DHCPERR_STATE;
        return -1;
    }

    /* Action! */
    return DhcpKick(name, DHCPST_RELEASING, timeout);
}

int NutDhcpInform(CONST char *name, uint32_t timeout)
{
    /* Check the state. */
    if (dhcpState != DHCPST_IDLE) {
        dhcpError = DHCPERR_STATE;
        return -1;
    }

    /* Action! */
    return DhcpKick(name, DHCPST_INFORMING, timeout);
}

int NutDhcpStatus(CONST char *name)
{
    return dhcpState;
}

int NutDhcpError(CONST char *name)
{
    int rc = dhcpError;
    dhcpError = 0;
    return rc;
}

int NutDhcpIsConfigured(void)
{
    return (dhcpState == DHCPST_BOUND);
}