ConfigLMM 0.4.0 → 0.5.0

data/lib/ConfigLMM/context.rb

@@ -2,16 +2,21 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative 'secrets/envStore'
+require_relative 'secrets/fileStore'
+
 require 'yaml'
 
 module ConfigLMM
     class Context
         CONTEXT_FILE = 'configlmm/context.yaml'
 
-        def initialize(logger, prompt, xdg, contextFile)
+        def initialize(logger, prompt, xdg, options)
             @Logger = logger
             @Prompt = prompt
-            load!(xdg.config_home, contextFile)
+            contextFile = options[:context]
+            secretsProvider = options[:secrets]
+            load!(xdg.config_home, contextFile, secretsProvider)
         end
 
         def likes?(name)
@@ -30,10 +35,15 @@ module ConfigLMM
             @Context['Dislikes'] += context['Dislikes']
         end
 
+        def secrets
+            @Secrets
+        end
+
         private
 
-        def load!(configHome, contextFile)
+        def load!(configHome, contextFile, secretsProvider)
             @Context = {}
+            @Secrets = Secrets::EnvStore.new(@Logger, @Prompt)
             if (contextFile && !File.exist?(contextFile))
                 @Logger.error("Provided Context file doesn't exist: #{contextFile}")
                 raise 'Missing Context!'
@@ -46,6 +56,15 @@ module ConfigLMM
             end
             @Context['Likes'] ||= []
             @Context['Dislikes'] ||= []
+
+            if secretsProvider && secretsProvider != 'no'
+                url = Addressable::URI.parse(secretsProvider)
+                if url.scheme.nil?
+                    @Secrets = Secrets::FileStore.new(@Logger, @Prompt, url.path)
+                else
+                    raise 'Only file secret provider is implemented!'
+                end
+            end
         end
 
     end

data/lib/ConfigLMM/io/configList.rb

@@ -3,6 +3,7 @@
 require_relative 'path'
 require 'find'
 require 'yaml'
+require 'deep_merge'
 
 module ConfigLMM
     module IO
@@ -12,7 +13,7 @@ module ConfigLMM
             def self.create(targets, logger)
                 targets = targets.uniq.select do |target|
                     exist = File.exist?(target)
-                    logger.warn("'#{path}' doesn't exist, ignoring!") unless exist
+                    logger.warn("'#{target}' doesn't exist, ignoring!") unless exist
                     exist
                 end
                 self.new(targets)
@@ -59,7 +60,7 @@ module ConfigLMM
                     raise ConfigError.new("Missing 'Type' field: #{id}!")
                 end
                 data['Name'] = id unless data.has_key?('Name')
-                data['Type'] = data['Type'].to_sym
+                data['Type'] = data['Type'].to_s.gsub('.', '').to_sym
                 data[:Parent] = parent
                 data
             end
@@ -67,10 +68,12 @@ module ConfigLMM
             def toConfig(context)
                 config = {}
                 @Sources.each do |source|
+                    seenIncludes = Set.new
                     data = YAML.safe_load_file(source.to_s, permitted_classes: [Symbol])
                     next unless data.is_a?(Hash)
+                    data = processIncludes(data, source.to_s, seenIncludes)
+                    data = processVariables(data, source.to_s)
                     data.each do |id, data|
-                        normalizedId = self.class.normalizeId(id)
                         if id == '_CONTEXT_'
                             context.add(data)
                             next
@@ -78,9 +81,12 @@ module ConfigLMM
 
                         self.class.processConfig(id, data, source.parent)
 
-                        # TODO FIXME we should deep merge them instead
-                        raise ConfigError.new("Duplicate ID: #{id} (#{normalizedId}) - #{source}") if config.has_key?(normalizedId)
-                        config[normalizedId] = data
+                        normalizedId = self.class.normalizeId(id)
+                        if config.has_key?(normalizedId)
+                            config[normalizedId].deep_merge!(data, :extend_existing_arrays => true)
+                        else
+                            config[normalizedId] = data
+                        end
                     end
                 #rescue YAML::SyntaxError => error
                 #    raise ConfigError.new(error)
