Microsoft/xbox-kernel
Microsoft/xbox-kernel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
xbox-kernel/private/ntos/net/ipdhcp.cpp

1798 lines
49 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
// ---------------------------------------------------------------------------------------
// ipdhcp.cpp
//
// Copyright (C) Microsoft Corporation
// ---------------------------------------------------------------------------------------
#include "xnp.h"
#include "xnver.h"
DefineTag(dhcp, 0);
#ifdef XNET_FEATURE_DHCP
//
// DHCP message format
// NOTE: default the options field to 64 bytes
// which is the size of BOOTP vendor-specified area
//
typedef struct _DhcpMessage {
BYTE _op; // message type
BYTE _htype; // hareware address type
BYTE _hlen; // hardware address length
BYTE _hops; // relay hops
DWORD _xid; // transaction ID
WORD _secs; // seconds since address acquisition process began
WORD _flags; // flags
CIpAddr _ciaddr; // client IP address
CIpAddr _yiaddr; // "your" (client) IP address
CIpAddr _siaddr; // server IP address
CIpAddr _giaddr; // relay agent IP address
BYTE _chaddr[16]; // client hardware address
BYTE _sname[64]; // optional server hostname
BYTE _file[128]; // boot filename
BYTE _options[64]; // optional parameters (variable length)
} DhcpMessage;
//
// Our default DHCP packet buffer is 576 bytes
//
#define BOOTP_MESSAGE_SIZE sizeof(DhcpMessage)
#define DEFAULT_DHCP_BUFSIZE 576
#define DHCPHDRLEN offsetof(DhcpMessage, _options)
//
// Minimum and maximum DHCP hardware address length
//
#define MIN_DHCP_HWADDRLEN 1
#define MAX_DHCP_HWADDRLEN 16
//
// BOOTP message type constants
//
#define BOOTREQUEST 1
#define BOOTREPLY 2
//
// Hardware type constants
//
#define HWTYPE_10MB_ETHERNET 1
#define HWTYPE_PPP 8
//
// Constants for DHCP_MESSAGE.flags
//
#define DHCP_BROADCAST 0x8000
//
// DHCP message type constants
//
#define DHCPDISCOVER 1
#define DHCPOFFER 2
#define DHCPREQUEST 3
#define DHCPDECLINE 4
#define DHCPACK 5
#define DHCPNAK 6
#define DHCPRELEASE 7
#define DHCPINFORM 8
//
// DHCP option tag constants
//
// Fixed-length options
#define DHCPOPT_PAD 0
#define DHCPOPT_END 255
// Standard options
#define DHCPOPT_SUBNET_MASK 1
#define DHCPOPT_TIME_OFFSET 2
#define DHCPOPT_ROUTERS 3
#define DHCPOPT_TIME_SERVERS 4
#define DHCPOPT_IEN116_SERVERS 5
#define DHCPOPT_DNS_SERVERS 6
#define DHCPOPT_LOG_SERVERS 7
#define DHCPOPT_COOKIE_SERVERS 8
#define DHCPOPT_LPR_SERVERS 9
#define DHCPOPT_IMPRESS_SERVERS 10
#define DHCPOPT_RLP_SERVERS 11
#define DHCPOPT_HOST_NAME 12
#define DHCPOPT_BOOT_FILESIZE 13
#define DHCPOPT_DUMP_FILE 14
#define DHCPOPT_DOMAIN_NAME 15
#define DHCPOPT_SWAP_SERVER 16
#define DHCPOPT_ROOT_PATH 17
#define DHCPOPT_EXTENSIONS_PATH 18
// IP parameters (per host)
#define DHCPOPT_ENABLE_FORWARD 19
#define DHCPOPT_NONLOCAL_SRCROUTING 20
#define DHCPOPT_POLICY_FILTER 21
#define DHCPOPT_MAX_REASSEMBLY_SIZE 22
#define DHCPOPT_DEFAULT_IP_TTL 23
#define DHCPOPT_PMTU_AGING_TIMEOUT 24
#define DHCPOPT_PMTU_PLATEAU_TABLE 25
// IP parameters (per interface)
#define DHCPOPT_INTERFACE_MTU 26
#define DHCPOPT_ALL_SUBNETS_LOCAL 27
#define DHCPOPT_BROADCAST_ADDRESS 28
#define DHCPOPT_MASK_DISCOVERY 29
#define DHCPOPT_MASK_SUPPLIER 30
#define DHCPOPT_ROUTER_DISCOVERY 31
#define DHCPOPT_SOLICIT_ROUTER_ADDR 32
#define DHCPOPT_STATIC_ROUTES 33
// Link layer parameters
#define DHCPOPT_TRAILER_ENCAPS 34
#define DHCPOPT_ARP_CACHE_TIMEOUT 35
#define DHCPOPT_ETHERNET_ENCAPS 36
// TCP parameters
#define DHCPOPT_DEFAULT_TCP_TTL 37
#define DHCPOPT_KEEPALIVE_INTERVAL 38
#define DHCPOPT_KEEPALIVE_GARBAGE 39
// Application parameters
#define DHCPOPT_NIS_DOMAIN 40
#define DHCPOPT_NIS_SERVERS 41
#define DHCPOPT_NTP_SERVERS 42
// DHCP extensions
#define DHCPOPT_REQUESTED_CIpAddr 50
#define DHCPOPT_IPADDR_LEASE_TIME 51
#define DHCPOPT_FIELD_OVERLOAD 52
#define DHCPOPT_TFTP_SERVER_NAME 66
#define DHCPOPT_BOOT_FILENAME 67
#define DHCPOPT_DHCP_MESSAGE_TYPE 53
#define DHCPOPT_SERVERID 54
#define DHCPOPT_PARAM_REQUEST_LIST 55
#define DHCPOPT_MESSAGE 56
#define DHCPOPT_MAX_DHCP_MESSAGESIZE 57
#define DHCPOPT_T1_INTERVAL 58
#define DHCPOPT_T2_INTERVAL 59
#define DHCPOPT_VENDOR_CLASSID 60
#define DHCPOPT_CLIENTID 61
// Vendor-specific information
#define DHCPOPT_VENDOR_INFO 43
#define DHCPOPT_NETBIOS_NAMESERVERS 44
#define DHCPOPT_NETBIOS_DATASERVERS 45
#define DHCPOPT_NETBIOS_NODETYPE 46
#define DHCPOPT_NETBIOS_SCOPE 47
#define DHCPOPT_X11_FONTSERVERS 48
#define DHCPOPT_X11_DISPLAYSERVERS 49
#define DHCPOPT_NIS2_DOMAIN 64
#define DHCPOPT_NIS2_SERVERS 65
#define DHCPOPT_MOBILEIP_HOME_AGENTS 68
#define DHCPOPT_SMTP_SERVERS 69
#define DHCPOPT_POP3_SERVERS 70
#define DHCPOPT_NNTP_SERVERS 71
#define DHCPOPT_WWW_SERVERS 72
#define DHCPOPT_FINGER_SERVERS 73
#define DHCPOPT_IRC_SERVERS 74
#define DHCPOPT_STREETTALK_SERVERS 75
#define DHCPOPT_STREETTALKDA_SERVERS 76
//
// DHCP magic cookie: 99, 130, 83, 99
//
//#define DHCPCOOKIELEN 4
//extern const BYTE DhcpMagicCookie[DHCPCOOKIELEN];
//
// DHCP time value (in seconds)
//
// NOTE: We use 32-bit unsigned interface to represent
// the number of seconds ellapsed since the start of 1/1/2000.
// This should last until year 2136 before overflowing.
//
#define DHCPTIME_INFINITE 0xffffffff
//
// Autonet address range: 169.254/16
// don't use the first 256 and the last 256 addresses
//
#define AUTONET_ADDRMASK 0xffff0000
#define AUTONET_ADDRBASE 0xa9fe0100
#define AUTONET_ADDRRANGE 0x0000fcff
//
// States for an interface
//
enum {
STATE_NONE, // temporary wait state after startup
STATE_STATIC_ADDR, // statically assigned address
STATE_INIT, // sending discover
STATE_REQUESTING, // waiting for DHCPACK after selecting
STATE_INIT_REBOOT, // rebooting with valid lease
STATE_BOUND, // bound with valid address lease
STATE_RENEWING, // renewing after T1 expires
STATE_REBINDING, // rebinding after T2 expires
STATE_DECLINING, // temporary wait state after sending decline
STATE_INIT_AUTOADDR, // waiting for timer to kick off autonet
STATE_SELECT_AUTOADDR // checking autonet address conflicts
};
//
// Constants for the DhcpInfo.flags field:
//
#define FLAG_ACTIVE_DHCPADDR 0x00010000
#define FLAG_ACTIVE_AUTONETADDR 0x00020000
#define FLAG_ACTIVE_NOADDR 0x00040000
#define FLAG_ACTIVE_ADDRMASK (FLAG_ACTIVE_DHCPADDR | FLAG_ACTIVE_AUTONETADDR | FLAG_ACTIVE_NOADDR)
BOOL CXnIp::ActiveDhcpAddr()
{
return (_flags & FLAG_ACTIVE_DHCPADDR);
}
BOOL CXnIp::ActiveAutonetAddr()
{
return (_flags & FLAG_ACTIVE_AUTONETADDR);
}
BOOL CXnIp::ActiveStaticAddr()
{
return(_state == STATE_STATIC_ADDR);
}
BOOL CXnIp::ActiveNoAddr()
{
return(_flags & FLAG_ACTIVE_NOADDR);
}
//
// Dump DHCP message in the debugger
//
#if DBG
VOID DhcpDumpMessage(DhcpMessage* msg, UINT msglen);
#else
#define DhcpDumpMessage(msg, msglen)
#endif
// ---------------------------------------------------------------------------------------
//
// First 4 bytes of the options field in a DHCP message
// must match the following magic cookie
//
const BYTE DhcpMagicCookie[] = { 99, 130, 83, 99 };
//
// Default address lease time requested:
// let the server decide
//
//UINT cfgDefaultLeaseTime = 0;
//
// Minimum retransmission timeout while in
// RENEWING and REBINDING states: 60 seconds
//
//UINT cfgMinRenewTimeout = 60;
//
// Number of seconds to wait after reboot
// before we start sending out DHCPDISCOVER packets
//
// NOTE: RFC2131 recommends that we wait between 1 to 10 seconds.
// But we're only doing 1 seconds here for faster startup time.
//
//UINT cfgStartupWaitMin = 0;
//UINT cfgStartupWaitMax = 1;
//
// Number of times we'll attempt to resend
// DHCPDISCOVER and DHCPREQUEST packets
//
// NOTE: Non-standard behavior!!!
// We're capping the timeout between retries to a maximum of 10 seconds.
//
//UINT cfgDhcpRetryCount = 3;
//UINT cfgDhcpRetryMaxTimeout = 10;
//
// Number of autonet addresses we'll attempt before giving up
//
//UINT cfgAutonetAddrRetries = 10;
//
// How frequently to look for DHCP server when in Autonet mode
//
//UINT cfgAutonetDhcpCheckInterval = 5*60;
//
// How many ARP requests to send
// when checking for address conflict
//
//UINT cfgConflictCheckRetries = 2;
// Check to see if we're forced to use autonet address
// (without trying to find DHCP servers)
INLINE
BOOL CXnIp::DhcpForceAutonet(CIpAddr addr, CIpAddr mask)
{
ICHECK(IP, USER|UDPC|SDPC);
return (mask == HTONL(AUTONET_ADDRMASK)) &&
(addr & mask) == (HTONL(AUTONET_ADDRBASE) & mask);
}
NTSTATUS CXnIp::DhcpInit()
{
ICHECK(IP, USER);
_state = STATE_NONE;
_timerDhcp.Init((PFNTIMER)DhcpTimer);
_dwXidNext = RandLong();
return(NETERR_OK);
}
INT CXnIp::DhcpConfig(const XNetConfigParams * pxncp)
{
ICHECK(IP, UDPC);
//@@@ Cannot be reconfigured. Need DHCP rewrite.
_activeaddr = pxncp->ina.s_addr;
if (_activeaddr != 0)
{
_activemask = pxncp->inaMask.s_addr;
if (_activemask == 0 || !_activemask.IsValidMask())
_activemask = _activeaddr.DefaultMask();
_options._gatewayCount = 0;
if (pxncp->inaGateway.s_addr != 0)
{
_options._gateways[_options._gatewayCount] = pxncp->inaGateway.s_addr;
_options._gatewayCount += 1;
}
_options._dnsServerCount = 0;
if (pxncp->inaDnsPrimary.s_addr != 0)
{
_options._dnsServers[_options._dnsServerCount] = pxncp->inaDnsPrimary.s_addr;
_options._dnsServerCount += 1;
}
if (pxncp->inaDnsSecondary.s_addr != 0)
{
_options._dnsServers[_options._dnsServerCount] = pxncp->inaDnsSecondary.s_addr;
_options._dnsServerCount += 1;
}
}
if (!TestInitFlag(INITF_CONNECTED_BOOT))
{
TraceSz(Warning, "Ethernet cable not plugged in. No IP address acquired.");
_flags = (_flags & ~FLAG_ACTIVE_ADDRMASK) | FLAG_ACTIVE_NOADDR;
}
#if defined(XNET_FEATURE_INSECURE) && !defined(XNET_FEATURE_SG)
else if (!(cfgFlags & XNET_STARTUP_BYPASS_SECURITY))
{
// When operating in secure mode don't acquire an IP address so we behave
// more like xnets.lib.
_flags = (_flags & ~FLAG_ACTIVE_ADDRMASK) | FLAG_ACTIVE_NOADDR;
}
#endif
else if (_activeaddr != 0 && !DhcpForceAutonet(_activeaddr, _activemask))
{
// If we're using static address, inform the IP stack
IpSetAddress(_activeaddr, _activemask);
DhcpSetDefaultGateways();
DhcpChangeState(STATE_STATIC_ADDR);
}
else if ((cfgFlags & XNET_STARTUP_BYPASS_DHCP) || _activeaddr != 0)
{
TraceSz(Warning, "Forcing autonet...");
_activeaddr = _activemask = 0;
DhcpChangeState(STATE_INIT_AUTOADDR);
}
else
{
// Obtain address via DHCP or Autonet. Be quiet for a while after startup.
DhcpTimerSetRelative(0, 0);
}
return(0);
}
void CXnIp::DhcpTerm()
{
ICHECK(IP, UDPC);
TimerSet(&_timerDhcp, TIMER_INFINITE);
}
void CXnIp::DhcpRecv(CPacket * ppkt, CUdpHdr * pUdpHdr, UINT msglen)
{
ICHECK(IP, UDPC|SDPC);
DhcpMessage * msg = (DhcpMessage *)(pUdpHdr + 1);
CDhcpOptions * dhcpParams = NULL;
BYTE* option;
BYTE overload = 0;
NTSTATUS status = NETERR_NOTIMPL;
if (msglen < DHCPHDRLEN)
{
TraceSz1(pktRecv, "[DISCARD] DHCP packet is too short (%d)", msglen);
return;
}
if (memcmp(msg->_chaddr, _ea._ab, sizeof(CEnetAddr)) != 0)
{
TraceSz(pktRecv, "[DISCARD] DHCP packet not meant for me");
return;
}
if ( msg->_op != BOOTREPLY
|| msg->_htype != HWTYPE_10MB_ETHERNET
|| msg->_hlen != sizeof(CEnetAddr)
|| NTOHL(msg->_xid) != _xid)
{
TraceSz4(pktWarn, "[DISCARD] DHCP packet is invalid (%d,%d,%d,%d)",
msg->_op != BOOTREPLY,
msg->_htype != HWTYPE_10MB_ETHERNET,
msg->_hlen != sizeof(CEnetAddr),
NTOHL(msg->_xid) != _xid);
return;
}
DhcpDumpMessage(msg, msglen);
dhcpParams = (CDhcpOptions *)PoolAllocZ(sizeof(*dhcpParams), PTAG_CDhcpOptions);
if (!dhcpParams)
{
TraceSz(pktWarn, "[DISCARD] Out of memory allocating CDhcpOptions");
status = NETERR_MEMORY;
goto exit;
}
//
// Skip the DHCP magic cookie
//
option = msg->_options;
msglen -= DHCPHDRLEN;
if ( msglen < sizeof(DhcpMagicCookie)
|| memcmp(option, DhcpMagicCookie, sizeof(DhcpMagicCookie)) != 0)
{
TraceSz1(pktWarn, "[DISCARD] DHCP packet has invalid magic cookie (%d)", msglen);
goto exit;
}
msglen -= sizeof(DhcpMagicCookie);
option += sizeof(DhcpMagicCookie);
//
// Parse the regular options
//
status = DhcpParseOptionParams(dhcpParams, option, msglen, &overload);
if (!NT_SUCCESS(status))
{
TraceSz(pktWarn, "[DISCARD] DHCP regular options are invalid");
goto exit;
}
//
// Parse overloaded options in the msg->_file field
//
if (overload & 1)
{
status = DhcpParseOptionParams(dhcpParams, msg->_file, sizeof(msg->_file), NULL);
if (!NT_SUCCESS(status))
{
TraceSz(pktWarn, "[DISCARD] DHCP file options are invalid");
goto exit;
}
}
//
// Parse overloaded options in the msg->_sname field
//
if (overload & 2)
{
status = DhcpParseOptionParams(dhcpParams, msg->_sname, sizeof(msg->_sname), NULL);
if (!NT_SUCCESS(status))
{
TraceSz(pktWarn, "[DISCARD] DHCP sname options are invalid");
goto exit;
}
}
//
// The received packet must have a server identifier option
//
if (dhcpParams->_dhcpServer == 0)
{
TraceSz(pktWarn, "[DISCARD] DHCP packet lacks server identifier option");
status = NETERR_PARAM;
goto exit;
}
//
// Now that we've parsed the option data,
// use it appropriately
//
status = NETERR_NOTIMPL;
switch (_state) {
case STATE_INIT:
// Expecting DHCPOFFER...
if (dhcpParams->_recvMsgType == DHCPOFFER)
status = DhcpProcessOffer(msg->_yiaddr, dhcpParams);
break;
case STATE_INIT_REBOOT:
case STATE_REQUESTING:
case STATE_RENEWING:
case STATE_REBINDING:
// Expecting DHCPACK or DHCPNAK...
if (dhcpParams->_recvMsgType == DHCPACK)
status = DhcpProcessAck(msg->_yiaddr, dhcpParams);
else if (dhcpParams->_recvMsgType == DHCPNAK)
status = DhcpProcessNak(dhcpParams->_dhcpServer);
break;
}
exit:
if (!NT_SUCCESS(status) && status != NETERR_NOTIMPL)
{
TraceSz1(pktWarn, "[DISCARD] DhcpRecv failed: %08lX", status);
}
PoolFree(dhcpParams);
}
void CXnIp::DhcpNotifyAddressConflict()
{
ICHECK(IP, UDPC|SDPC);
if (_state == STATE_SELECT_AUTOADDR)
{
// the last autonet address we chose was no good
// so we need to find another one
DhcpSelectAutonetAddr();
}
else
{
TraceSz1(Warning, "!!! Address conflict: %s", _activeaddr.Str());
}
}
//
// Number of seconds from start of 1601 to start of 2000
//
static const LONGLONG StartOf2000 = 0x2ee7dd480;
CXnIp::DHCPTIME CXnIp::DhcpTime()
{
ICHECK(IP, UDPC|SDPC);
LARGE_INTEGER currentTime;
// Get the current UTC time
// = number of 100 nanoseconds since 1/1/1601
KeQuerySystemTime(&currentTime);
// Return the number of seconds since the start of 2000
return (DHCPTIME) (currentTime.QuadPart / 10000000 - StartOf2000);
}
void CXnIp::DhcpTimerSetRelative(UINT minWait, UINT maxWait)
{
ICHECK(IP, UDPC|SDPC);
TimerSet(&_timerDhcp, TimerTick() + (minWait + RandScaled(maxWait - minWait)) * TICKS_PER_SECOND);
}
void CXnIp::DhcpTimerSetAbsolute(DHCPTIME dhcptime)
{
ICHECK(IP, UDPC|SDPC);
DWORD dwTick = TIMER_INFINITE;
if (dhcptime != DHCPTIME_INFINITE)
{
DHCPTIME dhcptimeNow = DhcpTime();
if (dhcptime > dhcptimeNow)
dwTick = TimerTick() + (dhcptime - dhcptimeNow) * TICKS_PER_SECOND;
else
dwTick = TimerTick();
}
TimerSet(&_timerDhcp, dwTick);
}
void CXnIp::DhcpComputeTimeout()
{
ICHECK(IP, UDPC|SDPC);
UINT minWait, maxWait;
switch (_state)
{
case STATE_INIT:
if (ActiveAutonetAddr()) {
//
// Special case: we're currently using an Autonet address
// and we're sending out periodic DHCPDISCOVER packets.
//
// DhcpSetIfTimerRelative(
// cfgAutonetDhcpCheckInterval,
// cfgAutonetDhcpCheckInterval);
// NOTE: Non-standard behavior!!!
// We do not send out DHCPDISCOVER messages
// while we're using an active AutoNet address.
DhcpTimerSetAbsolute(DHCPTIME_INFINITE);
break;
}
// Fall through
case STATE_REQUESTING:
case STATE_INIT_REBOOT:
//
// timeout = 2**retry x 2 +/- 1, i.e.
// 4 +/- 1
// 8 +/- 1
// 16 +/- 1
// 32 +/- 1
//
minWait = 2 << _retries;
if (minWait > cfgDhcpRetryMaxTimeoutInSeconds)
minWait = cfgDhcpRetryMaxTimeoutInSeconds;
minWait -= 1;
maxWait = minWait + 2;
DhcpTimerSetRelative(minWait, maxWait);
break;
case STATE_BOUND:
//
// timeout when T1 expires
//
DhcpTimerSetAbsolute(_options._t1time);
break;
case STATE_RENEWING:
case STATE_REBINDING: {
//
// calculate retransmission timeout for
// RENEWING and REBINDING states:
// 1. half the time from now to T2 (renew) or expiration (rebind)
// 2. make sure it's at least 60 seconds
//
DHCPTIME t1, t2;
t1 = DhcpTime();
t2 = (_state == STATE_RENEWING) ? _options._t2time : _options._exptime;
if (t1 < t2) {
minWait = (t2-t1) / 2;
if (minWait >= cfgDhcpRenewMinTimeoutInSeconds)
t1 += minWait;
else {
t1 += cfgDhcpRenewMinTimeoutInSeconds;
if (t1 > t2) t1 = t2;
}
}
DhcpTimerSetAbsolute(t1);
}
break;
case STATE_DECLINING:
//
// Wait 10 seconds after sending DHCP decline
//
DhcpTimerSetRelative(cfgDhcpDeclineWaitInSeconds, cfgDhcpDeclineWaitInSeconds);
break;
case STATE_SELECT_AUTOADDR:
//
// Wait ~2 seconds for address conflict detection
//
DhcpTimerSetRelative(cfgAutoIpRexmitTimeoutInSeconds, cfgAutoIpRexmitTimeoutInSeconds);
break;
default:
// Should not happen - shut off the timer just in case
Assert(FALSE);
case STATE_NONE:
case STATE_STATIC_ADDR:
DhcpTimerSetAbsolute(DHCPTIME_INFINITE);
break;
}
}
void CXnIp::DhcpTimer(CTimer * pt)
{
ICHECK(IP, UDPC|SDPC);
switch (_state) {
case STATE_NONE:
//
// We got here because we just finished the quiet
// period after startup
//
// If we had a valid lease before, start in
// INIT-REBOOT state; otherwise, start in INIT state
//
DhcpChangeState(_dhcpaddr ? STATE_INIT_REBOOT : STATE_INIT);
break;
case STATE_INIT:
//
// We're sending DHCPDISCOVER messages
//
if (_retries >= cfgDhcpRetryCount && !ActiveAutonetAddr())
{
//
// Too many retries, give up and
// start Autonet address acquisition process
//
TraceSz(dhcp, "Couldn't discover DHCP server, trying autonet...");
DhcpChangeState(STATE_SELECT_AUTOADDR);
}
else
{
//
// Send out another DHCPDISCOVER packet
//
TraceSz(dhcp, "Retransmit DHCPDISCOVER");
DhcpSendDiscover();
}
break;
case STATE_INIT_REBOOT:
case STATE_REQUESTING:
//
// We're sending DHCPREQUEST
//
if (_retries >= cfgDhcpRetryCount) {
//
// Too many retries, go back to INIT state
//
TraceSz(dhcp, _state == STATE_INIT_REBOOT ?
"Failed to reuse a prior lease" :
"No ack for an offered address");
DhcpChangeState(STATE_INIT);
} else {
//
// Send out another DHCPREQUEST packet
//
TraceSz(dhcp, "Retransmit DHCPREQUEST");
DhcpSendRequest();
}
break;
case STATE_DECLINING:
//
// We just finished waiting after sending DHCPDECLINE
//
DhcpChangeState(STATE_INIT);
break;
case STATE_BOUND:
//
// T1 expired, start the renewing process
//
TraceSz(dhcp, "Switching to RENEWING state");
DhcpChangeState(STATE_RENEWING);
break;
case STATE_RENEWING:
//
// We're trying to renew a valid address.
// If T2 expired, start the rebinding process.
//
if (DhcpTime() >= _options._t2time) {
TraceSz(dhcp, "Switching to REBINDING state");
DhcpChangeState(STATE_REBINDING);
} else {
// Send out another DHCPREQUEST
TraceSz(dhcp, "Retransmit DHCPREQUEST");
DhcpSendRequest();
}
break;
case STATE_REBINDING:
//
// We're trying to rebind a valid lease
// did our lease expire?
//
if (DhcpTime() >= _options._exptime) {
// Inform IP stack to discard the active address
TraceSz(dhcp, "Address lease expired - start over");
DhcpResetInterface();
// Too bad, go back to INIT state
DhcpChangeState(STATE_INIT);
} else {
// Send out another DHCPREQUEST
TraceSz(dhcp, "Retransmit DHCPREQUEST");
DhcpSendRequest();
}
break;
case STATE_INIT_AUTOADDR:
DhcpChangeState(STATE_SELECT_AUTOADDR);
break;
case STATE_SELECT_AUTOADDR:
if (++_retries > cfgAutoIpRetriesPerAttempt)
{
// We've successfully picked an autonet address.
TraceSz1(dhcp, "Selected autonet address: %s", _autonetaddr.Str());
_activeaddr = _autonetaddr;
_activemask = HTONL(AUTONET_ADDRMASK);
_flags |= FLAG_ACTIVE_AUTONETADDR;
IpSetAddress(_activeaddr, _activemask);
// Switch to INIT state to continue looking
// for a DHCP server
_initRetryCount = 0;
DhcpChangeState(STATE_INIT);
}
else
{
// No response to our previous ARP request.
// Try again just to be sure.
EnetXmitArp(_autonetaddr);
DhcpComputeTimeout();
}
break;
default:
TraceSz(dhcp, "Unexpected timeout");
DhcpTimerSetAbsolute(DHCPTIME_INFINITE);
break;
}
}
void CXnIp::DhcpChangeState(INT state)
{
ICHECK(IP, UDPC|SDPC);
INT oldstate = _state;
_state = state;
_retries = 0;
// Assign a new transaction ID for the next outgoing message.
_xid = _dwXidNext++;
switch (state) {
case STATE_INIT_REBOOT:
case STATE_REQUESTING:
case STATE_RENEWING:
case STATE_REBINDING:
// Send out DHCPREQUEST
DhcpSendRequest();
break;
case STATE_INIT:
if (oldstate == STATE_SELECT_AUTOADDR) {
// We just selected an autonet address.
// Continue to look for a DHCP server.
DhcpComputeTimeout();
}
else if (++_initRetryCount > cfgDhcpRetryCount) {
// We went through the INIT state too many times
// without getting a valid address lease. Just give up.
// We don't try Autonet because in this case there
// is a DHCP server but somehow we can't work with it.
TraceSz(Warning, "Couldn't get a valid DHCP address after many tries");
DhcpChangeState(STATE_NONE);
_flags = (_flags & ~FLAG_ACTIVE_ADDRMASK) | FLAG_ACTIVE_NOADDR;
} else {
// Send out DHCPDISCOVER
DhcpSendDiscover();
}
break;
case STATE_BOUND:
DhcpComputeTimeout();
TraceSz1(dhcp, "Sleep %d seconds till renewal...", _options._t1time - DhcpTime());
break;
case STATE_INIT_AUTOADDR:
DhcpTimerSetAbsolute(0);
break;
case STATE_SELECT_AUTOADDR:
_initRetryCount = 0;
DhcpSelectAutonetAddr();
break;
case STATE_NONE:
case STATE_STATIC_ADDR:
DhcpTimerSetAbsolute(DHCPTIME_INFINITE);
break;
}
}
void CXnIp::DhcpResetInterface()
{
ICHECK(IP, UDPC|SDPC);
IpSetAddress(0, 0);
_flags &= ~FLAG_ACTIVE_ADDRMASK;
if (_state != STATE_STATIC_ADDR)
_activeaddr = 0;
}
NTSTATUS CXnIp::DhcpSendMessage(CPacket * ppkt, UINT msglen, BOOL broadcast)
{
ICHECK(IP, UDPC|SDPC);
ppkt->SetCb(ppkt->GetCb() - DEFAULT_DHCP_BUFSIZE + msglen);
CUdpHdr * pUdpHdr = ppkt->GetUdpHdr();
DhcpMessage * msg = (DhcpMessage *)(pUdpHdr + 1);
// Debug trace
DhcpDumpMessage(msg, msglen);
// Set broadcast flag if necessary
if (!_activeaddr || ActiveAutonetAddr())
msg->_flags |= HTONS(DHCP_BROADCAST);
pUdpHdr->_ipportSrc = DHCP_CLIENT_PORT;
pUdpHdr->_ipportDst = DHCP_SERVER_PORT;
pUdpHdr->_wLen = HTONS(msglen + sizeof(CUdpHdr));
// Call the IP layer to send out the packet
IpFillAndXmit(ppkt, broadcast ? IPADDR_BROADCAST : _options._dhcpServer, IPPROTOCOL_UDP);
// Calculate the timeout value
_retries++;
DhcpComputeTimeout();
return(NETERR_OK);
}
//
// Append the 'parameter request list' option
// !!! we assume the data buffer is large enough.
//
BYTE * DhcpAppendParamReqList(BYTE * option)
{
*option++ = DHCPOPT_PARAM_REQUEST_LIST;
*option++ = 4;
*option++ = DHCPOPT_SUBNET_MASK;
*option++ = DHCPOPT_ROUTERS;
*option++ = DHCPOPT_DNS_SERVERS;
*option++ = DHCPOPT_DOMAIN_NAME;
return(option);
}
//
// Append an option whose value is a DWORD
//
BYTE * DhcpAppendDWordOption(BYTE * option, INT tag, DWORD val)
{
option[0] = (BYTE) tag;
option[1] = sizeof(DWORD);
option += 2;
memcpy(option, &val, sizeof(DWORD));
return option + sizeof(DWORD);
}
//
// Append the 'address lease time' option
//
BYTE * CXnIp::DhcpAppendLeaseTimeOption(BYTE * option)
{
ICHECK(IP, UDPC|SDPC);
DWORD dwLeaseTime = cfgDhcpDefaultLeaseTimeInDays * (24 * 60 * 60);
if (dwLeaseTime == 0)
return option;
return DhcpAppendDWordOption(option, DHCPOPT_IPADDR_LEASE_TIME, HTONL(dwLeaseTime));
}
BYTE * CXnIp::DhcpFillMessageHeader(BYTE * buf, INT msgtype)
{
ICHECK(IP, UDPC|SDPC);
DhcpMessage* msg = (DhcpMessage*) buf;
BYTE* option = msg->_options;
BYTE hwtype;
memset(buf, 0, DEFAULT_DHCP_BUFSIZE);
msg->_op = BOOTREQUEST;
msg->_htype = hwtype = HWTYPE_10MB_ETHERNET;
msg->_hlen = sizeof(CEnetAddr);
memcpy(msg->_chaddr, _ea._ab, sizeof(CEnetAddr));
//
// Fill in the transaction ID field
// NOTE: We reuse the same XID for retransmissions.
//
msg->_xid = HTONL(_xid);
// Number of seconds since we started the address
// acquisition process.
msg->_secs = (WORD) HTONS((WORD)_secsSinceStart);
// Start with the magic cookie
memcpy(option, DhcpMagicCookie, sizeof(DhcpMagicCookie));
option += sizeof(DhcpMagicCookie);
// Append the message type option
option[0] = DHCPOPT_DHCP_MESSAGE_TYPE;
option[1] = 1;
option[2] = (BYTE) msgtype;
option += 3;
// Append the client identifier option
option[0] = DHCPOPT_CLIENTID;
option[1] = (BYTE) (sizeof(CEnetAddr)+1);
option[2] = hwtype;
option += 3;
memcpy(option, _ea._ab, sizeof(CEnetAddr));
option += sizeof(CEnetAddr);
return option;
}
void CXnIp::DhcpComputeSecsSinceStart()
{
ICHECK(IP, UDPC|SDPC);
DHCPTIME now = DhcpTime();
if (_retries == 0)
_acqtime = now;
_secsSinceStart = now - _acqtime;
}
//
// Common prolog and epilog for SendDhcpXXX functions
//
#define SEND_DHCP_MESSAGE_PROLOG() \
DhcpMessage* msg; \
BYTE* buf; \
BYTE* option; \
CPacket * pkt = PacketAlloc(PTAG_CDhcpPacket, PKTF_TYPE_UDP|PKTF_XMIT_INSECURE|PKTF_POOLALLOC, DEFAULT_DHCP_BUFSIZE); \
if (!pkt) return NETERR_MEMORY; \
buf = (BYTE *)pkt->GetUdpHdr() + sizeof(CUdpHdr); \
msg = (DhcpMessage*) buf
#define SEND_DHCP_MESSAGE_RETURN(_bcast) \
return DhcpSendMessage(pkt, option - buf, _bcast)
NTSTATUS CXnIp::DhcpSendDiscover()
{
ICHECK(IP, UDPC|SDPC);
SEND_DHCP_MESSAGE_PROLOG();
Assert(_state == STATE_INIT);
DhcpComputeSecsSinceStart();
// Fill in common header fields
option = DhcpFillMessageHeader(buf, DHCPDISCOVER);
// Fill in the parameter request list
option = DhcpAppendParamReqList(option);
// Fill in requested ip address and lease time option
if (_dhcpaddr)
option = DhcpAppendDWordOption(option, DHCPOPT_REQUESTED_CIpAddr, _dhcpaddr);
// Fill in the lease time option
option = DhcpAppendLeaseTimeOption(option);
*option++ = DHCPOPT_END;
// Emit the message
SEND_DHCP_MESSAGE_RETURN(TRUE);
}
NTSTATUS CXnIp::DhcpSendRequest()
{
ICHECK(IP, UDPC|SDPC);
INT state = _state;
SEND_DHCP_MESSAGE_PROLOG();
Assert(state == STATE_REQUESTING ||
state == STATE_RENEWING ||
state == STATE_REBINDING ||
state == STATE_INIT_REBOOT);
//
// If we're in REQUESTING state, then don't update
// the secsSinceStart field. This is so that the
// secs in DHCPREQUEST message will be the same as
// what's in the original DHCPDISCOVER message.
//
if (state != STATE_REQUESTING) {
DhcpComputeSecsSinceStart();
}
// Fill in common header fields
option = DhcpFillMessageHeader(buf, DHCPREQUEST);
// Fill in the ciaddr field and the 'requested ip addr' option
if (state == STATE_RENEWING || state == STATE_REBINDING) {
msg->_ciaddr = _dhcpaddr;
} else if (_dhcpaddr) {
// state == STATE_INIT_REBOOT || state == STATE_REQUESTING
option = DhcpAppendDWordOption(option, DHCPOPT_REQUESTED_CIpAddr, _dhcpaddr);
}
// Fill in the parameter request list
option = DhcpAppendParamReqList(option);
// Fill in the lease time option
option = DhcpAppendLeaseTimeOption(option);
// Fill in the server identifier option
if (state == STATE_REQUESTING)
option = DhcpAppendDWordOption(option, DHCPOPT_SERVERID, _options._dhcpServer);
*option++ = DHCPOPT_END;
// Emit the message:
// unicast in RENEWING state, broadcast otherwise
SEND_DHCP_MESSAGE_RETURN(state != STATE_RENEWING);
}
BOOL CXnIp::DhcpValidateOffer(CIpAddr yiaddr, CDhcpOptions* param)
{
ICHECK(IP, UDPC|SDPC);
if ( !yiaddr.IsValidUnicast()
|| !param->_dhcpServer.IsValidUnicast()
|| param->_exptime < (DHCPTIME)(8*cfgDhcpRenewMinTimeoutInSeconds))
return FALSE;
if (param->_dhcpmask == 0)
param->_dhcpmask = yiaddr.DefaultMask();
if (param->_t1time == 0 ||
param->_t2time == 0 ||
param->_t1time >= param->_t2time ||
param->_t2time - param->_t1time < cfgDhcpRenewMinTimeoutInSeconds ||
param->_t2time >= param->_exptime ||
param->_exptime - param->_t2time < cfgDhcpRenewMinTimeoutInSeconds) {
param->_t1time = param->_exptime / 2;
param->_t2time = param->_exptime * 7 / 8;
}
return TRUE;
}
NTSTATUS CXnIp::DhcpProcessOffer(CIpAddr yiaddr, CDhcpOptions* param)
{
ICHECK(IP, UDPC|SDPC);
Assert(_state == STATE_INIT);
TraceSz3(dhcp, "Received DHCPOFFER %s from %s @ time %d", yiaddr.Str(), param->_dhcpServer.Str(), DhcpTime());
// Simply sanity check of offered parameters
if (!DhcpValidateOffer(yiaddr, param))
return(NETERR_PARAM);
_options._dhcpServer = param->_dhcpServer;
_dhcpaddr = yiaddr;
// Send DHCPREQUEST and ignore error
DhcpChangeState(STATE_REQUESTING);
return(NETERR_OK);
}
void CXnIp::DhcpAddOrRemoveGateways(BOOL fDelete)
{
ICHECK(IP, UDPC|SDPC);
CIpAddr ipa;
UINT i;
for (i = 0; i < _options._gatewayCount; i++)
{
ipa = _options._gateways[i];
TraceSz2(dhcp, "%s gateway: %s", fDelete ? "Remove" : "Add", ipa.Str());
if (fDelete)
RouteDelete(0, 0, ipa);
else
RouteAdd(0, 0, ipa, RTEF_DEFAULT, (WORD)(RTE_DEFAULT_METRIC + i));
}
}
void CXnIp::DhcpSetDefaultGateways()
{
ICHECK(IP, USER|UDPC|SDPC);
RaiseToDpc();
DhcpAddOrRemoveGateways(FALSE);
}
void CXnIp::DhcpUseOptionParams(CDhcpOptions* param)
{
ICHECK(IP, UDPC|SDPC);
BOOL resetGateways;
//
// Remember the originating server address and lease info
//
_options._dhcpServer = param->_dhcpServer;
if (param->_exptime == DHCPTIME_INFINITE) {
_options._t1time =
_options._t2time =
_options._exptime = DHCPTIME_INFINITE;
} else {
_options._t1time = _acqtime + param->_t1time;
_options._t2time = _acqtime + param->_t2time;
_options._exptime = _acqtime + param->_exptime;
}
//
// Set gateways in the IP stack
//
if (param->_gatewayCount == 0 || _options._gatewayCount == 0) {
resetGateways = TRUE;
} else {
UINT oldcnt = _options._gatewayCount;
UINT newcnt = param->_gatewayCount;
UINT i, j;
for (i=0; i < newcnt; i++) {
for (j=0; j < oldcnt; j++)
if (param->_gateways[i] != _options._gateways[j]) break;
if (j < oldcnt) break;
}
resetGateways = (i < newcnt);
}
if (resetGateways) {
//
// Reset gateways if anything has changed
// first delete existing gateways
// then set new gateways
//
// NOTE: should we ping the new gateways here?
//
DhcpAddOrRemoveGateways(TRUE);
_options._gatewayCount = param->_gatewayCount;
memcpy(_options._gateways,
param->_gateways,
param->_gatewayCount * sizeof(CIpAddr));
DhcpAddOrRemoveGateways(FALSE);
}
_options._dnsServerCount = param->_dnsServerCount;
memcpy(_options._dnsServers,
param->_dnsServers,
param->_dnsServerCount * sizeof(CIpAddr));
#if DBG
UINT i;
TraceSz2(dhcp, "%d gateway%s configured", _options._gatewayCount, _options._gatewayCount == 1 ? "" : "s");
for (i = 0; i < _options._gatewayCount; ++i)
TraceSz1(dhcp, " %s", _options._gateways[i].Str());
TraceSz2(dhcp, "%d DNS server%s configured", _options._dnsServerCount, _options._dnsServerCount == 1 ? "" : "s");
for (i = 0; i < _options._dnsServerCount; ++i)
TraceSz1(dhcp, " %s", _options._dnsServers[i].Str());
#endif
}
NTSTATUS CXnIp::DhcpProcessAck(CIpAddr yiaddr, CDhcpOptions* param)
{
ICHECK(IP, UDPC|SDPC);
TraceSz2(dhcp, "Received DHCPACK %s from %s", yiaddr.Str(), param->_dhcpServer.Str());
Assert(_state == STATE_INIT_REBOOT ||
_state == STATE_REQUESTING ||
_state == STATE_RENEWING ||
_state == STATE_REBINDING);
// Simply sanity check of offered parameters
if (!DhcpValidateOffer(yiaddr, param))
return NETERR_PARAM;
// Note: We're not checking for address conflicts
// and just assume the offered address is valid.
// If we're currently using a different address, give it up
if ((_activeaddr != 0) &&
(_activeaddr != yiaddr ||
_activemask != param->_dhcpmask) ||
ActiveAutonetAddr())
{
TraceSz1(dhcp, "Giving up old IP address %s", _activeaddr.Str());
DhcpResetInterface();
}
// If we got a new address, set it down in the IP stack
if (_activeaddr == 0)
{
IpSetAddress(yiaddr, param->_dhcpmask);
_activeaddr = _dhcpaddr = yiaddr;
_activemask = _options._dhcpmask = param->_dhcpmask;
_flags |= FLAG_ACTIVE_DHCPADDR;
}
TraceSz2(dhcp, "Accepted IP address: %s from %s", yiaddr.Str(), param->_dhcpServer.Str());
TraceSz3(dhcp, "Lease time: %d / %d / %d", param->_t1time, param->_t2time, param->_exptime);
//
// Set other option parameters
//
_initRetryCount = 0;
DhcpUseOptionParams(param);
// We're now in bound state.
// Set timer to expire at T1 time.
DhcpChangeState(STATE_BOUND);
return NETERR_OK;
}
NTSTATUS CXnIp::DhcpProcessNak(CIpAddr dhcpServer)
{
ICHECK(IP, UDPC|SDPC);
TraceSz1(dhcp, "Received DHCPNAK from %s", dhcpServer.Str());
Assert(_state == STATE_INIT_REBOOT ||
_state == STATE_REQUESTING ||
_state == STATE_RENEWING ||
_state == STATE_REBINDING);
// Barf if we got DHCPNAK from an unexpected server
if (_state != STATE_INIT_REBOOT && dhcpServer != _options._dhcpServer)
{
TraceSz1(Warning, "Random DHCPNAK from %s?", dhcpServer.Str());
}
// If we're using an address, give it up
if (_activeaddr) {
DhcpResetInterface();
}
//
// Go to INIT state to start over again
// Send DHCPDISCOVER and ignore error
//
DhcpChangeState(STATE_INIT);
return NETERR_OK;
}
// NOTE: we're assuming little-endian machine here.
#define EXTRACT_DWORD_OPTION(_result) \
if (len != 4) goto exit; \
if (_result == 0) { \
_result = (((DWORD) buf[0] << 24) | \
((DWORD) buf[1] << 16) | \
((DWORD) buf[2] << 8) | \
((DWORD) buf[3] )); \
}
#define EXTRACT_IPADDR_OPTION(_result) \
if (len != 4) goto exit; \
if (_result == 0) _result = *((CIpAddr*) buf)
NTSTATUS CXnIp::DhcpParseOptionParams(CDhcpOptions* param, const BYTE* buf, UINT buflen, BYTE* overload)
{
ICHECK(IP, UDPC|SDPC);
while (buflen) {
UINT tag, len;
// Stop after seeing the 'end' option
if ((tag = buf[0]) == DHCPOPT_END) break;
// Skip the 'pad' option
if (tag == DHCPOPT_PAD) {
buf++; buflen--;
continue;
}
// Is the option length field valid?
if (buflen < 2 || buflen-2 < (len = buf[1])) goto exit;
buf += 2; buflen -= 2;
// Interpret option data
switch (tag) {
case DHCPOPT_DHCP_MESSAGE_TYPE:
if (len != 1) goto exit;
if (param->_recvMsgType == 0)
param->_recvMsgType = *buf;
break;
case DHCPOPT_SERVERID:
EXTRACT_IPADDR_OPTION(param->_dhcpServer);
break;
case DHCPOPT_SUBNET_MASK:
EXTRACT_IPADDR_OPTION(param->_dhcpmask);
break;
case DHCPOPT_ROUTERS:
case DHCPOPT_DNS_SERVERS:
{
UINT* pcount;
CIpAddr* parray;
UINT n;
if (len == 0 || len % sizeof(CIpAddr) != 0) goto exit;
if (tag == DHCPOPT_ROUTERS)
{
pcount = &param->_gatewayCount;
parray = param->_gateways;
n = MAX_DEFAULT_GATEWAYS * sizeof(CIpAddr);
}
else
{
pcount = &param->_dnsServerCount;
parray = param->_dnsServers;
n = MAX_DEFAULT_DNSSERVERS * sizeof(CIpAddr);
}
if (n > len) n = len;
if (*pcount == 0) {
*pcount = n / sizeof(CIpAddr);
memcpy(parray, buf, n);
}
break;
}
case DHCPOPT_IPADDR_LEASE_TIME:
EXTRACT_DWORD_OPTION(param->_exptime);
break;
case DHCPOPT_T1_INTERVAL:
EXTRACT_DWORD_OPTION(param->_t1time);
break;
case DHCPOPT_T2_INTERVAL:
EXTRACT_DWORD_OPTION(param->_t2time);
break;
case DHCPOPT_FIELD_OVERLOAD:
if (len != 1) goto exit;
if (overload && *overload == 0) *overload = *buf;
break;
}
buf += len; buflen -= len;
}
return NETERR_OK;
exit:
TraceSz(Warning, "Invalid option data");
return NETERR_PARAM;
}
void CXnIp::DhcpSelectAutonetAddr()
{
ICHECK(IP, UDPC|SDPC);
CIpAddr addr;
Assert(_state == STATE_SELECT_AUTOADDR);
if (++_initRetryCount > cfgAutoIpMaxAttempts) {
//
// We tried too many autonet addresses without success.
// Just give up.
//
_initRetryCount = 0;
DhcpChangeState(STATE_NONE);
// Signal that Xnet initialization was completed abnormally
_flags = (_flags & ~FLAG_ACTIVE_ADDRMASK) | FLAG_ACTIVE_NOADDR;
TraceSz(Warning, "Failed to pick an autonet address.");
return;
}
// Generate a random autonet address
addr = AUTONET_ADDRBASE + RandScaled(AUTONET_ADDRRANGE);
_autonetaddr = addr = HTONL(addr);
TraceSz1(dhcp, "Trying autonet address: %s", addr.Str());
EnetXmitArp(addr);
_retries = 0;
DhcpComputeTimeout();
}
#if DBG
DefineTag(dhcpDump, 0);
//
// Whether to dump incoming and outgoing DHCP messages
//
VOID DhcpDumpByteArray(const BYTE* buf, UINT buflen)
/*++
Routine Description:
Dump a byte array in hexdecimal format
Arguments:
buf - Points to the data buffer
buflen - Buffer length
Return Value:
NONE
--*/
{
for ( ; buflen--; buf++) {
TraceSz1(dhcpDump, "+%02x+", *buf);
}
}
VOID DhcpDumpOption(IN const BYTE* buf, IN UINT buflen, OUT BYTE* overload)
/*++
Routine Description:
Dump DHCP options
Arguments:
buf - Points to the option data buffer
buflen - Data buffer length
overload - Returns the option overload flags
Return Value:
NONE
--*/
{
static PCSTR dhcpMessageTypeStrs[] = {
"***",
"DHCPDISCOVER",
"DHCPOFFER",
"DHCPREQUEST",
"DHCPDECLINE",
"DHCPACK",
"DHCPNAK",
"DHCPRELEASE",
"DHCPINFORM"
};
UINT tag, len, val;
while (buflen && *buf != DHCPOPT_END) {
// Special case for DHCPOPT_PAD - single byte
if (*buf == DHCPOPT_PAD) {
TraceSz(dhcpDump, "+ PAD");
buflen--, buf++;
continue;
}
// Check option length
if (buflen < 2 || buflen-2 < (len = buf[1])) goto badopt;
switch (tag = buf[0]) {
case DHCPOPT_DHCP_MESSAGE_TYPE:
if (len != 1) goto badopt;
val = buf[2];
if (val > 0 && val < dimensionof(dhcpMessageTypeStrs)) {
TraceSz1(dhcpDump, "+ %s+", dhcpMessageTypeStrs[val]);
} else {
TraceSz1(dhcpDump, "+ Unknown DHCP message type: %d+", val);
}
break;
case DHCPOPT_FIELD_OVERLOAD:
if (len != 1) goto badopt;
TraceSz1(dhcpDump, "+ OVERLOAD: %d+", buf[2]);
if (overload)
*overload = buf[2];
else
TraceSz(dhcpDump, "+ !!!+");
break;
case DHCPOPT_REQUESTED_CIpAddr:
case DHCPOPT_SERVERID:
if (len != 4) goto badopt;
TraceSz5(dhcpDump, "+ %s %d.%d.%d.%d+",
(tag == DHCPOPT_SERVERID) ? "SERVERID" : "REQUEST IP ADDR",
buf[2], buf[3], buf[4], buf[5]);
break;
default:
TraceSz1(dhcpDump, "+ %d - +", tag);
DhcpDumpByteArray(buf+2, len);
break;
}
TraceSz(dhcpDump, "+ ");
buf += len+2;
buflen -= len+2;
}
if (buflen == 0) {
TraceSz(dhcpDump, "!!! Missing 'end' option");
} else {
do {
buflen--, buf++;
} while (buflen && *buf == 0);
if (buflen != 0)
{
TraceSz(dhcpDump, "!!! Extra data after 'end' option");
}
}
return;
badopt:
TraceSz(dhcpDump, "!!! Bad DHCP option data");
}
void DhcpDumpMessage(DhcpMessage* msg, UINT msglen)
/*++
Routine Description:
Dump the content of a DHCP message
Arguments:
msg - Points to the DHCP message
msglen - Message length
Return Value:
NONE
--*/
{
const BYTE* option;
BYTE overload = 0;
if (!Tag(dhcpDump))
return;
//
// Sanity check
//
if (msglen < DHCPHDRLEN) {
TraceSz1(dhcpDump, "!!! DHCP message too small: %d bytes", msglen);
return;
}
//
// Dump out fixed header information
//
TraceSz(dhcpDump, "DHCP message: ");
if (msg->_op == BOOTREQUEST)
TraceSz(dhcpDump, "BOOTREQUEST");
else if (msg->_op == BOOTREPLY)
TraceSz(dhcpDump, "BOOTREPLY");
else
TraceSz1(dhcpDump, "%d", msg->_op);
TraceSz1(dhcpDump, " htype: %d", msg->_htype);
if (msg->_hlen > sizeof(msg->_chaddr)) {
TraceSz1(dhcpDump, "!!! Invalid hardware address length: %d\n", msg->_hlen);
} else if (msg->_hlen) {
TraceSz(dhcpDump, " chaddr: +");
DhcpDumpByteArray(msg->_chaddr, msg->_hlen);
TraceSz(dhcpDump, "+ ");
}
TraceSz1(dhcpDump, " hops: %d", msg->_hops);
TraceSz1(dhcpDump, " xid: 0x%08x", NTOHL(msg->_xid));
TraceSz1(dhcpDump, " secs: %d", NTOHS(msg->_secs));
TraceSz1(dhcpDump, " flags: 0x%04x", NTOHS(msg->_flags));
TraceSz1(dhcpDump, " ciaddr: %s", msg->_ciaddr.Str());
TraceSz1(dhcpDump, " yiaddr: %s", msg->_yiaddr.Str());
TraceSz1(dhcpDump, " siaddr: %s", msg->_siaddr.Str());
TraceSz1(dhcpDump, " giaddr: %s", msg->_giaddr.Str());
//
// Dump options
//
option = msg->_options;
msglen -= DHCPHDRLEN;
if (msglen < sizeof(DhcpMagicCookie) ||
memcmp(option, DhcpMagicCookie, sizeof(DhcpMagicCookie)) != 0) {
TraceSz(dhcpDump, "!!! Invalid DHCP magic cookie");
return;
}
msglen -= sizeof(DhcpMagicCookie);
option += sizeof(DhcpMagicCookie);
TraceSz(dhcpDump, " options:");
DhcpDumpOption(option, msglen, &overload);
if (overload & 1) {
TraceSz(dhcpDump, " overload options (file):");
DhcpDumpOption(msg->_file, sizeof(msg->_file), NULL);
}
if (overload & 2) {
TraceSz(dhcpDump, " overload options (sname):");
DhcpDumpOption(msg->_sname, sizeof(msg->_sname), NULL);
}
}
#endif // DBG
void CXnIp::IpRecvArp(CEnetAddr * pea)
{
ICHECK(IP, UDPC|SDPC);
DhcpNotifyAddressConflict();
}
#endif // XNET_FEATURE_DHCP
Reference in New Issue Copy Permalink