dhcp.c

Go to the documentation of this file.

/*! \file dhcp.c \brief DHCP Protocol Library. */
//*****************************************************************************
//
// File Name    : 'dhcp.c'
// Title        : DHCP Protocol Library
// Author       : Pascal Stang
// Created      : 9/17/2005
// Revised      : 9/17/2005
// Version      : 0.1
// Target MCU   : Atmel AVR series
// Editor Tabs  : 4
//
//*****************************************************************************

#include "global.h"
#include "net.h"
#include "nic.h"
#include "ip.h"
#include "netstack.h"

#include "dhcp.h"

#include "rprintf.h"

// global variables
uint32_t DhcpServerIP;      ///< IP address of the DHCP server that offered lease
uint32_t DhcpTransactID;    ///< Unique transaction ID that identifies DHCP request/replies
uint32_t DhcpLeaseTime;     ///< Number of seconds left in DHCP lease

void dhcpInit(void)
{
    uint8_t macaddr[6];
    
    // get interface mac address
    nicGetMacAddress(macaddr);
    // set transaction ID based on mac address
    DhcpTransactID = *((uint32_t*)&macaddr);
    // reset lease time
    DhcpLeaseTime = 0;
}

void dhcpIn(unsigned int len, struct netDhcpHeader* packet)
{
    uint8_t msgtype;
    uint32_t sid;
    uint8_t* optptr;
    uint32_t val;
    uint32_t netmask;
    uint32_t gateway;

    #if NET_DEBUG >= 3
    dhcpPrintHeader(packet);
    #endif

    // check that this is a reply, and for me
    if((packet->bootp.op != BOOTP_OP_BOOTREPLY) || (packet->bootp.xid != DhcpTransactID))
        return;

    // process incoming packet
    // check reply type
    dhcpGetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &msgtype);
    #if NET_DEBUG >= 2
    rprintf("DHCP: Received msgtype = %d\r\n", msgtype);
    #endif
    
    if(msgtype == DHCP_MSG_DHCPOFFER)
    {
        // get DHCP server ID
        dhcpGetOption(packet->options, DHCP_OPT_SERVERID, 4, &sid);
        #ifdef DHCP_DEBUG
        rprintfProgStrM("DHCP: Got offer from server "); netPrintIPAddr(htonl(sid)); rprintfCRLF();
        #endif

        // build DHCP request (on top of this reply)
        packet->bootp.op = BOOTP_OP_BOOTREQUEST;        // request type
        // set operation
        val = DHCP_MSG_DHCPREQUEST;
        optptr = dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
        // set the server ID
        optptr = dhcpSetOption(optptr, DHCP_OPT_SERVERID, 4, &sid);
        // request the IP previously offered
        optptr = dhcpSetOption(optptr, DHCP_OPT_REQUESTEDIP, 4, &packet->bootp.yiaddr);
        // request additional information
        ((uint8_t*)&val)[0] = DHCP_OPT_NETMASK;
        ((uint8_t*)&val)[1] = DHCP_OPT_ROUTERS;
        ((uint8_t*)&val)[2] = DHCP_OPT_DNSSERVERS;
        ((uint8_t*)&val)[3] = DHCP_OPT_DOMAINNAME;
        optptr = dhcpSetOption(optptr, DHCP_OPT_PARAMREQLIST, 4, &val);

        #ifdef DHCP_DEBUG
        rprintfProgStrM("DHCP: Sending request in response to offer\r\n");
        #endif
        // send DHCP request
        DhcpServerIP = htonl(sid);
        udpSend(DhcpServerIP, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+6+6+6+1, (uint8_t*)packet);

    }
    else if(msgtype == DHCP_MSG_DHCPACK)
    {
        // get netmask
        dhcpGetOption(packet->options, DHCP_OPT_NETMASK, 4, &val);
        netmask = htonl(val);
        // get gateway
        dhcpGetOption(packet->options, DHCP_OPT_ROUTERS, 4, &val);
        gateway = htonl(val);
        // get gateway
        dhcpGetOption(packet->options, DHCP_OPT_LEASETIME, 4, &val);
        DhcpLeaseTime = htonl(val);

        // assign new network info
        ipSetConfig(htonl(packet->bootp.yiaddr), netmask, gateway);

        #ifdef DHCP_DEBUG
        rprintf("DHCP: Got request ACK, bind complete\r\n");
        //debugPrintHexTable(len-DHCP_HEADER_LEN, (packet->options));
        // print info
        ipPrintConfig(ipGetConfig());
        rprintfProgStrM("LeaseTm : ");  rprintfNum(10,8,FALSE,' ',DhcpLeaseTime);   rprintfCRLF();
        #endif
    }
}

void dhcpRequest(void)
{
    struct netDhcpHeader* packet;
    uint32_t val;
    
    packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];

    // build BOOTP/DHCP header
    packet->bootp.op = BOOTP_OP_BOOTREQUEST;        // request type
    packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
    packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
    packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
    packet->bootp.yiaddr = HTONL(0l);
    packet->bootp.siaddr = HTONL(0l);
    packet->bootp.giaddr = HTONL(0l);
    nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
    packet->bootp.xid = DhcpTransactID;
    packet->bootp.flags = HTONS(1);
    
    // build DHCP request
    // begin with magic cookie
    packet->cookie = 0x63538263;
    // set operation
    val = DHCP_MSG_DHCPDISCOVER;
    dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);

    #ifdef DHCP_DEBUG
    rprintfProgStrM("DHCP: Sending Query\r\n");
    //dhcpPrintHeader(packet);
    #endif

    // send request
    udpSend(0xFFFFFFFF, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+1, (uint8_t*)packet);
}

