| 1 |
"""Module takes care of sending and recieving DNS messages as a mock client""" |
| 2 |
|
| 3 |
import errno |
| 4 |
import socket |
| 5 |
import struct |
| 6 |
import time |
| 7 |
from typing import Optional, Tuple, Union |
| 8 |
|
| 9 |
import dns.message |
| 10 |
import dns.inet |
| 11 |
|
| 12 |
|
| 13 |
SOCKET_OPERATION_TIMEOUT = 5 |
| 14 |
RECEIVE_MESSAGE_SIZE = 2**16-1 |
| 15 |
THROTTLE_BY = 0.1 |
| 16 |
|
| 17 |
|
| 18 |
def handle_socket_timeout(sock: socket.socket, deadline: float): |
| 19 |
# deadline is always time.monotonic |
| 20 |
remaining = deadline - time.monotonic() |
| 21 |
if remaining <= 0: |
| 22 |
raise RuntimeError("Server took too long to respond") |
| 23 |
sock.settimeout(remaining) |
| 24 |
|
| 25 |
|
| 26 |
def recv_n_bytes_from_tcp(stream: socket.socket, n: int, deadline: float) -> bytes: |
| 27 |
# deadline is always time.monotonic |
| 28 |
data = b"" |
| 29 |
while n != 0: |
| 30 |
handle_socket_timeout(stream, deadline) |
| 31 |
chunk = stream.recv(n) |
| 32 |
# Empty bytes from socket.recv mean that socket is closed |
| 33 |
if not chunk: |
| 34 |
raise OSError() |
| 35 |
n -= len(chunk) |
| 36 |
data += chunk |
| 37 |
return data |
| 38 |
|
| 39 |
|
| 40 |
def recvfrom_blob(sock: socket.socket, |
| 41 |
timeout: int = SOCKET_OPERATION_TIMEOUT) -> Tuple[bytes, str]: |
| 42 |
""" |
| 43 |
Receive DNS message from TCP/UDP socket. |
| 44 |
""" |
| 45 |
|
| 46 |
# deadline is always time.monotonic |
| 47 |
deadline = time.monotonic() + timeout |
| 48 |
|
| 49 |
while True: |
| 50 |
try: |
| 51 |
if sock.type & socket.SOCK_DGRAM: |
| 52 |
handle_socket_timeout(sock, deadline) |
| 53 |
data, addr = sock.recvfrom(RECEIVE_MESSAGE_SIZE) |
| 54 |
elif sock.type & socket.SOCK_STREAM: |
| 55 |
# First 2 bytes of TCP packet are the size of the message |
| 56 |
# See https://tools.ietf.org/html/rfc1035#section-4.2.2 |
| 57 |
data = recv_n_bytes_from_tcp(sock, 2, deadline) |
| 58 |
msg_len = struct.unpack_from("!H", data)[0] |
| 59 |
data = recv_n_bytes_from_tcp(sock, msg_len, deadline) |
| 60 |
addr = sock.getpeername()[0] |
| 61 |
else: |
| 62 |
raise NotImplementedError(f"[recvfrom_blob]: unknown socket type '{sock.type}'") |
| 63 |
return data, addr |
| 64 |
except socket.timeout as ex: |
| 65 |
raise RuntimeError("Server took too long to respond") from ex |
| 66 |
except OSError as ex: |
| 67 |
if ex.errno == errno.ENOBUFS: |
| 68 |
time.sleep(0.1) |
| 69 |
else: |
| 70 |
raise |
| 71 |
|
| 72 |
|
| 73 |
def recvfrom_msg(sock: socket.socket, |
| 74 |
timeout: int = SOCKET_OPERATION_TIMEOUT) -> Tuple[dns.message.Message, str]: |
| 75 |
data, addr = recvfrom_blob(sock, timeout=timeout) |
| 76 |
msg = dns.message.from_wire(data, one_rr_per_rrset=True) |
| 77 |
return msg, addr |
| 78 |
|
| 79 |
|
| 80 |
def sendto_msg(sock: socket.socket, message: bytes, addr: Optional[str] = None) -> None: |
| 81 |
""" Send DNS/UDP/TCP message. """ |
| 82 |
try: |
| 83 |
if sock.type & socket.SOCK_DGRAM: |
| 84 |
if addr is None: |
| 85 |
sock.send(message) |
| 86 |
else: |
| 87 |
sock.sendto(message, addr) |
| 88 |
elif sock.type & socket.SOCK_STREAM: |
| 89 |
data = struct.pack("!H", len(message)) + message |
| 90 |
sock.sendall(data) |
| 91 |
else: |
| 92 |
raise NotImplementedError(f"[sendto_msg]: unknown socket type '{sock.type}'") |
| 93 |
except OSError as ex: |
| 94 |
# Reference: http://lkml.iu.edu/hypermail/linux/kernel/0002.3/0709.html |
| 95 |
if ex.errno != errno.ECONNREFUSED: |
| 96 |
raise |
| 97 |
|
| 98 |
|
| 99 |
def setup_socket(address: str, |
| 100 |
port: int, |
| 101 |
tcp: bool = False, |
| 102 |
src_address: Optional[str] = None) -> socket.socket: |
| 103 |
family = dns.inet.af_for_address(address) |
| 104 |
sock = socket.socket(family, socket.SOCK_STREAM if tcp else socket.SOCK_DGRAM) |
| 105 |
if tcp: |
| 106 |
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True) |
| 107 |
if src_address is not None: |
| 108 |
sock.bind((src_address, 0)) # random source port |
| 109 |
sock.settimeout(SOCKET_OPERATION_TIMEOUT) |
| 110 |
sock.connect((address, port)) |
| 111 |
return sock |
| 112 |
|
| 113 |
|
| 114 |
def send_query(sock: socket.socket, query: Union[dns.message.Message, bytes]) -> None: |
| 115 |
message = query if isinstance(query, bytes) else query.to_wire() |
| 116 |
while True: |
| 117 |
try: |
| 118 |
sendto_msg(sock, message) |
| 119 |
break |
| 120 |
except OSError as ex: |
| 121 |
# ENOBUFS, throttle sending |
| 122 |
if ex.errno == errno.ENOBUFS: |
| 123 |
time.sleep(0.1) |
| 124 |
else: |
| 125 |
raise |
| 126 |
|
| 127 |
|
| 128 |
def get_answer(sock: socket.socket, timeout: int = SOCKET_OPERATION_TIMEOUT) -> bytes: |
| 129 |
""" Compatibility function """ |
| 130 |
answer, _ = recvfrom_blob(sock, timeout=timeout) |
| 131 |
return answer |
| 132 |
|
| 133 |
|
| 134 |
def get_dns_message(sock: socket.socket, |
| 135 |
timeout: int = SOCKET_OPERATION_TIMEOUT) -> dns.message.Message: |
| 136 |
return dns.message.from_wire(get_answer(sock, timeout=timeout)) |