@@ -95,6 +101,76 @@ module ConfigLMM
             def to_a
                 @Sources
             end
+
+            private
+
+            def processIncludes(data, source, seenIncludes)
+                seenIncludes << source
+                includes = data['_INCLUDE_']
+                return data if includes.nil?
+                includes = [includes] unless includes.is_a?(Array)
+                includesData = {}
+                includes.each do |file|
+                    file = file.to_s
+                    file += '.yaml' unless file.end_with?('.yaml')
+                    file = File.expand_path(file, File.dirname(source))
+                    next if seenIncludes.include?(file)
+                    raise ConfigError.new("#{file} doesn't exist! - #{source}") unless File.exist?(file)
+                    innerData = YAML.safe_load_file(file, permitted_classes: [Symbol])
+                    next unless innerData.is_a?(Hash)
+                    innerData = processIncludes(innerData, file, seenIncludes.dup)
+                    includesData.deep_merge!(innerData, :extend_existing_arrays => true)
+                end
+                includesData.deep_merge!(data, :extend_existing_arrays => true)
+                includesData.delete('_INCLUDE_')
+                includesData
+            end
+
+            def processVariables(data, source)
+                variables = data['_VARIABLES_']
+                raise ConfigError.new("_VARIABLES_ must be a hash! - #{source}") if !variables.nil? && !variables.is_a?(Hash)
+                variables = variables.to_h.transform_keys { |key| key.to_s.upcase }
+                data.delete('_VARIABLES_')
+                data.each do |id, content|
+                    data[id] = processContent(content, variables, source)
+                end
+                data
+            end
+
+            def processContent(content, variables, source)
+                if content.is_a?(Array)
+                    content.each_with_index do |item, i|
+                        content[i] = processContent(item, variables, source)
+                    end
+                elsif content.is_a?(Hash)
+                    newContent = {}
+                    content.each do |key, item|
+                        key = processContent(key, variables, source) if key.is_a?(String)
+                        newContent[key] = processContent(item, variables, source)
+                    end
+                    content = newContent
+                else
+                    content = fillVariable(content, variables, source)
+                end
+                content
+            end
+
+            def fillVariable(content, variables, source)
+                variableStart = content.to_s.index('${VAR:')
+                if variableStart
+                    variableEnd = content.index('}', variableStart + 6)
+                    raise "Unterminated variable: #{content}" if variableEnd.nil?
+                    name = content[variableStart + 6...variableEnd].to_s
+                    raise ConfigError.new("Empty variable name #{content} - #{source}") if name.empty?
+                    raise ConfigError.new("Undefined variable #{name} - #{source}") unless variables.key?(name.upcase)
+                    if variableStart.zero? && variableEnd == content.length
+                        content = variables[name.upcase]
+                    else
+                        content = content[0...variableStart].to_s + variables[name.upcase].to_s + fillVariable(content[(variableEnd + 1)..-1].to_s, variables, source).to_s
+                    end
+                end
+                content
+            end
         end
     end
 end

