private void SendOffer(DhcpMessage message)
{
Trace.TraceInformation("{0} Sending Dhcp Offer.", Thread.CurrentThread.ManagedThreadId);
DhcpMessage response = new DhcpMessage();
response.Operation = DhcpOperation.BootReply;
response.Hardware = HardwareType.Ethernet;
response.HardwareAddressLength = 6;
response.SecondsElapsed = message.SecondsElapsed;
response.SessionId = message.SessionId;
response.Flags = message.Flags;
Byte[] hardwareAddressData = new Byte[6];
Array.Copy(message.ClientHardwareAddress, hardwareAddressData, 6);
PhysicalAddress clientHardwareAddress = new PhysicalAddress(hardwareAddressData);
response.NextServerAddress = this._mDhcpInterfaceAddress.GetAddressBytes();
response.ClientHardwareAddress = message.ClientHardwareAddress;
response.AddOption(DhcpOption.DhcpMessageType, (Byte)DhcpMessageType.Offer);
response.AddOption(DhcpOption.ClassId, Encoding.UTF8.GetBytes("PXEClient"));
Byte[] paramList = message.GetOptionData(DhcpOption.ParameterList);
if (paramList != null)
{
response.OptionOrdering = paramList;
}
response.AddOption(DhcpOption.DhcpAddress, this._mDhcpInterfaceAddress.GetAddressBytes());
try
{
this._mDhcpSocket.SendTo(response.ToArray(), new IPEndPoint(IPAddress.Broadcast, DhcpClientPort));
}
catch (Exception ex)
{
TraceException("Error Sending Dhcp Reply", ex);
return;
}
Trace.TraceInformation("{0} Dhcp Offer Sent.", Thread.CurrentThread.ManagedThreadId);
}
private void CompleteRequest(object state)
{
var messageData = (DhcpData) state;
EndPoint source = new IPEndPoint(0, 0);
_mAbortLock.AcquireReaderLock(-1);
try
{
if (_mAbort)
{
return;
}
messageData.BufferSize = _mDhcpSocket.EndReceiveFrom(messageData.Result, ref source);
messageData.Source = (IPEndPoint) source;
}
catch (SocketException)
{
return;
}
catch (Exception ex)
{
TraceException("Error", ex);
return;
}
finally
{
_mAbortLock.ReleaseLock();
}
DhcpMessage message;
try
{
message = new DhcpMessage(messageData);
}
catch (ArgumentException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (InvalidCastException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (IndexOutOfRangeException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (Exception ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
if (message.Operation == DhcpOperation.BootRequest)
{
var messageVendorIdData = message.GetOptionData(DhcpOption.ClassId);
if (messageVendorIdData != null)
{
var strVendorId = Encoding.Default.GetString(messageVendorIdData);
string bootType = null;
if (strVendorId.Contains("PXEClient"))
bootType = "pxe";
else if (strVendorId.Contains("AAPLBSDPC"))
bootType = "bsdp";
else
{
Trace.TraceInformation("{0} Ignoring, Not A Boot Request",
ByteArrayToString(message.ClientHardwareAddress));
return;
}
if (BsdpMode == "enabled" && bootType == "bsdp")
{
if (strVendorId.Length >= 14)
{
if (strVendorId.Substring(0, 14) == "AAPLBSDPC/i386")
{
var vendorOptions = message.GetOptionData(DhcpOption.VendorSpecificInformation);
if (vendorOptions != null)
{
var strVendorInformation = ByteArrayToString(vendorOptions);
if (strVendorInformation.Length >= 12)
{
if (strVendorInformation.Substring(0, 12) != "010101020201" &&
strVendorInformation.Substring(0, 12) != "010102020201")
{
Trace.TraceInformation(
"{0} Ignoring, Not An Apple BSDP Request, Vendor Information Mismatch",
ByteArrayToString(message.ClientHardwareAddress));
return;
}
}
}
else
{
Trace.TraceInformation("{0} Ignoring, No Vendor Information Data To Parse",
ByteArrayToString(message.ClientHardwareAddress));
return;
}
}
else
{
Trace.TraceInformation("{0} Ignoring, Not An Apple BSDP Request",
ByteArrayToString(message.ClientHardwareAddress));
return;
}
}
}
}
else
{
Trace.TraceInformation("{0} Ignoring, No Vendor ID Data To Parse",
ByteArrayToString(message.ClientHardwareAddress));
return;
}
var messageTypeData = message.GetOptionData(DhcpOption.DhcpMessageType);
if (messageTypeData != null && messageTypeData.Length == 1)
{
var messageType = (DhcpMessageType) messageTypeData[0];
switch (messageType)
{
case DhcpMessageType.Discover:
Trace.TraceInformation("{0} Dhcp DISCOVER Message Received.", Thread.CurrentThread.ManagedThreadId);
this.DhcpDiscover(message);
Trace.TraceInformation("{0} Dhcp DISCOVER Message Processed.", Thread.CurrentThread.ManagedThreadId);
break;
case DhcpMessageType.Inform:
Trace.TraceInformation("{0}, {1} Dhcp Inform Message Received.",
Thread.CurrentThread.ManagedThreadId, ByteArrayToString(message.ClientHardwareAddress));
Bsdp(message);
Trace.TraceInformation("{0} Dhcp Inform Message Processed.",
Thread.CurrentThread.ManagedThreadId);
break;
default:
Trace.TraceWarning("Ignoring ({0}) Message On Port 67.", messageType);
break;
}
}
else
{
Trace.TraceWarning("Unknown Dhcp Data Received, Ignoring.");
}
}
else
{
Trace.TraceInformation("Ignoring, Not a DHCP Boot Request.");
}
}
private void DhcpDiscover(DhcpMessage message)
{
Byte[] addressRequestData = message.GetOptionData(DhcpOption.AddressRequest);
if (addressRequestData == null)
{
addressRequestData = message.ClientAddress;
}
InternetAddress addressRequest = new InternetAddress(addressRequestData);
// Assume we're on an ethernet network
Byte[] hardwareAddressData = new Byte[6];
Array.Copy(message.ClientHardwareAddress, hardwareAddressData, 6);
PhysicalAddress clientHardwareAddress = new PhysicalAddress(hardwareAddressData);
// If this client is explicitly allowed, or they are not denied and the allow any flag is set
if (this._mAcl.ContainsKey(clientHardwareAddress) && this._mAcl[clientHardwareAddress] ||
!this._mAcl.ContainsKey(clientHardwareAddress) && this._mAllowAny)
{
this.SendOffer(message);
}
else
{
this.SendNak(message);
}
}
private void CompleteRequest(Object state)
{
DhcpData messageData = (DhcpData)state;
EndPoint source = new IPEndPoint(0, 0);
this.m_AbortLock.AcquireReaderLock(-1);
try
{
if (this.m_Abort)
{
return;
}
messageData.BufferSize = this.m_DhcpSocket.EndReceiveFrom(messageData.Result, ref source);
messageData.Source = (IPEndPoint)source;
}
catch (SocketException)
{
return;
}
catch (Exception ex)
{
TraceException("Error", ex);
return;
}
finally
{
this.m_AbortLock.ReleaseLock();
}
DhcpMessage message;
try
{
message = new DhcpMessage(messageData);
message.SourcePort = messageData.Source.Port.ToString();
}
catch (ArgumentException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (InvalidCastException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (IndexOutOfRangeException ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
catch (Exception ex)
{
TraceException("Error Parsing Dhcp Message", ex);
return;
}
if (message.Operation == DhcpOperation.BootRequest)
{
Byte[] messageVendorIDData = message.GetOptionData(DhcpOption.ClassId);
if (messageVendorIDData != null)
{
var str = System.Text.Encoding.Default.GetString(messageVendorIDData);
if (!str.Contains("PXEClient"))
return;
else
{
string[] values = str.Split(':');
if (values.Length >= 3)
{
message.ClientArchitecture = values[2];
if(message.ClientArchitecture != "00000" && message.ClientArchitecture != "00006" && message.ClientArchitecture!= "00007" && message.ClientArchitecture!="00009")
return;
}
}
}
else
return;
Byte[] messageTypeData = message.GetOptionData(DhcpOption.DhcpMessageType);
if (messageTypeData != null && messageTypeData.Length == 1)
{
DhcpMessageType messageType = (DhcpMessageType)messageTypeData[0];
switch (messageType)
{
case DhcpMessageType.Request:
Trace.TraceInformation("{0} Dhcp REQUEST Message Received.", Thread.CurrentThread.ManagedThreadId);
this.DhcpRequest(message);
Trace.TraceInformation("{0} Dhcp REQUEST Message Processed.", Thread.CurrentThread.ManagedThreadId);
break;
default:
Trace.TraceWarning("Ignoring ({0}) Message On Port 4011.", messageType.ToString());
break;
}
}
else
{
Trace.TraceWarning("Unknown Dhcp Data Received, Ignoring.");
}
}
}
