Debian Codegraph @

src/resolve/test-resolved-dummy-server.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-daemon.h"
4 #include "sd-event.h"
5
6 #include "dns-packet.h"
7 #include "dns-question.h"
8 #include "dns-type.h"
9 #include "errno-util.h"
10 #include "fd-util.h"
11 #include "iovec-util.h"
12 #include "log.h"
13 #include "main-func.h"
14 #include "resolved-manager.h"
15 #include "socket-netlink.h"
16 #include "socket-util.h"
17 #include "string-util.h"
18 #include "time-util.h"
19
20 /* Taken from resolved-dns-stub.c */
21 #define ADVERTISE_DATAGRAM_SIZE_MAX (65536U-14U-20U-8U)
22
23 /* This is more or less verbatim manager_recv() from resolved-manager.c, sans the manager stuff */
24 static int server_recv(int fd, DnsPacket **ret) {
25 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
26 CMSG_BUFFER_TYPE(CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo))
27 + CMSG_SPACE(int) /* ttl/hoplimit */
28 + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */) control;
29 union sockaddr_union sa;
30 struct iovec iov;
31 struct msghdr mh = {
32 .msg_name = &sa.sa,
33 .msg_namelen = sizeof(sa),
34 .msg_iov = &iov,
35 .msg_iovlen = 1,
36 .msg_control = &control,
37 .msg_controllen = sizeof(control),
38 };
39 struct cmsghdr *cmsg;
40 ssize_t ms, l;
41 int r;
42
43 assert(fd >= 0);
44 assert(ret);
45
46 ms = next_datagram_size_fd(fd);
47 if (ms < 0)
48 return ms;
49
50 r = dns_packet_new(&p, DNS_PROTOCOL_DNS, ms, DNS_PACKET_SIZE_MAX);
51 if (r < 0)
52 return r;
53
54 iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->allocated);
55
56 l = recvmsg_safe(fd, &mh, 0);
57 if (ERRNO_IS_NEG_TRANSIENT(l))
58 return 0;
59 if (l <= 0)
60 return l;
61
62 p->size = (size_t) l;
63
64 p->family = sa.sa.sa_family;
65 p->ipproto = IPPROTO_UDP;
66 if (p->family == AF_INET) {
67 p->sender.in = sa.in.sin_addr;
68 p->sender_port = be16toh(sa.in.sin_port);
69 } else if (p->family == AF_INET6) {
70 p->sender.in6 = sa.in6.sin6_addr;
71 p->sender_port = be16toh(sa.in6.sin6_port);
72 p->ifindex = sa.in6.sin6_scope_id;
73 } else
74 return -EAFNOSUPPORT;
75
76 p->timestamp = now(CLOCK_BOOTTIME);
77
78 CMSG_FOREACH(cmsg, &mh) {
79
80 if (cmsg->cmsg_level == IPPROTO_IPV6) {
81 assert(p->family == AF_INET6);
82
83 switch (cmsg->cmsg_type) {
84
85 case IPV6_PKTINFO: {
86 struct in6_pktinfo *i = CMSG_TYPED_DATA(cmsg, struct in6_pktinfo);
87
88 if (p->ifindex <= 0)
89 p->ifindex = i->ipi6_ifindex;
90
91 p->destination.in6 = i->ipi6_addr;
92 break;
93 }
94
95 case IPV6_HOPLIMIT:
96 p->ttl = *CMSG_TYPED_DATA(cmsg, int);
97 break;
98
99 case IPV6_RECVFRAGSIZE:
100 p->fragsize = *CMSG_TYPED_DATA(cmsg, int);
101 break;
102 }
103 } else if (cmsg->cmsg_level == IPPROTO_IP) {
104 assert(p->family == AF_INET);
105
106 switch (cmsg->cmsg_type) {
107
108 case IP_PKTINFO: {
109 struct in_pktinfo *i = CMSG_TYPED_DATA(cmsg, struct in_pktinfo);
110
111 if (p->ifindex <= 0)
112 p->ifindex = i->ipi_ifindex;
113
114 p->destination.in = i->ipi_addr;
115 break;
116 }
117
118 case IP_TTL:
119 p->ttl = *CMSG_TYPED_DATA(cmsg, int);
120 break;
121
122 case IP_RECVFRAGSIZE:
123 p->fragsize = *CMSG_TYPED_DATA(cmsg, int);
124 break;
125 }
126 }
127 }
128
129 /* The Linux kernel sets the interface index to the loopback
130 * device if the packet came from the local host since it
131 * avoids the routing table in such a case. Let's unset the
132 * interface index in such a case. */
133 if (p->ifindex == LOOPBACK_IFINDEX)
134 p->ifindex = 0;
135
136 log_debug("Received DNS UDP packet of size %zu, ifindex=%i, ttl=%u, fragsize=%zu, sender=%s, destination=%s",
137 p->size, p->ifindex, p->ttl, p->fragsize,
138 IN_ADDR_TO_STRING(p->family, &p->sender),
139 IN_ADDR_TO_STRING(p->family, &p->destination));
140
141 *ret = TAKE_PTR(p);
142 return 1;
143 }
144
145 /* Same as above, see manager_ipv4_send() in resolved-manager.c */
146 static int server_ipv4_send(
147 int fd,
148 const struct in_addr *destination,
149 uint16_t port,
150 const struct in_addr *source,
151 DnsPacket *packet) {
152
153 union sockaddr_union sa;
154 struct iovec iov;
155 struct msghdr mh = {
156 .msg_iov = &iov,
157 .msg_iovlen = 1,
158 .msg_name = &sa.sa,
159 .msg_namelen = sizeof(sa.in),
160 };
161
162 assert(fd >= 0);
163 assert(destination);
164 assert(port > 0);
165 assert(packet);
166
167 iov = IOVEC_MAKE(DNS_PACKET_DATA(packet), packet->size);
168
169 sa = (union sockaddr_union) {
170 .in.sin_family = AF_INET,
171 .in.sin_addr = *destination,
172 .in.sin_port = htobe16(port),
173 };
174
175 return sendmsg_loop(fd, &mh, 0);
176 }
177
178 static int make_reply_packet(DnsPacket *packet, DnsPacket **ret) {
179 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
180 int r;
181
182 assert(packet);
183 assert(ret);
184
185 r = dns_packet_new(&p, DNS_PROTOCOL_DNS, 0, dns_packet_payload_size_max(packet));
186 if (r < 0)
187 return r;
188
189 r = dns_packet_append_question(p, packet->question);
190 if (r < 0)
191 return r;
192
193 DNS_PACKET_HEADER(p)->id = DNS_PACKET_ID(packet);
194 DNS_PACKET_HEADER(p)->qdcount = htobe16(dns_question_size(packet->question));
195
196 *ret = TAKE_PTR(p);
197 return 0;
198 }
199
200 static int reply_append_edns(DnsPacket *packet, DnsPacket *reply, const char *extra_text, size_t rcode, uint16_t ede_code) {
201 size_t saved_size;
202 int r;
203
204 assert(packet);
205 assert(reply);
206
207 /* Append EDNS0 stuff (inspired by dns_packet_append_opt() from resolved-dns-packet.c).
208 *
209 * Relevant headers from RFC 6891:
210 *
211 * +------------+--------------+------------------------------+
212 * | Field Name | Field Type | Description |
213 * +------------+--------------+------------------------------+
214 * | NAME | domain name | MUST be 0 (root domain) |
215 * | TYPE | u_int16_t | OPT (41) |
216 * | CLASS | u_int16_t | requestor's UDP payload size |
217 * | TTL | u_int32_t | extended RCODE and flags |
218 * | RDLEN | u_int16_t | length of all RDATA |
219 * | RDATA | octet stream | {attribute,value} pairs |
220 * +------------+--------------+------------------------------+
221 *
222 * +0 (MSB) +1 (LSB)
223 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
224 * 0: | OPTION-CODE |
225 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
226 * 2: | OPTION-LENGTH |
227 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
228 * 4: | |
229 * / OPTION-DATA /
230 * / /
231 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
232 *
233 * And from RFC 8914:
234 *
235 * 1 1 1 1 1 1
236 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
237 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
238 * 0: | OPTION-CODE |
239 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
240 * 2: | OPTION-LENGTH |
241 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
242 * 4: | INFO-CODE |
243 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
244 * 6: / EXTRA-TEXT ... /
245 * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
246 */
247
248 saved_size = reply->size;
249
250 /* empty name */
251 r = dns_packet_append_uint8(reply, 0, NULL);
252 if (r < 0)
253 return r;
254
255 /* type */
256 r = dns_packet_append_uint16(reply, DNS_TYPE_OPT, NULL);
257 if (r < 0)
258 return r;
259
260 /* class: maximum udp packet that can be received */
261 r = dns_packet_append_uint16(reply, ADVERTISE_DATAGRAM_SIZE_MAX, NULL);
262 if (r < 0)
263 return r;
264
265 /* extended RCODE and VERSION */
266 r = dns_packet_append_uint16(reply, ((uint16_t) rcode & 0x0FF0) << 4, NULL);
267 if (r < 0)
268 return r;
269
270 /* flags: DNSSEC OK (DO), see RFC3225 */
271 r = dns_packet_append_uint16(reply, 0, NULL);
272 if (r < 0)
273 return r;
274
275 /* RDATA */
276
277 size_t extra_text_len = isempty(extra_text) ? 0 : strlen(extra_text);
278 /* RDLENGTH (OPTION CODE + OPTION LENGTH + INFO-CODE + EXTRA-TEXT) */
279 r = dns_packet_append_uint16(reply, 2 + 2 + 2 + extra_text_len, NULL);
280 if (r < 0)
281 return 0;
282
283 /* OPTION-CODE: 15 for EDE */
284 r = dns_packet_append_uint16(reply, 15, NULL);
285 if (r < 0)
286 return r;
287
288 /* OPTION-LENGTH: INFO-CODE + EXTRA-TEXT */
289 r = dns_packet_append_uint16(reply, 2 + extra_text_len, NULL);
290 if (r < 0)
291 return r;
292
293 /* INFO-CODE: EDE code */
294 r = dns_packet_append_uint16(reply, ede_code, NULL);
295 if (r < 0)
296 return r;
297
298 /* EXTRA-TEXT */
299 if (extra_text_len > 0) {
300 /* From RFC 8914:
301 * EDE text may be null terminated but MUST NOT be assumed to be; the length MUST be derived
302 * from the OPTION-LENGTH field
303 *
304 * Let's exercise our code on the receiving side and not NUL-terminate the EXTRA-TEXT field
305 */
306 r = dns_packet_append_blob(reply, extra_text, extra_text_len, NULL);
307 if (r < 0)
308 return r;
309 }
310
311 DNS_PACKET_HEADER(reply)->arcount = htobe16(DNS_PACKET_ARCOUNT(reply) + 1);
312 reply->opt_start = saved_size;
313 reply->opt_size = reply->size - saved_size;
314
315 /* Order: qr, opcode, aa, tc, rd, ra, ad, cd, rcode */
316 DNS_PACKET_HEADER(reply)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
317 1, 0, 0, 0, DNS_PACKET_RD(packet), 1, 0, 1, rcode));
318 return 0;
319 }
320
321 static void server_fail(DnsPacket *packet, DnsPacket *reply, int rcode) {
322 assert(reply);
323
324 /* Order: qr, opcode, aa, tc, rd, ra, ad, cd, rcode */
325 DNS_PACKET_HEADER(reply)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(
326 1, 0, 0, 0, DNS_PACKET_RD(packet), 1, 0, 1, rcode));
327 }
328
329 static int server_handle_edns_bogus_dnssec(DnsPacket *packet, DnsPacket *reply) {
330 assert(packet);
331 assert(reply);
332
333 return reply_append_edns(packet, reply, NULL, DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_DNSSEC_BOGUS);
334 }
335
336 static int server_handle_edns_extra_text(DnsPacket *packet, DnsPacket *reply) {
337 assert(packet);
338 assert(reply);
339
340 return reply_append_edns(packet, reply, "Nothing to see here!", DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_CENSORED);
341 }
342
343 static int server_handle_edns_invalid_code(DnsPacket *packet, DnsPacket *reply, const char *extra_text) {
344 assert(packet);
345 assert(reply);
346 assert_cc(_DNS_EDE_RCODE_MAX_DEFINED < UINT16_MAX);
347
348 return reply_append_edns(packet, reply, extra_text, DNS_RCODE_SERVFAIL, _DNS_EDE_RCODE_MAX_DEFINED + 1);
349 }
350
351 static int server_handle_edns_code_zero(DnsPacket *packet, DnsPacket *reply) {
352 assert(packet);
353 assert(reply);
354 assert_cc(DNS_EDE_RCODE_OTHER == 0);
355
356 return reply_append_edns(packet, reply, "\xF0\x9F\x90\xB1", DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_OTHER);
357 }
358
359 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
360 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
361 _cleanup_(dns_packet_unrefp) DnsPacket *reply = NULL;
362 const char *name;
363 int r;
364
365 assert(fd >= 0);
366
367 r = server_recv(fd, &packet);
368 if (r < 0) {
369 log_debug_errno(r, "Failed to receive packet, ignoring: %m");
370 return 0;
371 }
372
373 r = dns_packet_validate_query(packet);
374 if (r < 0) {
375 log_debug_errno(r, "Invalid DNS UDP packet, ignoring.");
376 return 0;
377 }
378
379 r = dns_packet_extract(packet);
380 if (r < 0) {
381 log_debug_errno(r, "Failed to extract DNS packet, ignoring: %m");
382 return 0;
383 }
384
385 name = dns_question_first_name(packet->question);
386 log_info("Processing question for name '%s'", name);
387
388 dns_question_dump(packet->question, stdout);
389
390 r = make_reply_packet(packet, &reply);
391 if (r < 0) {
392 log_debug_errno(r, "Failed to make reply packet, ignoring: %m");
393 return 0;
394 }
395
396 if (streq_ptr(name, "edns-bogus-dnssec.forwarded.test"))
397 r = server_handle_edns_bogus_dnssec(packet, reply);
398 else if (streq_ptr(name, "edns-extra-text.forwarded.test"))
399 r = server_handle_edns_extra_text(packet, reply);
400 else if (streq_ptr(name, "edns-invalid-code.forwarded.test"))
401 r = server_handle_edns_invalid_code(packet, reply, NULL);
402 else if (streq_ptr(name, "edns-invalid-code-with-extra-text.forwarded.test"))
403 r = server_handle_edns_invalid_code(packet, reply, "Hello [#]$%~ World");
404 else if (streq_ptr(name, "edns-code-zero.forwarded.test"))
405 r = server_handle_edns_code_zero(packet, reply);
406 else
407 r = log_debug_errno(SYNTHETIC_ERRNO(EFAULT), "Unhandled name '%s', ignoring.", name);
408 if (r < 0)
409 server_fail(packet, reply, DNS_RCODE_NXDOMAIN);
410
411 r = server_ipv4_send(fd, &packet->sender.in, packet->sender_port, &packet->destination.in, reply);
412 if (r < 0)
413 log_debug_errno(r, "Failed to send reply, ignoring: %m");
414
415 return 0;
416 }
417
418 static int run(int argc, char *argv[]) {
419 _cleanup_(sd_event_unrefp) sd_event *event = NULL;
420 _cleanup_close_ int fd = -EBADF;
421 int r;
422
423 log_setup();
424
425 if (argc != 2)
426 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
427 "This program takes one argument in format ip_address:port");
428
429 fd = make_socket_fd(LOG_DEBUG, argv[1], SOCK_DGRAM, SOCK_CLOEXEC);
430 if (fd < 0)
431 return log_error_errno(fd, "Failed to listen on address '%s': %m", argv[1]);
432
433 r = sd_event_default(&event);
434 if (r < 0)
435 return log_error_errno(r, "Failed to allocate event: %m");
436
437 r = sd_event_add_io(event, NULL, fd, EPOLLIN, on_dns_packet, NULL);
438 if (r < 0)
439 return log_error_errno(r, "Failed to add IO event source: %m");
440
441 r = sd_event_set_signal_exit(event, true);
442 if (r < 0)
443 return log_error_errno(r, "Failed to install SIGINT/SIGTERM handlers: %m");
444
445 (void) sd_notify(/* unset_environment=false */ false, "READY=1");
446
447 r = sd_event_loop(event);
448 if (r < 0)
449 return log_error_errno(r, "Failed to run event loop: %m");
450
451 return 0;
452 }
453
454 DEFINE_MAIN_FUNCTION(run);