data/lib/ConfigLMM/io/connection.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+require_relative 'local'
+require_relative 'ssh'
+
+module ConfigLMM
+    module IO
+        ConnectionError = Class.new(Framework::PluginProcessError)
+
+        class ExecError < ConnectionError
+            attr_reader :command, :stdout, :stderr, :status
+
+            def initialize(message, command, stdout, stderr, status)
+                super(message)
+                @command = command
+                @stdout = stdout
+                @stderr = stderr
+                @status = status
+            end
+
+            def to_s
+                str = super + "\n"
+                str += stdout.to_s + "\n" if stdout
+                str += stderr.to_s if stdout != stderr
+                str
+            end
+        end
+
+        class Connection
+
+            attr_reader :type
+            attr_reader :tunnel
+            attr_reader :local
+            attr_reader :prompt
+            attr_reader :logger
+
+            def initialize(type, tunnel, prompt, logger)
+                @type = type
+                @tunnel = tunnel
+                @local = Local.new(prompt, logger)
+                @prompt = prompt
+                @logger = logger
+            end
+
+            def rm(path, dry)
+                @tunnel.rm(path, dry)
+            end
+
+            def exec(command, allowFailure = false, options = {})
+                @tunnel.exec(command, allowFailure, options)
+            end
+
+            def adminExec(command, allowFailure = false, options = {})
+                @tunnel.adminExec(command, allowFailure, options)
+            end
+
+            def filePresent?(file, options = {})
+                self.exec("stat #{file}", true, options) if options['dry']
+                result = self.exec("stat #{file}", true, { **options, 'dry' => false })
+                !result.start_with?('stat: cannot')
+            end
+
+            def fileLink?(file, options = {})
+                self.exec("stat #{file}", true, options) if options['dry']
+                result = self.exec("stat #{file}", true, { **options, 'dry' => false })
+                return false if result.start_with?('stat: cannot')
+                result.include?('symbolic link') && !result.include?('regular file')
+            end
+
+            def updateFile(file, options, atTop = false, comment = '#', &block)
+                @tunnel.updateFile(file, options, atTop, comment, &block)
+            end
+
+            def download(source, target, options = {})
+                @tunnel.download(source, target, options)
+            end
+
+            def upload(source, target, options = {})
+                @tunnel.upload(source, target, options)
+            end
+
+            def uploadFolder(folder, target, options = {})
+                @tunnel.uploadFolder(folder, target, options)
+            end
+
+            def self.exec(command, ssh = nil, allowFailure = false, options = {})
+                if ssh.nil?
+                    Local.exec(command, allowFailure, options)
+                else
+                    SSH.exec!(ssh, command, allowFailure, options)
+                end
+            end
+
+            def self.cmdSuccess?(command, ssh = nil)
+                if ssh.nil?
+                    system(command, :out => File::NULL)
+                else
+                    SSH.sshSuccess?(ssh, command)
+                end
+            end
+
+            # `connect': No route to host - connect(2) for 192.168.1.3:22 (Errno::EHOSTUNREACH)
+            # `connect': Connection refused - connect(2) for 192.168.1.3:22 (Errno::ECONNREFUSED)
+            def self.tunnel(uri, target, context, prompt, logger, &block)
+                scheme, uri = self.processURI(uri)
+                case scheme
+                when 'local'
+                    yield(Connection.new(:Local, Local.new(prompt, logger), prompt, logger))
+                when 'ssh'
+                    SSH.tunnel(uri) do |ssh|
+                        yield(Connection.new(:SSH, SSH.new(prompt, logger, ssh), prompt, logger))
+                    end
+                when 'proxmox+xterm'
+                    LMM::Proxmox.withXTerm(uri, target, context, prompt, logger) do |xterm|
+                        yield(Connection.new(:Proxmox, xterm, prompt, logger))
+                    end
+                else
+                    raise ConnectionError.new("Unsupported protocol: #{scheme}!")
+                end
+            end
+
+            def self.ping(uri, target, context, prompt, logger)
+                scheme, uri = self.processURI(uri)
+                case scheme
+                when 'local'
+                    return true
+                when 'ssh'
+                    SSH.ping(uri, prompt, logger)
+                else
+                    raise ConnectionError.new("Unimplemented protocol: #{scheme}!")
+                end
+            end
+
+            def self.processURI(uri)
+                return 'local' if uri.nil? || uri.to_s.empty? || uri == '@me'
+                uri = Addressable::URI.parse(uri) if uri.is_a?(String)
+                [uri.scheme, uri]
+            end
+
+        end
+    end
+end

data/lib/ConfigLMM/io/dhcp.rb

