|
|
/*++
Copyright (c) 1998, Microsoft Corporation
Module Name:
dhcpmsg.c
Abstract:
This module contains declarations related to the DHCP allocator's message-processing.
Author:
Abolade Gbadegesin (aboladeg) 6-Mar-1998
Revision History:
Raghu Gatta (rgatta) 15-Dec-2000 + Changed manner in which the option DHCP_TAG_DOMAIN_NAME is added in DhcpBuildReplyMessage(). + Inform DNS component via DnsUpdate() in DhcpProcessRequestMessage().
Raghu Gatta (rgatta) 20-Apr-2001 + IP/1394 support changes
--*/
#include "precomp.h"
#pragma hdrstop
//
// EXTERNAL DECLARATIONS
//
extern PIP_DNS_PROXY_GLOBAL_INFO DnsGlobalInfo;extern PWCHAR DnsICSDomainSuffix;extern CRITICAL_SECTION DnsGlobalInfoLock;
//
// FORWARD DECLARATIONS
//
VOIDDhcpAppendOptionToMessage( DHCP_OPTION UNALIGNED** Optionp, UCHAR Tag, UCHAR Length, UCHAR Option[] );
VOIDDhcpBuildReplyMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED** Option, UCHAR MessageType, BOOLEAN DynamicDns, DHCP_OPTION UNALIGNED* OptionArray[] );
ULONGDhcpExtractOptionsFromMessage( PDHCP_HEADER Headerp, ULONG MessageSize, DHCP_OPTION UNALIGNED* OptionArray[] );
VOIDDnsUpdate( CHAR *pszName, ULONG len, ULONG ulAddress );
VOIDDhcpAppendOptionToMessage( DHCP_OPTION UNALIGNED** Optionp, UCHAR Tag, UCHAR Length, UCHAR Option[] )/*++
Routine Description:
This routine is invoked to append an option to a DHCP message.
Arguments:
Optionp - on input, the point at which to append the option; on output, the point at which to append the next option.
Tag - the option tag
Length - the option length
Option - the option's data
Return Value:
none.
--*/
{ PROFILE("DhcpAppendOptionToMessage");
(*Optionp)->Tag = Tag;
if (!Length) { *Optionp = (DHCP_OPTION UNALIGNED *)((PUCHAR)*Optionp + 1); } else { (*Optionp)->Length = Length; CopyMemory((*Optionp)->Option, Option, Length); *Optionp = (DHCP_OPTION UNALIGNED *)((PUCHAR)*Optionp + Length + 2); }
} // DhcpAppendOptionToMessage
VOIDDhcpBuildReplyMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED** Option, UCHAR MessageType, BOOLEAN DynamicDns, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is called to construct the options portion of a reply message.
Arguments:
Interfacep - the interface on which the reply will be sent
Bufferp - the buffer containing the reply
Option - the start of the options portion on input; on output, the end of the message
MessageType - the type of message to be sent
DynamicDns - indicates whether to include the 'dynamic-dns' option.
OptionArray - options extracted from message
Return Value:
none.
Environment:
Invoked with 'Interfacep' referenced by the caller.
--*/
{ ULONG Address; ULONG SubnetMask; ULONG i;
//
// Obtain the address and mask for the endpoint
//
Address = NhQueryAddressSocket(Bufferp->Socket); SubnetMask = PtrToUlong(Bufferp->Context2);
if (MessageType == DHCP_MESSAGE_BOOTP) { ((PDHCP_HEADER)Bufferp->Buffer)->BootstrapServerAddress = Address; } else {
//
// Always begin with the 'message-type' option.
//
DhcpAppendOptionToMessage( Option, DHCP_TAG_MESSAGE_TYPE, 1, &MessageType );
//
// Provide our address as the server-identifier
//
DhcpAppendOptionToMessage( Option, DHCP_TAG_SERVER_IDENTIFIER, 4, (PUCHAR)&Address ); }
if (MessageType != DHCP_MESSAGE_NAK) {
PCHAR DomainName; ULONG dnSize; ULONG LeaseTime; UCHAR NbtNodeType = DHCP_NBT_NODE_TYPE_M; ULONG RebindingTime; ULONG RenewalTime;
EnterCriticalSection(&DhcpGlobalInfoLock); LeaseTime = DhcpGlobalInfo->LeaseTime * 60; LeaveCriticalSection(&DhcpGlobalInfoLock); RebindingTime = (LeaseTime * 3) / 4; RenewalTime = LeaseTime / 2; if (RenewalTime > DHCP_MAXIMUM_RENEWAL_TIME) { RenewalTime = DHCP_MAXIMUM_RENEWAL_TIME; }
LeaseTime = htonl(LeaseTime); RebindingTime = htonl(RebindingTime); RenewalTime = htonl(RenewalTime);
DhcpAppendOptionToMessage( Option, DHCP_TAG_SUBNET_MASK, 4, (PUCHAR)&SubnetMask );
DhcpAppendOptionToMessage( Option, DHCP_TAG_ROUTER, 4, (PUCHAR)&Address );
////
//// RFC 2132 9.14 : server treats client identifier as an opaque object
//// append the client identifier if present in received message
////
//if (OptionArray[DhcpOptionClientIdentifier])
//{
// DhcpAppendOptionToMessage(
// Option,
// DHCP_TAG_CLIENT_IDENTIFIER,
// OptionArray[DhcpOptionClientIdentifier]->Length,
// (PUCHAR)OptionArray[DhcpOptionClientIdentifier]->Option
// );
//}
if (MessageType != DHCP_MESSAGE_BOOTP) {
//specify the DNS server in the message if DNS proxy is enabled
//or DNS server is running on local host
if (NhIsDnsProxyEnabled() || !NoLocalDns) { DhcpAppendOptionToMessage( Option, DHCP_TAG_DNS_SERVER, 4, (PUCHAR)&Address ); } if (NhIsWinsProxyEnabled()) { DhcpAppendOptionToMessage( Option, DHCP_TAG_WINS_SERVER, 4, (PUCHAR)&Address ); } DhcpAppendOptionToMessage( Option, DHCP_TAG_RENEWAL_TIME, 4, (PUCHAR)&RenewalTime ); DhcpAppendOptionToMessage( Option, DHCP_TAG_REBINDING_TIME, 4, (PUCHAR)&RebindingTime ); DhcpAppendOptionToMessage( Option, DHCP_TAG_LEASE_TIME, 4, (PUCHAR)&LeaseTime ); DhcpAppendOptionToMessage( Option, DHCP_TAG_NBT_NODE_TYPE, 1, &NbtNodeType ); if (DynamicDns) { UCHAR DynamicDns[3] = { 0x03, 0, 0 }; DhcpAppendOptionToMessage( Option, DHCP_TAG_DYNAMIC_DNS, sizeof(DynamicDns), DynamicDns ); }
//if (NhpStopDnsEvent && DnsICSDomainSuffix)
if (DnsGlobalInfo && DnsICSDomainSuffix) { EnterCriticalSection(&DnsGlobalInfoLock); dnSize = wcstombs(NULL, DnsICSDomainSuffix, 0); DomainName = reinterpret_cast<PCHAR>(NH_ALLOCATE(dnSize + 1)); if (DomainName) { wcstombs(DomainName, DnsICSDomainSuffix, (dnSize + 1)); }
LeaveCriticalSection(&DnsGlobalInfoLock); } else //
// at this point we have no DNS enabled
// so we default to old behaviour
//
{ DomainName = NhQuerySharedConnectionDomainName(); }
if (DomainName) { //
// We include the terminating nul in the domain name
// even though the RFC says we should not, because
// the DHCP server does so.
//
DhcpAppendOptionToMessage( Option, DHCP_TAG_DOMAIN_NAME, (UCHAR)(lstrlenA(DomainName) + 1), (PUCHAR)DomainName ); NH_FREE(DomainName); }
} }
DhcpAppendOptionToMessage( Option, DHCP_TAG_END, 0, NULL );
} // DhcpBuildReplyMessage
ULONGDhcpExtractOptionsFromMessage( PDHCP_HEADER Headerp, ULONG MessageSize, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is invoked to parse the options contained in a DHCP message. Pointers to each option are stored in the given option array.
Arguments:
Headerp - the header of the DHCP message to be parsed
MessageSize - the size of the message to be parsed
OptionArray - receives the parsed options
Return Value:
ULONG - Win32 status code.
--*/
{ DHCP_OPTION UNALIGNED* Index; DHCP_OPTION UNALIGNED* End;
PROFILE("DhcpExtractOptionsFromMessage");
//
// Initialize the option array to be empty
//
ZeroMemory(OptionArray, DhcpOptionCount * sizeof(PDHCP_OPTION));
//
// Check that the message is large enough to hold options
//
if (MessageSize < sizeof(DHCP_HEADER)) { NhTrace( TRACE_FLAG_DHCP, "DhcpExtractOptionsFromMessage: message size %d too small", MessageSize ); NhWarningLog( IP_AUTO_DHCP_LOG_MESSAGE_TOO_SMALL, 0, "" ); return ERROR_INVALID_DATA; }
//
// Ensure that the magic cookie is present; if not, there are no options.
//
if (MessageSize < (sizeof(DHCP_HEADER) + sizeof(DHCP_FOOTER)) || *(ULONG UNALIGNED*)Headerp->Footer[0].Cookie != DHCP_MAGIC_COOKIE) { return NO_ERROR; }
//
// Parse the message's options, if any
//
End = (PDHCP_OPTION)((PUCHAR)Headerp + MessageSize);
Index = (PDHCP_OPTION)&Headerp->Footer[1]; while (Index < End && Index->Tag != DHCP_TAG_END) {
if ((DHCP_TAG_PAD != Index->Tag) && (End < (PDHCP_OPTION)(Index->Option + Index->Length))) { NhTrace( TRACE_FLAG_DHCP, "DhcpExtractOptionsFromMessage: option truncated at %d bytes", MessageSize ); NhWarningLog( IP_AUTO_DHCP_LOG_INVALID_FORMAT, 0, "" ); return ERROR_INVALID_DATA; }
switch (Index->Tag) { case DHCP_TAG_PAD: NhTrace(TRACE_FLAG_DHCP, "Pad"); break; case DHCP_TAG_CLIENT_IDENTIFIER: NhTrace(TRACE_FLAG_DHCP, "ClientIdentifier"); OptionArray[DhcpOptionClientIdentifier] = Index; break; case DHCP_TAG_MESSAGE_TYPE: NhTrace(TRACE_FLAG_DHCP, "MessageType"); if (Index->Length < 1) { break; } OptionArray[DhcpOptionMessageType] = Index; break; case DHCP_TAG_REQUESTED_ADDRESS: NhTrace(TRACE_FLAG_DHCP, "RequestedAddress"); if (Index->Length < 4) { break; } OptionArray[DhcpOptionRequestedAddress] = Index; break; case DHCP_TAG_PARAMETER_REQUEST_LIST: NhTrace(TRACE_FLAG_DHCP, "ParameterRequestList"); if (Index->Length < 1) { break; } OptionArray[DhcpOptionParameterRequestList] = Index; break; case DHCP_TAG_ERROR_MESSAGE: NhTrace(TRACE_FLAG_DHCP, "ErrorMessage"); if (Index->Length < 1) { break; } OptionArray[DhcpOptionErrorMessage] = Index; break; case DHCP_TAG_DYNAMIC_DNS: NhTrace(TRACE_FLAG_DHCP, "DynamicDns"); if (Index->Length < 1) { break; } OptionArray[DhcpOptionDynamicDns] = Index; break; case DHCP_TAG_HOST_NAME: NhTrace(TRACE_FLAG_DHCP, "HostName"); if (Index->Length < 1) { break; } OptionArray[DhcpOptionHostName] = Index; break; }
if (DHCP_TAG_PAD != Index->Tag) { Index = (PDHCP_OPTION)(Index->Option + Index->Length); } else { Index = (PDHCP_OPTION)((PUCHAR)Index + 1); } }
if (Index->Tag != DHCP_TAG_END) { NhTrace( TRACE_FLAG_DHCP, "DhcpExtractOptionsFromMessage: message truncated to %d bytes", MessageSize ); NhWarningLog( IP_AUTO_DHCP_LOG_INVALID_FORMAT, 0, "" ); return ERROR_INVALID_DATA; }
return NO_ERROR;
} // DhcpExtractOptionsFromMessage
VOIDDhcpProcessBootpMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is called to process a received BOOTP message.
Arguments:
Interfacep - the interface on which the message was received
Bufferp - the buffer containing the message
OptionArray - options extracted from the message
Return Value:
none.
Environment:
Invoked with 'Interfacep' referenced by the caller.
--*/
{ ULONG AssignedAddress; ULONG Error; UCHAR ExistingAddress[MAX_HARDWARE_ADDRESS_LENGTH]; ULONG ExistingAddressLength; PDHCP_HEADER Headerp; ULONG MessageLength; PDHCP_HEADER Offerp; DHCP_OPTION UNALIGNED* Option; ULONG ReplyAddress; USHORT ReplyPort; PNH_BUFFER Replyp; ULONG ScopeNetwork; ULONG ScopeMask; BOOLEAN bIsLocal = FALSE;
PROFILE("DhcpProcessBootpMessage");
ZeroMemory(ExistingAddress, sizeof(ExistingAddress));
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
if (!Headerp->ClientAddress) { AssignedAddress = 0; } else { //
// Validate the address requested by the client
//
AssignedAddress = Headerp->ClientAddress; EnterCriticalSection(&DhcpGlobalInfoLock); ScopeNetwork = DhcpGlobalInfo->ScopeNetwork; ScopeMask = DhcpGlobalInfo->ScopeMask; LeaveCriticalSection(&DhcpGlobalInfoLock);
if ((AssignedAddress & ~ScopeMask) == 0 || (AssignedAddress & ~ScopeMask) == ~ScopeMask || (AssignedAddress & ScopeMask) != (ScopeNetwork & ScopeMask)) {
//
// The client is on the wrong subnet, or has an all-zeros
// or all-ones address on the subnet.
// Select a different address for the client.
//
AssignedAddress = 0; } else if (!DhcpIsUniqueAddress( AssignedAddress, &bIsLocal, ExistingAddress, &ExistingAddressLength ) && (bIsLocal || ((Headerp->HardwareAddressType != 7 && // due to WinXP Bridge bug + WinME Client bug
Headerp->HardwareAddressLength) && // if address length is zero we wont compare
(ExistingAddressLength < Headerp->HardwareAddressLength || memcmp( ExistingAddress, Headerp->HardwareAddress, Headerp->HardwareAddressLength ))))) {
//
// Someone has the requested address, and it's not the requestor.
//
AssignedAddress = 0;
} else if (DhcpIsReservedAddress(AssignedAddress, NULL, 0)) {
//
// The address is reserved for someone else.
//
AssignedAddress = 0; } }
if (!AssignedAddress && !(AssignedAddress = DhcpAcquireUniqueAddress( NULL, 0, Headerp->HardwareAddress, Headerp->HardwareAddressLength ))) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessBootpMessage: address-allocation failed" ); return; }
//
// Acquire a buffer for the reply we will send back
//
Replyp = NhAcquireBuffer();
if (!Replyp) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessBootpMessage: buffer-allocation failed" ); NhErrorLog( IP_AUTO_DHCP_LOG_ALLOCATION_FAILED, 0, "%d", sizeof(NH_BUFFER) ); return; }
//
// Pick up fields from the original buffer;
// the routines setting up the reply will attempt to read these,
// so they are set to the values from the original buffer.
//
Replyp->Socket = Bufferp->Socket; Replyp->ReadAddress = Bufferp->ReadAddress; Replyp->WriteAddress = Bufferp->WriteAddress; Replyp->Context = Bufferp->Context; Replyp->Context2 = Bufferp->Context2;
Offerp = (PDHCP_HEADER)Replyp->Buffer;
//
// Copy the original header
//
*Offerp = *Headerp;
//
// Set up the offer-header fields
//
Offerp->Operation = BOOTP_OPERATION_REPLY; Offerp->AssignedAddress = AssignedAddress; Offerp->ServerHostName[0] = 0; Offerp->BootFile[0] = 0; Offerp->SecondsSinceBoot = 0; *(ULONG UNALIGNED *)Offerp->Footer[0].Cookie = DHCP_MAGIC_COOKIE;
//
// Fill in options
//
Option = (PDHCP_OPTION)&Offerp->Footer[1];
DhcpBuildReplyMessage( Interfacep, Replyp, &Option, DHCP_MESSAGE_BOOTP, FALSE, OptionArray );
//
// Send the offer to the BOOTP client
//
EnterCriticalSection(&DhcpInterfaceLock); if (!DHCP_REFERENCE_INTERFACE(Interfacep)) { LeaveCriticalSection(&DhcpInterfaceLock); NhReleaseBuffer(Replyp); } else {
LeaveCriticalSection(&DhcpInterfaceLock);
if (Headerp->RelayAgentAddress) { ReplyAddress = Headerp->RelayAgentAddress; ReplyPort = DHCP_PORT_SERVER; } else { ReplyAddress = INADDR_BROADCAST; ReplyPort = DHCP_PORT_CLIENT; }
MessageLength = (ULONG)((PUCHAR)Option - Replyp->Buffer); if (MessageLength < sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH) { MessageLength = sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH; } Error = NhWriteDatagramSocket( &DhcpComponentReference, Bufferp->Socket, ReplyAddress, ReplyPort, Replyp, MessageLength, DhcpWriteCompletionRoutine, Interfacep, Bufferp->Context2 );
if (!Error) { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.BootpOffersSent) ); } else { DHCP_DEREFERENCE_INTERFACE(Interfacep); NhReleaseBuffer(Replyp); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessBootpMessage: error %d sending reply", Error ); NhErrorLog( IP_AUTO_DHCP_LOG_REPLY_FAILED, Error, "%I", NhQueryAddressSocket(Bufferp->Socket) ); } }
} // DhcpProcessBootpMessage
VOIDDhcpProcessDiscoverMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is called to process a received DHCPDISCOVER message.
Arguments:
Interfacep - the interface on which the discover was received
Bufferp - the buffer containing the message
OptionArray - options extracted from the message
Return Value:
none.
Environment:
Invoked with 'Interfacep' referenced by the caller.
--*/
{ ULONG AssignedAddress; ULONG Error; UCHAR ExistingAddress[MAX_HARDWARE_ADDRESS_LENGTH]; ULONG ExistingAddressLength; PDHCP_HEADER Headerp; ULONG MessageLength; PDHCP_HEADER Offerp; DHCP_OPTION UNALIGNED* Option; ULONG ReplyAddress; USHORT ReplyPort; PNH_BUFFER Replyp; ULONG ScopeNetwork; ULONG ScopeMask; BOOLEAN bIsLocal = FALSE;
PROFILE("DhcpProcessDiscoverMessage");
ZeroMemory(ExistingAddress, sizeof(ExistingAddress));
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
//
// See if the client is renewing or requesting
//
if (!OptionArray[DhcpOptionRequestedAddress]) {
AssignedAddress = 0; } else {
//
// Validate the address requested by the client
//
AssignedAddress = *(ULONG UNALIGNED*)OptionArray[DhcpOptionRequestedAddress]->Option; EnterCriticalSection(&DhcpGlobalInfoLock); ScopeNetwork = DhcpGlobalInfo->ScopeNetwork; ScopeMask = DhcpGlobalInfo->ScopeMask; LeaveCriticalSection(&DhcpGlobalInfoLock);
if ((AssignedAddress & ~ScopeMask) == 0 || (AssignedAddress & ~ScopeMask) == ~ScopeMask || (AssignedAddress & ScopeMask) != (ScopeNetwork & ScopeMask)) {
//
// The client is on the wrong subnet, or has an all-zeroes
// or all-ones address on the subnet.
// Select a different address for the client.
//
AssignedAddress = 0; } else if (!DhcpIsUniqueAddress( AssignedAddress, &bIsLocal, ExistingAddress, &ExistingAddressLength ) && (bIsLocal || ((Headerp->HardwareAddressType != 7 && // due to WinXP Bridge bug + WinME Client bug
Headerp->HardwareAddressLength) && // if address length is zero we wont compare
(ExistingAddressLength < Headerp->HardwareAddressLength || memcmp( ExistingAddress, Headerp->HardwareAddress, Headerp->HardwareAddressLength ))))) {
//
// Someone has the requested address, and it's not the requestor.
//
AssignedAddress = 0; } else if (OptionArray[DhcpOptionHostName]) { if (DhcpIsReservedAddress( AssignedAddress, reinterpret_cast<PCHAR>( OptionArray[DhcpOptionHostName]->Option ), OptionArray[DhcpOptionHostName]->Length )) {
//
// The address is reserved for someone else,
// or the client has a different address reserved.
//
AssignedAddress = 0; } } else if (DhcpIsReservedAddress(AssignedAddress, NULL, 0)) {
//
// The address is reserved for someone else.
//
AssignedAddress = 0; } }
//
// Generate an address for the client if necessary
//
if (!AssignedAddress) { if (!OptionArray[DhcpOptionHostName]) { AssignedAddress = DhcpAcquireUniqueAddress( NULL, 0, Headerp->HardwareAddress, Headerp->HardwareAddressLength ); } else { AssignedAddress = DhcpAcquireUniqueAddress( reinterpret_cast<PCHAR>( OptionArray[DhcpOptionHostName]->Option ), OptionArray[DhcpOptionHostName]->Length, Headerp->HardwareAddress, Headerp->HardwareAddressLength ); } if (!AssignedAddress) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessDiscoverMessage: address-allocation failed" ); return; } }
//
// Acquire a buffer for the offer we will send back
//
Replyp = NhAcquireBuffer();
if (!Replyp) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessDiscoverMessage: buffer-allocation failed" ); NhErrorLog( IP_AUTO_DHCP_LOG_ALLOCATION_FAILED, 0, "%d", sizeof(NH_BUFFER) ); return; }
//
// Pick up fields from the original message
// the routines setting up the reply will attempt to read these,
// so they are set to the values from the original buffer.
//
Replyp->Socket = Bufferp->Socket; Replyp->ReadAddress = Bufferp->ReadAddress; Replyp->WriteAddress = Bufferp->WriteAddress; Replyp->Context = Bufferp->Context; Replyp->Context2 = Bufferp->Context2;
Offerp = (PDHCP_HEADER)Replyp->Buffer;
//
// Copy the original discover header
//
*Offerp = *Headerp;
//
// IP/1394 support (RFC 2855)
//
if ((IP1394_HTYPE == Offerp->HardwareAddressType) && (0 == Offerp->HardwareAddressLength)) { //
// MUST set client hardware address to zero
//
ZeroMemory(Offerp->HardwareAddress, sizeof(Offerp->HardwareAddress)); }
//
// Set up the offer-header fieldds
//
Offerp->Operation = BOOTP_OPERATION_REPLY; Offerp->AssignedAddress = AssignedAddress; Offerp->ServerHostName[0] = 0; Offerp->BootFile[0] = 0; Offerp->SecondsSinceBoot = 0; *(ULONG UNALIGNED *)Offerp->Footer[0].Cookie = DHCP_MAGIC_COOKIE;
//
// Fill in options
//
Option = (PDHCP_OPTION)&Offerp->Footer[1];
DhcpBuildReplyMessage( Interfacep, Replyp, &Option, DHCP_MESSAGE_OFFER, (BOOLEAN)(OptionArray[DhcpOptionDynamicDns] ? TRUE : FALSE), OptionArray );
//
// Send the offer to the client
//
EnterCriticalSection(&DhcpInterfaceLock); if (!DHCP_REFERENCE_INTERFACE(Interfacep)) { LeaveCriticalSection(&DhcpInterfaceLock); NhReleaseBuffer(Replyp); } else {
LeaveCriticalSection(&DhcpInterfaceLock);
if (Headerp->RelayAgentAddress) { ReplyAddress = Headerp->RelayAgentAddress; ReplyPort = DHCP_PORT_SERVER; } else { ReplyAddress = INADDR_BROADCAST; ReplyPort = DHCP_PORT_CLIENT; } MessageLength = (ULONG)((PUCHAR)Option - Replyp->Buffer); if (MessageLength < sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH) { MessageLength = sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH; } Error = NhWriteDatagramSocket( &DhcpComponentReference, Bufferp->Socket, ReplyAddress, ReplyPort, Replyp, MessageLength, DhcpWriteCompletionRoutine, Interfacep, Bufferp->Context2 );
if (!Error) { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.OffersSent) ); } else { DHCP_DEREFERENCE_INTERFACE(Interfacep); NhReleaseBuffer(Replyp); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessDiscoverMessage: error %d sending reply", Error ); NhErrorLog( IP_AUTO_DHCP_LOG_REPLY_FAILED, Error, "%I", NhQueryAddressSocket(Bufferp->Socket) ); } }
} // DhcpProcessDiscoverMessage
VOIDDhcpProcessInformMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is called to process a received DHCPINFORM message.
Arguments:
Interfacep - the interface on which the inform was received
Bufferp - the buffer containing the message
OptionArray - options extracted from the message
Return Value:
none.
Environment:
Invoked with 'Interfacep' referenced by the caller.
--*/
{ PDHCP_HEADER Ackp; ULONG Error; PDHCP_HEADER Headerp; ULONG MessageLength; DHCP_OPTION UNALIGNED* Option; ULONG ReplyAddress; USHORT ReplyPort; PNH_BUFFER Replyp;
PROFILE("DhcpProcessInformMessage");
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
//
// Acquire a buffer for the ack we will send back
//
Replyp = NhAcquireBuffer();
if (!Replyp) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessInformMessage: buffer-allocation failed" ); NhErrorLog( IP_AUTO_DHCP_LOG_ALLOCATION_FAILED, 0, "%d", sizeof(NH_BUFFER) ); return; }
//
// Pick up fields from the original message
// the routines setting up the reply will attempt to read these,
// so they are set to the values from the original buffer.
//
Replyp->Socket = Bufferp->Socket; Replyp->ReadAddress = Bufferp->ReadAddress; Replyp->WriteAddress = Bufferp->WriteAddress; Replyp->Context = Bufferp->Context; Replyp->Context2 = Bufferp->Context2;
Ackp = (PDHCP_HEADER)Replyp->Buffer;
//
// Copy the original header
//
*Ackp = *Headerp;
//
// IP/1394 support (RFC 2855)
//
if ((IP1394_HTYPE == Ackp->HardwareAddressType) && (0 == Ackp->HardwareAddressLength)) { //
// MUST set client hardware address to zero
//
ZeroMemory(Ackp->HardwareAddress, sizeof(Ackp->HardwareAddress)); } //
// Set up the ack-header fieldds
//
Ackp->Operation = BOOTP_OPERATION_REPLY; Ackp->AssignedAddress = 0; Ackp->ServerHostName[0] = 0; Ackp->BootFile[0] = 0; Ackp->SecondsSinceBoot = 0; *(ULONG UNALIGNED *)Ackp->Footer[0].Cookie = DHCP_MAGIC_COOKIE;
//
// Fill in options
//
Option = (PDHCP_OPTION)&Ackp->Footer[1];
DhcpBuildReplyMessage( Interfacep, Replyp, &Option, DHCP_MESSAGE_ACK, (BOOLEAN)(OptionArray[DhcpOptionDynamicDns] ? TRUE : FALSE), OptionArray );
//
// Send the offer to the client
//
EnterCriticalSection(&DhcpInterfaceLock); if (!DHCP_REFERENCE_INTERFACE(Interfacep)) { LeaveCriticalSection(&DhcpInterfaceLock); NhReleaseBuffer(Replyp); } else {
LeaveCriticalSection(&DhcpInterfaceLock);
if (Headerp->RelayAgentAddress) { ReplyAddress = Headerp->RelayAgentAddress; ReplyPort = DHCP_PORT_SERVER; } else { ReplyAddress = INADDR_BROADCAST; ReplyPort = DHCP_PORT_CLIENT; } MessageLength = (ULONG)((PUCHAR)Option - Replyp->Buffer); if (MessageLength < sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH) { MessageLength = sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH; } Error = NhWriteDatagramSocket( &DhcpComponentReference, Bufferp->Socket, ReplyAddress, ReplyPort, Replyp, MessageLength, DhcpWriteCompletionRoutine, Interfacep, Bufferp->Context2 );
if (!Error) { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.AcksSent) ); } else { DHCP_DEREFERENCE_INTERFACE(Interfacep); NhReleaseBuffer(Replyp); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessInformMessage: error %d sending reply", Error ); NhErrorLog( IP_AUTO_DHCP_LOG_REPLY_FAILED, Error, "%I", NhQueryAddressSocket(Bufferp->Socket) ); } }
} // DhcpProcessInformMessage
VOIDDhcpProcessMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp )
/*++
Routine Description:
This routine is invoked to process a DHCP client message.
Arguments:
Interfacep - the interface on which the request was received
Bufferp - the buffer containing the message received
Return Value:
none.
Environment:
Invoked internally with 'Interfacep' referenced by the caller.
--*/
{ ULONG Error; PDHCP_HEADER Headerp; UCHAR MessageType; PDHCP_OPTION OptionArray[DhcpOptionCount];
PROFILE("DhcpProcessMessage");
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
#if DBG
NhDump( TRACE_FLAG_DHCP, Bufferp->Buffer, Bufferp->BytesTransferred, 1 );#endif
//
// Extract pointers to each option in the message
//
Error = DhcpExtractOptionsFromMessage( Headerp, Bufferp->BytesTransferred, OptionArray );
if (Error) { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.MessagesIgnored) ); } else //
// Look for the message-type;
// This distinguishes BOOTP from DHCP clients.
//
if (!OptionArray[DhcpOptionMessageType]) { DhcpProcessBootpMessage( Interfacep, Bufferp, OptionArray ); } else if (Headerp->HardwareAddressLength <= sizeof(Headerp->HardwareAddress) && DhcpIsLocalHardwareAddress( Headerp->HardwareAddress, Headerp->HardwareAddressLength)) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: ignoring message, from self" ); } else switch(MessageType = OptionArray[DhcpOptionMessageType]->Option[0]) { case DHCP_MESSAGE_DISCOVER: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.DiscoversReceived) ); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: received DISCOVER message" ); DhcpProcessDiscoverMessage( Interfacep, Bufferp, OptionArray ); break; } case DHCP_MESSAGE_REQUEST: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.RequestsReceived) ); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: received REQUEST message" ); DhcpProcessRequestMessage( Interfacep, Bufferp, OptionArray ); break; } case DHCP_MESSAGE_INFORM: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.InformsReceived) ); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: received INFORM message" ); DhcpProcessInformMessage( Interfacep, Bufferp, OptionArray ); break; } case DHCP_MESSAGE_DECLINE: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.DeclinesReceived) ); // log message
NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: received DECLINE message" ); break; } case DHCP_MESSAGE_RELEASE: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.ReleasesReceived) ); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: received RELEASE message" ); break; } default: { InterlockedIncrement( reinterpret_cast<LPLONG>(&DhcpStatistics.MessagesIgnored) ); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: message type %d invalid", MessageType ); NhWarningLog( IP_AUTO_DHCP_LOG_INVALID_DHCP_MESSAGE_TYPE, 0, "%d", MessageType ); break; } }
//
// Post the buffer for another read
//
EnterCriticalSection(&DhcpInterfaceLock); if (!DHCP_REFERENCE_INTERFACE(Interfacep)) { LeaveCriticalSection(&DhcpInterfaceLock); NhReleaseBuffer(Bufferp); } else { LeaveCriticalSection(&DhcpInterfaceLock); Error = NhReadDatagramSocket( &DhcpComponentReference, Bufferp->Socket, Bufferp, DhcpReadCompletionRoutine, Bufferp->Context, Bufferp->Context2 ); if (Error) { ACQUIRE_LOCK(Interfacep); DhcpDeferReadInterface(Interfacep, Bufferp->Socket); RELEASE_LOCK(Interfacep); DHCP_DEREFERENCE_INTERFACE(Interfacep); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessMessage: error %d reposting read", Error ); NhWarningLog( IP_AUTO_DHCP_LOG_RECEIVE_FAILED, Error, "%I", NhQueryAddressSocket(Bufferp->Socket) ); NhReleaseBuffer(Bufferp); } }
} // DhcpProcessMessage
VOIDDhcpProcessRequestMessage( PDHCP_INTERFACE Interfacep, PNH_BUFFER Bufferp, DHCP_OPTION UNALIGNED* OptionArray[] )
/*++
Routine Description:
This routine is called to process a request message.
Arguments:
Interfacep - the interface on which the request was received
Bufferp - the buffer containing the message received
OptionArray - options extracted from the message
Return Value:
none.
Environment:
Invoked internally with 'Interfacep' referenced by the caller.
--*/
{ ULONG AssignedAddress = 0; ULONG Error; UCHAR ExistingAddress[MAX_HARDWARE_ADDRESS_LENGTH]; ULONG ExistingAddressLength; PDHCP_HEADER Headerp; ULONG MessageLength; PDHCP_HEADER Offerp; DHCP_OPTION UNALIGNED* Option; ULONG ReplyAddress; USHORT ReplyPort; PNH_BUFFER Replyp; UCHAR ReplyType = DHCP_MESSAGE_ACK; ULONG ScopeNetwork; ULONG ScopeMask; BOOLEAN bIsLocal = FALSE;
PROFILE("DhcpProcessRequestMessage");
ZeroMemory(ExistingAddress, sizeof(ExistingAddress));
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
//
// Validate the address requested by the client
//
if (!Headerp->ClientAddress && !OptionArray[DhcpOptionRequestedAddress]) {
//
// The client left out the address being requested
//
ReplyType = DHCP_MESSAGE_NAK; } else {
//
// Try to see if the address is in use.
//
AssignedAddress = Headerp->ClientAddress ? Headerp->ClientAddress : *(ULONG UNALIGNED*) OptionArray[DhcpOptionRequestedAddress]->Option; EnterCriticalSection(&DhcpGlobalInfoLock); ScopeNetwork = DhcpGlobalInfo->ScopeNetwork; ScopeMask = DhcpGlobalInfo->ScopeMask; LeaveCriticalSection(&DhcpGlobalInfoLock);
if ((AssignedAddress & ~ScopeMask) == 0 || (AssignedAddress & ~ScopeMask) == ~ScopeMask || (AssignedAddress & ScopeMask) != (ScopeNetwork & ScopeMask)) {
//
// The client is on the wrong subnet, or has an all-ones
// or all-zeroes address.
//
ReplyType = DHCP_MESSAGE_NAK;
} else if (!DhcpIsUniqueAddress( AssignedAddress, &bIsLocal, ExistingAddress, &ExistingAddressLength ) && (bIsLocal || ((Headerp->HardwareAddressType != 7 && // due to WinXP Bridge bug + WinME Client bug
Headerp->HardwareAddressLength) && // if address length is zero we wont compare
(ExistingAddressLength < Headerp->HardwareAddressLength || memcmp( ExistingAddress, Headerp->HardwareAddress, Headerp->HardwareAddressLength ))))) {
//
// Someone has the requested address, and it's not the requestor.
//
ReplyType = DHCP_MESSAGE_NAK;
} else if (OptionArray[DhcpOptionHostName]) { if (DhcpIsReservedAddress( AssignedAddress, reinterpret_cast<PCHAR>( OptionArray[DhcpOptionHostName]->Option ), OptionArray[DhcpOptionHostName]->Length )) {
//
// The address is reserved for someone else,
// or the client has a different address reserved.
//
ReplyType = DHCP_MESSAGE_NAK; } } else if (DhcpIsReservedAddress(AssignedAddress, NULL, 0)) {
//
// The address is reserved for someone else.
//
ReplyType = DHCP_MESSAGE_NAK; } }
//
// Acquire a buffer for the reply we will send back
//
Replyp = NhAcquireBuffer();
if (!Replyp) { NhTrace( TRACE_FLAG_DHCP, "DhcpProcessRequestMessage: buffer-allocation failed" ); NhErrorLog( IP_AUTO_DHCP_LOG_ALLOCATION_FAILED, 0, "%d", sizeof(NH_BUFFER) ); return; }
//
// Pick up fields to be used in the reply-buffer
// the routines setting up the reply will attempt to read these,
// so they are set to the values from the original buffer.
//
Replyp->Socket = Bufferp->Socket; Replyp->ReadAddress = Bufferp->ReadAddress; Replyp->WriteAddress = Bufferp->WriteAddress; Replyp->Context = Bufferp->Context; Replyp->Context2 = Bufferp->Context2;
Offerp = (PDHCP_HEADER)Replyp->Buffer;
//
// Copy the original discover header
//
*Offerp = *Headerp;
//
// IP/1394 support (RFC 2855)
//
if ((IP1394_HTYPE == Offerp->HardwareAddressType) && (0 == Offerp->HardwareAddressLength)) { //
// MUST set client hardware address to zero
//
ZeroMemory(Offerp->HardwareAddress, sizeof(Offerp->HardwareAddress)); }
//
// Set up the offer-header fieldds
//
Offerp->Operation = BOOTP_OPERATION_REPLY; Offerp->AssignedAddress = AssignedAddress; Offerp->ServerHostName[0] = 0; Offerp->BootFile[0] = 0; Offerp->SecondsSinceBoot = 0; *(ULONG UNALIGNED *)Offerp->Footer[0].Cookie = DHCP_MAGIC_COOKIE;
//
// Fill in options
//
Option = (PDHCP_OPTION)&Offerp->Footer[1];
DhcpBuildReplyMessage( Interfacep, Replyp, &Option, ReplyType, (BOOLEAN)(OptionArray[DhcpOptionDynamicDns] ? TRUE : FALSE), OptionArray );
//
// NEW LOGIC HERE => tied to DNS
//
if (DHCP_MESSAGE_ACK == ReplyType) { //
// We perform the equivalent of Dynamic DNS here
// by informing the DNS component that this client exists
//
if (OptionArray[DhcpOptionHostName]) { //
// check if DNS component is active
//
if (REFERENCE_DNS()) { DnsUpdate( reinterpret_cast<PCHAR>(OptionArray[DhcpOptionHostName]->Option), (ULONG) OptionArray[DhcpOptionHostName]->Length, AssignedAddress );
DEREFERENCE_DNS(); } } }
//
// Send the reply to the client
//
EnterCriticalSection(&DhcpInterfaceLock); if (!DHCP_REFERENCE_INTERFACE(Interfacep)) { LeaveCriticalSection(&DhcpInterfaceLock); NhReleaseBuffer(Replyp); } else {
LeaveCriticalSection(&DhcpInterfaceLock);
if (Headerp->RelayAgentAddress) { ReplyAddress = Headerp->RelayAgentAddress; ReplyPort = DHCP_PORT_SERVER; } else { ReplyAddress = INADDR_BROADCAST; ReplyPort = DHCP_PORT_CLIENT; } MessageLength = (ULONG)((PUCHAR)Option - Replyp->Buffer); if (MessageLength < sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH) { MessageLength = sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH; } Error = NhWriteDatagramSocket( &DhcpComponentReference, Bufferp->Socket, ReplyAddress, ReplyPort, Replyp, MessageLength, DhcpWriteCompletionRoutine, Interfacep, Bufferp->Context2 );
if (!Error) { InterlockedIncrement( (ReplyType == DHCP_MESSAGE_ACK) ? reinterpret_cast<LPLONG>(&DhcpStatistics.AcksSent) : reinterpret_cast<LPLONG>(&DhcpStatistics.NaksSent) ); } else { DHCP_DEREFERENCE_INTERFACE(Interfacep); NhReleaseBuffer(Replyp); NhTrace( TRACE_FLAG_DHCP, "DhcpProcessRequestMessage: error %d sending reply", Error ); NhErrorLog( IP_AUTO_DHCP_LOG_REPLY_FAILED, Error, "%I", NhQueryAddressSocket(Bufferp->Socket) ); } }
} // DhcpProcessRequestMessage
ULONGDhcpWriteClientRequestMessage( PDHCP_INTERFACE Interfacep, PDHCP_BINDING Binding )
/*++
Routine Description:
This routine is invoked to check for the existence of a DHCP server on the given interface and address. It generates a BOOTP request on a socket bound to the DHCP client port.
Arguments:
Interfacep - the interface on which the client request is to be sent
Binding - the binding on which the request is to be sent
Return Value:
ULONG - status code.
Environment:
Invoked with 'Interfacep' locked and with a reference made to 'Interfacep' for the send which occurs here. If the routine fails, it is the caller's responsibility to release the reference.
--*/
{ PNH_BUFFER Bufferp; ULONG Error; PDHCP_HEADER Headerp; SOCKET Socket;
PROFILE("DhcpWriteClientRequestMessage");
//
// Create a socket using the given address
//
Error = NhCreateDatagramSocket( Binding->Address, DHCP_PORT_CLIENT, &Binding->ClientSocket );
if (Error) { NhTrace( TRACE_FLAG_IF, "DhcpWriteClientRequestMessage: error %d creating socket for %s", Error, INET_NTOA(Binding->Address) ); NhWarningLog( IP_AUTO_DHCP_LOG_DETECTION_UNAVAILABLE, Error, "%I", Binding->Address ); return Error; }
//
// Allocate a buffer for the BOOTP request
//
Bufferp = NhAcquireBuffer(); if (!Bufferp) { NhDeleteDatagramSocket(Binding->ClientSocket); Binding->ClientSocket = INVALID_SOCKET; NhTrace( TRACE_FLAG_IF, "DhcpWriteClientRequestMessage: error allocating buffer for %s", INET_NTOA(Binding->Address) ); NhErrorLog( IP_AUTO_DHCP_LOG_ALLOCATION_FAILED, 0, "%d", sizeof(NH_BUFFER) ); return ERROR_NOT_ENOUGH_MEMORY; }
//
// Initialize the BOOTP request
//
Headerp = (PDHCP_HEADER)Bufferp->Buffer;
ZeroMemory(Headerp, sizeof(*Headerp));
Headerp->Operation = BOOTP_OPERATION_REQUEST; Headerp->HardwareAddressType = 1; Headerp->HardwareAddressLength = 6; Headerp->TransactionId = DHCP_DETECTION_TRANSACTION_ID; Headerp->SecondsSinceBoot = 10; Headerp->Flags |= BOOTP_FLAG_BROADCAST; Headerp->ClientAddress = Binding->Address; Headerp->HardwareAddress[1] = 0xab; *(PULONG)(Headerp->Footer[0].Cookie) = DHCP_MAGIC_COOKIE; *(PUCHAR)(Headerp->Footer + 1) = DHCP_TAG_END;
//
// Send the BOOTP request on the socket
//
Error = NhWriteDatagramSocket( &DhcpComponentReference, Binding->ClientSocket, INADDR_BROADCAST, DHCP_PORT_SERVER, Bufferp, sizeof(DHCP_HEADER) + BOOTP_VENDOR_LENGTH, DhcpWriteClientRequestCompletionRoutine, (PVOID)Interfacep, UlongToPtr(Binding->Address) );
if (Error) { NhReleaseBuffer(Bufferp); NhDeleteDatagramSocket(Binding->ClientSocket); Binding->ClientSocket = INVALID_SOCKET; NhTrace( TRACE_FLAG_IF, "DhcpWriteClientRequestMessage: error %d writing request for %s", Error, INET_NTOA(Binding->Address) ); NhWarningLog( IP_AUTO_DHCP_LOG_DETECTION_UNAVAILABLE, Error, "%I", Binding->Address ); return Error; }
return NO_ERROR;
} // DhcpWriteClientRequestMessage
|