void dhcpRelease(void)
{
    struct netDhcpHeader* packet;
    uint32_t val;
    uint8_t* optptr;
    
    packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];

    // build BOOTP/DHCP header
    packet->bootp.op = BOOTP_OP_BOOTREQUEST;        // request type
    packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
    packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
    packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
    packet->bootp.yiaddr = HTONL(0l);
    packet->bootp.siaddr = HTONL(0l);
    packet->bootp.giaddr = HTONL(0l);
    nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
    packet->bootp.xid = DhcpTransactID;         // set trans ID (use part of MAC address)
    packet->bootp.flags = HTONS(1);
    
    // build DHCP request
    // begin with magic cookie
    packet->cookie = 0x63538263;
    // set operation
    val = DHCP_MSG_DHCPRELEASE;
    optptr = dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
    // set the server ID
    val = htonl(DhcpServerIP);
    optptr = dhcpSetOption(optptr, DHCP_OPT_SERVERID, 4, &val);
    // request the IP previously offered
    optptr = dhcpSetOption(optptr, DHCP_OPT_REQUESTEDIP, 4, &packet->bootp.ciaddr);

    #ifdef DHCP_DEBUG
    rprintfProgStrM("DHCP: Sending Release to "); netPrintIPAddr(DhcpServerIP); rprintfCRLF();
    //dhcpPrintHeader(packet);
    #endif

    // send release
    udpSend(DhcpServerIP, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+6+6+1, (uint8_t*)packet);
    
    // deconfigure ip addressing
    ipSetConfig(0,0,0);
    DhcpLeaseTime = 0;
}

void dhcpTimer(void)
{
    // this function to be called once per second

    // decrement lease time
    if(DhcpLeaseTime)
        DhcpLeaseTime--;
}

uint8_t dhcpGetOption(uint8_t* options, uint8_t optcode, uint8_t optlen, void* optvalptr)
{
    uint8_t i;

    // parse for desired option
    for (;;)
    {
        // skip pad characters
        if(*options == DHCP_OPT_PAD)
            options++;
        // break if end reached
        else if(*options == DHCP_OPT_END)
            break;
        // check for desired option
        else if(*options == optcode)
        {
            // found desired option
            // limit size to actual option length
            optlen = MIN(optlen, *(options+1));
            //if(*(options+1) < optlen)
            //  optlen = *(options+1);
            
            // copy contents of option
            for(i=0; i<optlen; i++)
                *(((uint8_t*)optvalptr)+i) = *(options+i+2);
            // return length of option
            return *(options+1);
        }
        else
        {
            // skip to next option
            options++;
            options+=*options;
            options++;
        }
    }
    // failed to find desired option
    return 0;
}


uint8_t* dhcpSetOption(uint8_t* options, uint8_t optcode, uint8_t optlen, void* optvalptr)
{
    // use current options address as write point

    // set optcode
    *options++ = optcode;
    // set optlen
    *options++ = optlen;
    // copy in argument/data
    while(optlen--)
    {
        *options++ = *(uint8_t*)optvalptr++;
    }
    // write end marker
    *options = DHCP_OPT_END;

    // return address of end marker, to be used as a future write point
    return options;
}


#ifdef DHCP_DEBUG_PRINT
void dhcpPrintHeader(struct netDhcpHeader* packet)
{
    rprintfProgStrM("DHCP Packet:\r\n");
    // print op
    rprintfProgStrM("Op      : ");
    switch(packet->bootp.op)
    {
    case BOOTP_OP_BOOTREQUEST:  rprintfProgStrM("BOOTREQUEST"); break;
    case BOOTP_OP_BOOTREPLY:    rprintfProgStrM("BOOTREPLY"); break;
    default:                    rprintfProgStrM("UNKNOWN"); break;
    }
    rprintfCRLF();
    // print transaction ID
    rprintfProgStrM("XID     : 0x");    rprintfu32(packet->bootp.xid);              rprintfCRLF();
    // print client IP address
    rprintfProgStrM("ClIpAddr: ");  netPrintIPAddr(htonl(packet->bootp.ciaddr));    rprintfCRLF();
    // print 'your' IP address
    rprintfProgStrM("YrIpAddr: ");  netPrintIPAddr(htonl(packet->bootp.yiaddr));    rprintfCRLF();
    // print server IP address
    rprintfProgStrM("SvIpAddr: ");  netPrintIPAddr(htonl(packet->bootp.siaddr));    rprintfCRLF();
    // print gateway IP address
    rprintfProgStrM("GwIpAddr: ");  netPrintIPAddr(htonl(packet->bootp.giaddr));    rprintfCRLF();
    // print client hardware address
    rprintfProgStrM("ClHwAddr: ");  netPrintEthAddr((struct netEthAddr*)packet->bootp.chaddr);  rprintfCRLF();
}
#endif

---