@@ -0,0 +1,330 @@
+
+require 'net/dhcp'
+require 'socket'
+require 'securerandom'
+require 'zlib'
+
+module ConfigLMM
+    module IO
+        class DHCP
+            READ_SIZE = 1500
+            MIN_SIZE = 300
+
+            DHCP_BROADCAST_FLAG = 0x8000
+            DHCP_CLIENTMACHINEID = 0x61 # Option 97 - Client Machine Identifier
+            DHCP_UUID_IDENTIFIER = 0x00
+
+            def initialize(logger)
+                @Logger = logger
+                @ServerSocket = UDPSocket.new
+                @ServerSocket.do_not_reverse_lookup = true
+                @ServerSocket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+                @ServerSocket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+                @ServerSocket.setsockopt(Socket::IPPROTO_IP, Socket::IP_PKTINFO, true)
+                @ServerSocket.bind('0.0.0.0', 67)
+                @Logger.debug('Listening on UDP port 67 (DHCP Server)')
+
+                @ClientSocket = UDPSocket.new
+                @ClientSocket.do_not_reverse_lookup = true
+                @ClientSocket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+                @ClientSocket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+                @ClientSocket.setsockopt(Socket::IPPROTO_IP, Socket::IP_PKTINFO, true)
+                @ClientSocket.bind('0.0.0.0', 68)
+                @Logger.debug('Listening on UDP port 68 (DHCP Client)')
+
+                @ProxyServerSocket = UDPSocket.new
+                @ProxyServerSocket.do_not_reverse_lookup = true
+                @ProxyServerSocket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+                @ProxyServerSocket.bind('0.0.0.0', 4011)
+                @Logger.debug('Listening on UDP port 4011 (proxyDHCP Server)')
+            end
+
+            def sendDiscover(mac)
+                discover = ::DHCP::Discover.new(flags: DHCP_BROADCAST_FLAG,
+                                                chaddr: [mac + '00000000000000000000'].pack('H*').unpack('C16'))
+                targetAddr = '<broadcast>'
+                @ClientSocket.send(discover.pack, 0, targetAddr, 67)
+                discover
+            end
+
+            def waitDiscover(timeout, useHTTP)
+                @Logger.info('Waiting for DHCP Discover request')
+                timeoutTime = Time.now + timeout
+                msgs = {}
+                loop do
+                    return msgs if Time.now >= timeoutTime
+                    data, sender_sockaddr, rflags, *controls = @ServerSocket.recvmsg_nonblock()
+                    ipinfo = controls.find { |ancillary| ancillary.cmsg_is?(:IP, :PKTINFO) }.ip_pktinfo
+                    if data.bytesize >= MIN_SIZE
+                        message = ::DHCP::Message.from_udp_payload(data)
+                        if isValidDiscover?(message, useHTTP)
+                            msgs[ipinfo] = message
+                            timeoutTime = Time.now + 0.0001
+                        else
+                            @Logger.debug("Ignoring unexpected DHCP request packet")
+                        end
+                    else
+                        @Logger.debug("Ignoring too small DHCP packet")
+                    end
+                rescue ::IO::WaitReadable
+                    ::IO.select([@ServerSocket], [], [], 0.0001)
+                    retry
+                end
+                msgs
+            end
+
+            def waitOffer(discoverMessage, timeout)
+                @Logger.info('Waiting for DHCP Offer response')
+                timeoutTime = Time.now + timeout
+                loop do
+                    return false if Time.now >= timeoutTime
+                    data, inetAddr  = @ClientSocket.recvfrom_nonblock(READ_SIZE)
+                    if data.bytesize >= MIN_SIZE
+                        message = ::DHCP::Message.from_udp_payload(data)
+                        if message.xid == discoverMessage.xid && message.chaddr[0, message.hlen] == discoverMessage.chaddr[0, discoverMessage.hlen]
+                            return message
+                        else
+                            @Logger.debug("Ignoring unexpected DHCP response packet")
+                        end
+                    else
+                        @Logger.debug("Ignoring too small DHCP packet")
+                    end
+                rescue ::IO::WaitReadable
+                    ::IO.select([@ClientSocket], [], [], 0.1)
+                    retry
+                end
+                false
+            end
+
+            def packUUID(uuid)
+                uuidParts = uuid.split('-')
+                uuidParts[0, 3].map(&:reverse).pack('h*h*h*') + uuidParts[3, 2].pack('H*H*')
+            end
+
+            def sendOffer(discoverMessageInfo, isFullDHCP, networkOptions, bootFile, bootFileSize)
+                ipinfo, discoverMessage = discoverMessageInfo
+                fname = bootFile
+                sname = networkOptions['IP']
+                siaddr = networkOptions['IP'].split('.').map(&:to_i).pack('C4').unpack('N').first
+                yiaddr = 0
+                useHTTP = bootFile.start_with?('http://')
+                etherboot = discoverMessage.options.find { |option| option.is_a?(::DHCP::PrivateOption) } # Etherboot
+                # Etherboot won't HTTP boot as HTTPClient...
+                vendorClass = useHTTP && !etherboot ? 'HTTPClient' : 'PXEClient'
+
+                if isFullDHCP
+                  yiaddr = networkOptions['ClientIP'].split('.').map(&:to_i).pack('C4').unpack('N').first
+                end
+                options = [
+                    ::DHCP::MessageTypeOption.new(payload: [$DHCP_MSG_OFFER]),
+                    ::DHCP::ServerIdentifierOption.new(payload: networkOptions['IP'].split('.').map(&:to_i)),
+                    ::DHCP::Option.new(type: $DHCP_BOOTFILESIZE, payload: [(bootFileSize / 512.0).ceil].pack('n').unpack('C*')),
+                    ::DHCP::Option.new(type: $DHCP_BOOTFILENAME, payload: bootFile.unpack('C*') + [0]),
+                    ::DHCP::VendorClassIDOption.new(payload: vendorClass.unpack('C*'))
+                ]
+
+                if !useHTTP
+                    options << ::DHCP::Option.new(type: $DHCP_TFTPSERVER, payload: networkOptions['IP'].unpack('C*') + [0])
+                end
+
+                clientMachineIdOption = discoverMessage.options.find { |option| option.type == DHCP_CLIENTMACHINEID }
+                if clientMachineIdOption
+                    options << clientMachineIdOption
+                end
+                if isFullDHCP
+                    options << ::DHCP::IPAddressLeaseTimeOption.new()
+                    options << ::DHCP::Option.new(type: $DHCP_RENEWTIME, payload: [3600].pack('N').unpack('C*'))
+                    options << ::DHCP::Option.new(type: $DHCP_REBINDTIME, payload: [3600].pack('N').unpack('C*'))
+                    options << ::DHCP::SubnetMaskOption.new(payload: networkOptions['Subnet'].split('.').map(&:to_i))
+                    options << ::DHCP::BroadcastAddressOption.new(payload: networkOptions['Broadcast'].split('.').map(&:to_i))
+                    options << ::DHCP::RouterOption.new(payload: networkOptions['Gateway'].split('.').map(&:to_i)) if networkOptions['Gateway']
+                    options << ::DHCP::DomainNameServerOption.new(payload: networkOptions['DNS'].split('.').map(&:to_i)) if networkOptions['DNS']
+                end
+
+                offer = ::DHCP::Offer.new(xid: discoverMessage.xid,
+                                          flags: discoverMessage.flags & DHCP_BROADCAST_FLAG,
+                                          siaddr: siaddr,
+                                          yiaddr: yiaddr,
+                                          chaddr: discoverMessage.chaddr,
+                                          sname: sname,
+                                          fname: fname,
+                                          options: options)
+                targetAddr = '<broadcast>'
+                #targetAddr = networkOptions['ClientIP'] if (discoverMessage.flags & DHCP_BROADCAST_FLAG).zero?
+                sockaddr = Socket.sockaddr_in(68, targetAddr)
+                @ServerSocket.sendmsg(offer.pack, 0, sockaddr, Socket::AncillaryData.ip_pktinfo(*ipinfo))
+                offer
+            end
+
+            def sendRequest(discoverMessage, offerRequest)
+                options = [::DHCP::MessageTypeOption.new({:payload=>[$DHCP_MSG_REQUEST]}), ::DHCP::ParameterRequestListOption.new]
+                serverIdentifier = offerRequest.options.find { |opt| opt.is_a?(::DHCP::ServerIdentifierOption) }
+                options << serverIdentifier if serverIdentifier
+                options << ::DHCP::RequestedIPAddressOption.new(payload: [offerRequest.yiaddr].pack('N').unpack('C4'))
+                request = ::DHCP::Request.new(
+                    xid: discoverMessage.xid,
+                    flags: DHCP_BROADCAST_FLAG,
+                    chaddr: discoverMessage.chaddr,
+                    options: options)
+                targetAddr = '<broadcast>'
+                @ClientSocket.send(request.pack, 0, targetAddr, 67)
+                request
+            end
+
+            def waitRequest(offerRequest, timeout)
+                @Logger.info('Waiting for DHCP Request response')
+                timeoutTime = Time.now + timeout
+                msgs = {}
+                loop do
+                    return msgs if Time.now >= timeoutTime
+                    data, sender_sockaddr, rflags, *controls = @ServerSocket.recvmsg_nonblock()
+                    ipinfo = controls.find { |ancillary| ancillary.cmsg_is?(:IP, :PKTINFO) }.ip_pktinfo
+                    if data.bytesize >= MIN_SIZE
+                        message = ::DHCP::Message.from_udp_payload(data)
+                        if isValidRequest?(message, offerRequest)
+                            msgs[ipinfo] = message
+                            timeoutTime = Time.now + 0.1
+                        elsif message.is_a?(::DHCP::Request)
+                            @Logger.info("Some router received DHCP Request packet")
+                        elsif message.is_a?(::DHCP::Discover)
+                            @Logger.debug("Received DHCP Discover packet, resending DHCP Offer")
+                            sockaddr = Socket.sockaddr_in(68, '<broadcast>')
+                            @ServerSocket.sendmsg(offerRequest.pack, 0, sockaddr, Socket::AncillaryData.ip_pktinfo(*ipinfo))
+                        else
+                            @Logger.debug("Ignoring unexpected DHCP response packet")
+                        end
+                    else
+                        @Logger.debug("Ignoring too small DHCP packet")
+                    end
+                rescue ::IO::WaitReadable
+                    ::IO.select([@ServerSocket], [], [], 0.1)
+                    retry
+                end
+                msgs
+            end
+
+            def createACK(requestMessage, offerRequest)
+                options = offerRequest.options.dup
+                options.delete_if { |option| option.is_a?(::DHCP::MessageTypeOption) }
+                ack = ::DHCP::ACK.new(xid: requestMessage.xid,
+                                      flags: requestMessage.flags,
+                                      ciaddr: offerRequest.ciaddr,
+                                      yiaddr: offerRequest.yiaddr,
+                                      siaddr: offerRequest.siaddr,
+                                      giaddr: offerRequest.giaddr,
+                                      chaddr: offerRequest.chaddr,
+                                      sname: offerRequest.sname,
+                                      fname: offerRequest.fname,
+                                      options: [::DHCP::MessageTypeOption.new(payload: [$DHCP_MSG_ACK])] + options)
+                ack
+            end
+
+            def waitACK(discoverMessage, requestMessage, timeout)
+                @Logger.info('Waiting for DHCP ACK response')
+                timeoutTime = Time.now + timeout
+                loop do
+                    return false if Time.now >= timeoutTime
+                    data, sender_sockaddr, rflags, *controls = @ClientSocket.recvmsg_nonblock()
+                    ipinfo = controls.find { |ancillary| ancillary.cmsg_is?(:IP, :PKTINFO) }.ip_pktinfo
+                    if data.bytesize >= MIN_SIZE
+                        message = ::DHCP::Message.from_udp_payload(data)
+                        if message.xid == discoverMessage.xid && message.chaddr[0, message.hlen] == discoverMessage.chaddr[0, discoverMessage.hlen]
+                            return [ipinfo, message]
+                        else
+                            @Logger.debug("Ignoring unexpected DHCP response packet")
+                        end
+                    else
+                        @Logger.debug("Ignoring too small DHCP packet")
+                    end
+                rescue ::IO::WaitReadable
+                    ::IO.select([@ClientSocket], [], [], 0.1)
+                    retry
+                end
+                false
+            end
+
+            def sendACK(requestMessageInfo, offerRequest)
+                ipinfo, requestMessage = requestMessageInfo
+                ack = createACK(requestMessage, offerRequest)
+                targetAddr = '<broadcast>'
+                #targetAddr = [offerRequest.yiaddr].pack('N').unpack('C4').join('.') if (offerRequest.flags & DHCP_BROADCAST_FLAG).zero?
+                sockaddr = Socket.sockaddr_in(68, targetAddr)
+                @ServerSocket.sendmsg(ack.pack, 0, sockaddr, Socket::AncillaryData.ip_pktinfo(*ipinfo))
+            end
+
+            def waitProxyRequest(timeout)
+                @Logger.info('Waiting for proxyDHCP Request response')
+                timeoutTime = Time.now + timeout
+                loop do
+                    return false if Time.now >= timeoutTime
+                    data, inetAddr  = @ProxyServerSocket.recvfrom_nonblock(READ_SIZE)
+                    if data.bytesize >= MIN_SIZE
+                        message = ::DHCP::Message.from_udp_payload(data)
+                        if isValidProxyRequest?(message)
+                            return message
+                        else
+                            @Logger.debug("Ignoring unexpected DHCP response packet")
+                        end
+                    else
+                        @Logger.debug("Ignoring too small DHCP packet")
+                    end
+                rescue ::IO::WaitReadable
+                    ::IO.select([@ProxyServerSocket], [], [], 0.1)
+                    retry
+                end
+                false
+            end
+
+            def sendProxyACK(proxyRequestMessage, offerRequest)
+                ack = createACK(proxyRequestMessage, offerRequest)
+                ack.ciaddr = proxyRequestMessage.ciaddr
+                targetAddr = [proxyRequestMessage.ciaddr].pack('N').unpack('C4').join('.')
+                @ProxyServerSocket.send(ack.pack, 0, targetAddr, 4011)
+            end
+
+            def isValidDiscover?(message, useHTTP)
+                isValid = message.is_a?(::DHCP::Discover) &&
+                message.htype == $DHCP_HTYPE_ETHERNET &&
+                message.hlen == $DHCP_HLEN_ETHERNET &&
+                message.giaddr.zero?
+                return isValid unless isValid
+                if useHTTP
+                    clientArchOption = message.options.find { |option| option.is_a?(::DHCP::ClientSystemArchitectureOption) }
+                    return true if clientArchOption && clientArchOption.payload.pack('C*').unpack('n').first == 0x0010 # x64 UEFI HTTP
+                    return true if message.options.find { |option| option.is_a?(::DHCP::PrivateOption) } # Etherboot
+                else
+                    message.options.each do |option|
+                        return true if option.is_a?(::DHCP::ParameterRequestListOption) &&
+                                       option.payload.include?($DHCP_TFTPSERVER) &&
+                                       option.payload.include?($DHCP_BOOTFILENAME)
+                    end
+                end
+                false
+            end
+
+            def isValidRequest?(message, offerRequest)
+                isValid = message.is_a?(::DHCP::Request) &&
+                message.htype == $DHCP_HTYPE_ETHERNET &&
+                message.hlen == $DHCP_HLEN_ETHERNET &&
+                message.giaddr.zero? &&
+                message.xid == offerRequest.xid &&
+                message.chaddr[0, message.hlen] == offerRequest.chaddr[0, offerRequest.hlen]
+
+                return isValid unless isValid
+                message.options.each do |option|
+                    return true if option.is_a?(::DHCP::ServerIdentifierOption) &&
+                                   option.payload == offerRequest.options.find { |offerOption| offerOption.is_a?(::DHCP::ServerIdentifierOption) }.payload
+                end
+                false
+            end
+
+            def isValidProxyRequest?(message)
+                isValid = message.is_a?(::DHCP::Request) &&
+                message.htype == $DHCP_HTYPE_ETHERNET &&
+                message.hlen == $DHCP_HLEN_ETHERNET &&
+                message.giaddr.zero?
+            end
+
+        end
+    end
+end