def validate_dhcp_resp(request, response): # pylint: disable=R1710
bytes_recv = len(response)
if bytes_recv < 0xF6:
logger.error("HandleDhcpResponse: Too few bytes received:{0}",
bytes_recv)
return False
logger.verbose("BytesReceived:{0}", hex(bytes_recv))
logger.verbose("DHCP response:{0}", hex_dump(response, bytes_recv))
# check transactionId, cookie, MAC address cookie should never mismatch
# transactionId and MAC address may mismatch if we see a response
# meant from another machine
if not compare_bytes(request, response, 0xEC, 4):
logger.verbose("Cookie not match:\nsend={0},\nreceive={1}",
hex_dump3(request, 0xEC, 4),
hex_dump3(response, 0xEC, 4))
raise DhcpError("Cookie in dhcp respones doesn't match the request")
if not compare_bytes(request, response, 4, 4):
logger.verbose("TransactionID not match:\nsend={0},\nreceive={1}",
hex_dump3(request, 4, 4), hex_dump3(response, 4, 4))
raise DhcpError("TransactionID in dhcp respones "
"doesn't match the request")
if not compare_bytes(request, response, 0x1C, 6):
logger.verbose("Mac Address not match:\nsend={0},\nreceive={1}",
hex_dump3(request, 0x1C, 6),
hex_dump3(response, 0x1C, 6))
raise DhcpError("Mac Addr in dhcp respones "
"doesn't match the request")
def test_detect_protocol_no_dhcp(self, WireProtocol, mock_get_lib_dir, _):
WireProtocol.return_value.detect = Mock()
mock_get_lib_dir.return_value = self.tmp_dir
protocol_util = get_protocol_util()
protocol_util.osutil = MagicMock()
protocol_util.osutil.is_dhcp_available.return_value = False
protocol_util.dhcp_handler = MagicMock()
protocol_util.dhcp_handler.endpoint = None
protocol_util.dhcp_handler.run = Mock()
endpoint_file = protocol_util._get_wireserver_endpoint_file_path()
# Test wire protocol when no endpoint file has been written
protocol_util._detect_protocol()
self.assertEqual(KNOWN_WIRESERVER_IP,
protocol_util.get_wireserver_endpoint())
# Test wire protocol on dhcp failure
protocol_util.osutil.is_dhcp_available.return_value = True
protocol_util.dhcp_handler.run.side_effect = DhcpError()
self.assertRaises(ProtocolError, protocol_util._detect_protocol)
def send_dhcp_req(self):
"""
Check if DHCP is available
"""
dhcp_available = self.osutil.is_dhcp_available()
if not dhcp_available:
logger.info("send_dhcp_req: DHCP not available")
self.endpoint = KNOWN_WIRESERVER_IP
return
# pylint: disable=W0105
"""
Build dhcp request with mac addr
Configure route to allow dhcp traffic
Stop dhcp service if necessary
"""
# pylint: enable=W0105
logger.info("Send dhcp request")
mac_addr = self.osutil.get_mac_addr()
# Do unicast first, then fallback to broadcast if fails.
req = build_dhcp_request(mac_addr, self._request_broadcast)
if not self._request_broadcast:
self._request_broadcast = True
# Temporary allow broadcast for dhcp. Remove the route when done.
missing_default_route = self.osutil.is_missing_default_route()
ifname = self.osutil.get_if_name()
if missing_default_route:
self.osutil.set_route_for_dhcp_broadcast(ifname)
# In some distros, dhcp service needs to be shutdown before agent probe
# endpoint through dhcp.
if self.osutil.is_dhcp_enabled():
self.osutil.stop_dhcp_service()
resp = self._send_dhcp_req(req)
if self.osutil.is_dhcp_enabled():
self.osutil.start_dhcp_service()
if missing_default_route:
self.osutil.remove_route_for_dhcp_broadcast(ifname)
if resp is None:
raise DhcpError("Failed to receive dhcp response.")
self.endpoint, self.gateway, self.routes = parse_dhcp_resp(resp)
def socket_send(request):
sock = None
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(("0.0.0.0", 68))
sock.sendto(request, ("<broadcast>", 67))
sock.settimeout(10)
logger.verbose("Send DHCP request: Setting socket.timeout=10, "
"entering recv")
response = sock.recv(1024)
return response
except IOError as e:
raise DhcpError("{0}".format(e))
finally:
if sock is not None:
sock.close()
