You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
8.3 KiB
301 lines
8.3 KiB
/*! \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 "net.h"
|
|
#include "nic.h"
|
|
#include "ip.h"
|
|
#include "netstack.h"
|
|
|
|
#include "dhcp.h"
|
|
|
|
#include "HardwareSerial.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
|
|
SPrint_P(PSTR("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
|
|
SPrint("DHCP: Got offer from server "); netPrintIPAddr(htonl(sid)); Serial.println();
|
|
#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
|
|
SPrint("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
|
|
SPrint("DHCP: Got request ACK, bind complete\r\n");
|
|
//debugPrintHexTable(len-DHCP_HEADER_LEN, (packet->options));
|
|
// print info
|
|
ipPrintConfig(ipGetConfig());
|
|
SPrint("LeaseTm : "); Serial.print(DhcpLeaseTime); Serial.println();
|
|
#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
|
|
SPrint("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
|
|
SPrint("DHCP: Sending Release to "); netPrintIPAddr(DhcpServerIP); Serial.println();
|
|
//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, uint32_t* 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)
|
|
{
|
|
SPrint("DHCP Packet:\r\n");
|
|
// print op
|
|
SPrint("Op : ");
|
|
switch(packet->bootp.op)
|
|
{
|
|
case BOOTP_OP_BOOTREQUEST: SPrint("BOOTREQUEST"); break;
|
|
case BOOTP_OP_BOOTREPLY: SPrint("BOOTREPLY"); break;
|
|
default: SPrint("UNKNOWN"); break;
|
|
}
|
|
Serial.println();
|
|
// print transaction ID
|
|
SPrint("XID : 0x"); Serial.printu32(packet->bootp.xid); Serial.println();
|
|
// print client IP address
|
|
SPrint("ClIpAddr: "); netPrintIPAddr(htonl(packet->bootp.ciaddr)); Serial.println();
|
|
// print 'your' IP address
|
|
SPrint("YrIpAddr: "); netPrintIPAddr(htonl(packet->bootp.yiaddr)); Serial.println();
|
|
// print server IP address
|
|
SPrint("SvIpAddr: "); netPrintIPAddr(htonl(packet->bootp.siaddr)); Serial.println();
|
|
// print gateway IP address
|
|
SPrint("GwIpAddr: "); netPrintIPAddr(htonl(packet->bootp.giaddr)); Serial.println();
|
|
// print client hardware address
|
|
SPrint("ClHwAddr: "); netPrintEthAddr((struct netEthAddr*)packet->bootp.chaddr); Serial.println();
|
|
}
|
|
|
|
#endif
|