Debian Codegraph @

modules/ta_update/ta_update.unmanagedkey.test.integr/rfc5011/pydnstest/mock_client.py

raw
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))