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."); } } }