chiark / gitweb /
resolved: add API for resolving specific RRs
[elogind.git] / src / resolve / resolved-manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2014 Tom Gundersen <teg@jklm.no>
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20  ***/
21
22 #include <arpa/inet.h>
23 #include <resolv.h>
24 #include <net/if.h>
25 #include <sys/ioctl.h>
26 #include <sys/poll.h>
27 #include <netinet/in.h>
28
29 #include "rtnl-util.h"
30 #include "event-util.h"
31 #include "network-util.h"
32 #include "network-internal.h"
33 #include "conf-parser.h"
34 #include "socket-util.h"
35 #include "af-list.h"
36 #include "resolved.h"
37
38 #define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
39
40 static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
41         Manager *m = userdata;
42         uint16_t type;
43         Link *l;
44         int ifindex, r;
45
46         assert(rtnl);
47         assert(m);
48         assert(mm);
49
50         r = sd_rtnl_message_get_type(mm, &type);
51         if (r < 0)
52                 goto fail;
53
54         r = sd_rtnl_message_link_get_ifindex(mm, &ifindex);
55         if (r < 0)
56                 goto fail;
57
58         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
59
60         switch (type) {
61
62         case RTM_NEWLINK:{
63                 bool is_new = !l;
64
65                 if (!l) {
66                         r = link_new(m, &l, ifindex);
67                         if (r < 0)
68                                 goto fail;
69                 }
70
71                 r = link_update_rtnl(l, mm);
72                 if (r < 0)
73                         goto fail;
74
75                 if (is_new)
76                         log_debug("Found new link %i/%s", ifindex, l->name);
77
78                 break;
79         }
80
81         case RTM_DELLINK:
82                 if (l) {
83                         log_debug("Removing link %i/%s", l->ifindex, l->name);
84                         link_free(l);
85                 }
86
87                 break;
88         }
89
90         return 0;
91
92 fail:
93         log_warning("Failed to process RTNL link message: %s", strerror(-r));
94         return 0;
95 }
96
97 static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
98         Manager *m = userdata;
99         union in_addr_union address;
100         uint16_t type;
101         int r, ifindex, family;
102         LinkAddress *a;
103         Link *l;
104
105         assert(rtnl);
106         assert(mm);
107         assert(m);
108
109         r = sd_rtnl_message_get_type(mm, &type);
110         if (r < 0)
111                 goto fail;
112
113         r = sd_rtnl_message_addr_get_ifindex(mm, &ifindex);
114         if (r < 0)
115                 goto fail;
116
117         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
118         if (!l)
119                 return 0;
120
121         r = sd_rtnl_message_addr_get_family(mm, &family);
122         if (r < 0)
123                 goto fail;
124
125         switch (family) {
126
127         case AF_INET:
128                 r = sd_rtnl_message_read_in_addr(mm, IFA_LOCAL, &address.in);
129                 if (r < 0) {
130                         r = sd_rtnl_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
131                         if (r < 0)
132                                 goto fail;
133                 }
134
135                 break;
136
137         case AF_INET6:
138                 r = sd_rtnl_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
139                 if (r < 0) {
140                         r = sd_rtnl_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
141                         if (r < 0)
142                                 goto fail;
143                 }
144
145                 break;
146
147         default:
148                 return 0;
149         }
150
151         a = link_find_address(l, family, &address);
152
153         switch (type) {
154
155         case RTM_NEWADDR:
156
157                 if (!a) {
158                         r = link_address_new(l, &a, family, &address);
159                         if (r < 0)
160                                 return r;
161                 }
162
163                 r = link_address_update_rtnl(a, mm);
164                 if (r < 0)
165                         return r;
166
167                 break;
168
169         case RTM_DELADDR:
170                 if (a)
171                         link_address_free(a);
172                 break;
173         }
174
175         return 0;
176
177 fail:
178         log_warning("Failed to process RTNL address message: %s", strerror(-r));
179         return 0;
180 }
181
182
183 static int manager_rtnl_listen(Manager *m) {
184         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
185         sd_rtnl_message *i;
186         int r;
187
188         assert(m);
189
190         /* First, subscibe to interfaces coming and going */
191         r = sd_rtnl_open(&m->rtnl, 3, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR);
192         if (r < 0)
193                 return r;
194
195         r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
196         if (r < 0)
197                 return r;
198
199         r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
200         if (r < 0)
201                 return r;
202
203         r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
204         if (r < 0)
205                 return r;
206
207         r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
208         if (r < 0)
209                 return r;
210
211         r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
212         if (r < 0)
213                 return r;
214
215         /* Then, enumerate all links */
216         r = sd_rtnl_message_new_link(m->rtnl, &req, RTM_GETLINK, 0);
217         if (r < 0)
218                 return r;
219
220         r = sd_rtnl_message_request_dump(req, true);
221         if (r < 0)
222                 return r;
223
224         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
225         if (r < 0)
226                 return r;
227
228         for (i = reply; i; i = sd_rtnl_message_next(i)) {
229                 r = manager_process_link(m->rtnl, i, m);
230                 if (r < 0)
231                         return r;
232         }
233
234         req = sd_rtnl_message_unref(req);
235         reply = sd_rtnl_message_unref(reply);
236
237         /* Finally, enumerate all addresses, too */
238         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
239         if (r < 0)
240                 return r;
241
242         r = sd_rtnl_message_request_dump(req, true);
243         if (r < 0)
244                 return r;
245
246         r = sd_rtnl_call(m->rtnl, req, 0, &reply);
247         if (r < 0)
248                 return r;
249
250         for (i = reply; i; i = sd_rtnl_message_next(i)) {
251                 r = manager_process_address(m->rtnl, i, m);
252                 if (r < 0)
253                         return r;
254         }
255
256         return r;
257 }
258
259 static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
260         Manager *m = userdata;
261         Iterator i;
262         Link *l;
263         int r;
264
265         assert(m);
266
267         sd_network_monitor_flush(m->network_monitor);
268
269         HASHMAP_FOREACH(l, m->links, i) {
270                 r = link_update_monitor(l);
271                 if (r < 0)
272                         log_warning("Failed to update monitor information for %i: %s", l->ifindex, strerror(-r));
273         }
274
275         r = manager_write_resolv_conf(m);
276         if (r < 0)
277                 log_warning("Could not update resolv.conf: %s", strerror(-r));
278
279         return 0;
280 }
281
282 static int manager_network_monitor_listen(Manager *m) {
283         int r, fd, events;
284
285         assert(m);
286
287         r = sd_network_monitor_new(&m->network_monitor, NULL);
288         if (r < 0)
289                 return r;
290
291         fd = sd_network_monitor_get_fd(m->network_monitor);
292         if (fd < 0)
293                 return fd;
294
295         events = sd_network_monitor_get_events(m->network_monitor);
296         if (events < 0)
297                 return events;
298
299         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, &on_network_event, m);
300         if (r < 0)
301                 return r;
302
303         return 0;
304 }
305
306 static int parse_dns_server_string(Manager *m, const char *string) {
307         char *word, *state;
308         size_t length;
309         int r;
310
311         assert(m);
312         assert(string);
313
314         FOREACH_WORD_QUOTED(word, length, string, state) {
315                 char buffer[length+1];
316                 int family;
317                 union in_addr_union addr;
318
319                 memcpy(buffer, word, length);
320                 buffer[length] = 0;
321
322                 r = in_addr_from_string_auto(buffer, &family, &addr);
323                 if (r < 0) {
324                         log_warning("Ignoring invalid DNS address '%s'", buffer);
325                         continue;
326                 }
327
328                 /* filter out duplicates */
329                 if (manager_find_dns_server(m, family, &addr))
330                         continue;
331
332                 r = dns_server_new(m, NULL, NULL, family, &addr);
333                 if (r < 0)
334                         return r;
335         }
336
337         return 0;
338 }
339
340 int config_parse_dnsv(
341                 const char *unit,
342                 const char *filename,
343                 unsigned line,
344                 const char *section,
345                 unsigned section_line,
346                 const char *lvalue,
347                 int ltype,
348                 const char *rvalue,
349                 void *data,
350                 void *userdata) {
351
352         Manager *m = userdata;
353         int r;
354
355         assert(filename);
356         assert(lvalue);
357         assert(rvalue);
358         assert(m);
359
360         /* Empty assignment means clear the list */
361         if (isempty(rvalue)) {
362                 while (m->dns_servers)
363                         dns_server_free(m->dns_servers);
364
365                 return 0;
366         }
367
368         r = parse_dns_server_string(m, rvalue);
369         if (r < 0) {
370                 log_error("Failed to parse DNS server string");
371                 return r;
372         }
373
374         return 0;
375 }
376
377 int manager_parse_config_file(Manager *m) {
378         assert(m);
379
380         return config_parse(NULL, "/etc/systemd/resolved.conf", NULL,
381                             "Resolve\0",
382                             config_item_perf_lookup, resolved_gperf_lookup,
383                             false, false, true, m);
384 }
385
386 int manager_new(Manager **ret) {
387         _cleanup_(manager_freep) Manager *m = NULL;
388         int r;
389
390         assert(ret);
391
392         m = new0(Manager, 1);
393         if (!m)
394                 return -ENOMEM;
395
396         m->dns_ipv4_fd = m->dns_ipv6_fd = -1;
397         m->llmnr_ipv4_udp_fd = m->llmnr_ipv6_udp_fd = -1;
398         m->llmnr_ipv4_tcp_fd = m->llmnr_ipv6_tcp_fd = -1;
399
400         m->use_llmnr = true;
401
402         r = parse_dns_server_string(m, DNS_SERVERS);
403         if (r < 0)
404                 return r;
405
406         m->hostname = gethostname_malloc();
407         if (!m->hostname)
408                 return -ENOMEM;
409
410         r = sd_event_default(&m->event);
411         if (r < 0)
412                 return r;
413
414         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
415         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
416
417         sd_event_set_watchdog(m->event, true);
418
419         r = dns_scope_new(m, &m->unicast_scope, NULL, DNS_PROTOCOL_DNS, AF_UNSPEC);
420         if (r < 0)
421                 return r;
422
423         r = manager_network_monitor_listen(m);
424         if (r < 0)
425                 return r;
426
427         r = manager_rtnl_listen(m);
428         if (r < 0)
429                 return r;
430
431         r = manager_connect_bus(m);
432         if (r < 0)
433                 return r;
434
435         r = manager_llmnr_ipv4_udp_fd(m);
436         if (r < 0)
437                 return r;
438         r = manager_llmnr_ipv6_udp_fd(m);
439         if (r < 0)
440                 return r;
441         r = manager_llmnr_ipv4_tcp_fd(m);
442         if (r < 0)
443                 return r;
444         r = manager_llmnr_ipv6_tcp_fd(m);
445         if (r < 0)
446                 return r;
447
448         *ret = m;
449         m = NULL;
450
451         return 0;
452 }
453
454 Manager *manager_free(Manager *m) {
455         Link *l;
456
457         if (!m)
458                 return NULL;
459
460         while (m->dns_queries)
461                 dns_query_free(m->dns_queries);
462
463         hashmap_free(m->dns_query_transactions);
464
465         while ((l = hashmap_first(m->links)))
466                link_free(l);
467         hashmap_free(m->links);
468
469         dns_scope_free(m->unicast_scope);
470
471         while (m->dns_servers)
472                 dns_server_free(m->dns_servers);
473
474         sd_event_source_unref(m->network_event_source);
475         sd_network_monitor_unref(m->network_monitor);
476
477         sd_event_source_unref(m->dns_ipv4_event_source);
478         sd_event_source_unref(m->dns_ipv6_event_source);
479         safe_close(m->dns_ipv4_fd);
480         safe_close(m->dns_ipv6_fd);
481
482         sd_event_source_unref(m->llmnr_ipv4_udp_event_source);
483         sd_event_source_unref(m->llmnr_ipv6_udp_event_source);
484         safe_close(m->llmnr_ipv4_udp_fd);
485         safe_close(m->llmnr_ipv6_udp_fd);
486
487         sd_event_source_unref(m->llmnr_ipv4_tcp_event_source);
488         sd_event_source_unref(m->llmnr_ipv6_tcp_event_source);
489         safe_close(m->llmnr_ipv4_tcp_fd);
490         safe_close(m->llmnr_ipv6_tcp_fd);
491
492         sd_event_source_unref(m->bus_retry_event_source);
493         sd_bus_unref(m->bus);
494
495         sd_event_unref(m->event);
496
497         dns_resource_key_unref(m->host_ipv4_key);
498         dns_resource_key_unref(m->host_ipv6_key);
499         free(m->hostname);
500         free(m);
501
502         return NULL;
503 }
504
505 static void write_resolve_conf_server(DnsServer *s, FILE *f, unsigned *count) {
506         _cleanup_free_ char *t  = NULL;
507         int r;
508
509         assert(s);
510         assert(f);
511         assert(count);
512
513         r = in_addr_to_string(s->family, &s->address, &t);
514        if (r < 0) {
515                 log_warning("Invalid DNS address. Ignoring.");
516                 return;
517         }
518
519         if (*count == MAXNS)
520                 fputs("# Too many DNS servers configured, the following entries may be ignored\n", f);
521
522         fprintf(f, "nameserver %s\n", t);
523         (*count) ++;
524 }
525
526 int manager_write_resolv_conf(Manager *m) {
527         const char *path = "/run/systemd/resolve/resolv.conf";
528         _cleanup_free_ char *temp_path = NULL;
529         _cleanup_fclose_ FILE *f = NULL;
530         unsigned count = 0;
531         DnsServer *s;
532         Iterator i;
533         Link *l;
534         int r;
535
536         assert(m);
537
538         r = fopen_temporary(path, &f, &temp_path);
539         if (r < 0)
540                 return r;
541
542         fchmod(fileno(f), 0644);
543
544         fputs("# This file is managed by systemd-resolved(8). Do not edit.\n#\n"
545               "# Third party programs must not access this file directly, but\n"
546               "# only through the symlink at /etc/resolv.conf. To manage\n"
547               "# resolv.conf(5) in a different way, replace the symlink by a\n"
548               "# static file or a different symlink.\n\n", f);
549
550         HASHMAP_FOREACH(l, m->links, i)
551                 LIST_FOREACH(servers, s, l->dns_servers)
552                         write_resolve_conf_server(s, f, &count);
553
554         LIST_FOREACH(servers, s, m->dns_servers)
555                 write_resolve_conf_server(s, f, &count);
556
557         r = fflush_and_check(f);
558         if (r < 0)
559                 goto fail;
560
561         if (rename(temp_path, path) < 0) {
562                 r = -errno;
563                 goto fail;
564         }
565
566         return 0;
567
568 fail:
569         unlink(path);
570         unlink(temp_path);
571         return r;
572 }
573
574 int manager_recv(Manager *m, int fd, DnsProtocol protocol, DnsPacket **ret) {
575         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
576         union {
577                 struct cmsghdr header; /* For alignment */
578                 uint8_t buffer[CMSG_SPACE(MAX(sizeof(struct in_pktinfo), sizeof(struct in6_pktinfo)))
579                                + CMSG_SPACE(int) /* ttl/hoplimit */
580                                + EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */];
581         } control;
582         union sockaddr_union sa;
583         struct msghdr mh = {};
584         struct cmsghdr *cmsg;
585         struct iovec iov;
586         int ms = 0, r;
587         ssize_t l;
588
589         assert(m);
590         assert(fd >= 0);
591         assert(ret);
592
593         r = ioctl(fd, FIONREAD, &ms);
594         if (r < 0)
595                 return -errno;
596         if (ms < 0)
597                 return -EIO;
598
599         r = dns_packet_new(&p, protocol, ms);
600         if (r < 0)
601                 return r;
602
603         iov.iov_base = DNS_PACKET_DATA(p);
604         iov.iov_len = p->allocated;
605
606         mh.msg_name = &sa.sa;
607         mh.msg_namelen = sizeof(sa);
608         mh.msg_iov = &iov;
609         mh.msg_iovlen = 1;
610         mh.msg_control = &control;
611         mh.msg_controllen = sizeof(control);
612
613         l = recvmsg(fd, &mh, 0);
614         if (l < 0) {
615                 if (errno == EAGAIN || errno == EINTR)
616                         return 0;
617
618                 return -errno;
619         }
620
621         if (l <= 0)
622                 return -EIO;
623
624         assert(!(mh.msg_flags & MSG_CTRUNC));
625         assert(!(mh.msg_flags & MSG_TRUNC));
626
627         p->size = (size_t) l;
628
629         p->family = sa.sa.sa_family;
630         p->ipproto = IPPROTO_UDP;
631         if (p->family == AF_INET) {
632                 p->sender.in = sa.in.sin_addr;
633                 p->sender_port = be16toh(sa.in.sin_port);
634         } else if (p->family == AF_INET6) {
635                 p->sender.in6 = sa.in6.sin6_addr;
636                 p->sender_port = be16toh(sa.in6.sin6_port);
637                 p->ifindex = sa.in6.sin6_scope_id;
638         } else
639                 return -EAFNOSUPPORT;
640
641         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
642
643                 if (cmsg->cmsg_level == IPPROTO_IPV6) {
644                         assert(p->family == AF_INET6);
645
646                         switch (cmsg->cmsg_type) {
647
648                         case IPV6_PKTINFO: {
649                                 struct in6_pktinfo *i = (struct in6_pktinfo*) CMSG_DATA(cmsg);
650
651                                 if (p->ifindex <= 0)
652                                         p->ifindex = i->ipi6_ifindex;
653
654                                 p->destination.in6 = i->ipi6_addr;
655                                 break;
656                         }
657
658                         case IPV6_HOPLIMIT:
659                                 p->ttl = *(int *) CMSG_DATA(cmsg);
660                                 break;
661
662                         }
663                 } else if (cmsg->cmsg_level == IPPROTO_IP) {
664                         assert(p->family == AF_INET);
665
666                         switch (cmsg->cmsg_type) {
667
668                         case IP_PKTINFO: {
669                                 struct in_pktinfo *i = (struct in_pktinfo*) CMSG_DATA(cmsg);
670
671                                 if (p->ifindex <= 0)
672                                         p->ifindex = i->ipi_ifindex;
673
674                                 p->destination.in = i->ipi_addr;
675                                 break;
676                         }
677
678                         case IP_TTL:
679                                 p->ttl = *(int *) CMSG_DATA(cmsg);
680                                 break;
681                         }
682                 }
683         }
684
685         /* The Linux kernel sets the interface index to the loopback
686          * device if the packet came from the local host since it
687          * avoids the routing table in such a case. Let's unset the
688          * interface index in such a case. */
689         if (p->ifindex > 0 && manager_ifindex_is_loopback(m, p->ifindex) != 0)
690                 p->ifindex = 0;
691
692         /* If we don't know the interface index still, we look for the
693          * first local interface with a matching address. Yuck! */
694         if (p->ifindex <= 0)
695                 p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
696
697         *ret = p;
698         p = NULL;
699
700         return 1;
701 }
702
703 static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
704         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
705         DnsQueryTransaction *t = NULL;
706         Manager *m = userdata;
707         int r;
708
709         r = manager_recv(m, fd, DNS_PROTOCOL_DNS, &p);
710         if (r <= 0)
711                 return r;
712
713         if (dns_packet_validate_reply(p) > 0) {
714                 t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
715                 if (!t)
716                         return 0;
717
718                 dns_query_transaction_process_reply(t, p);
719
720         } else
721                 log_debug("Invalid DNS packet.");
722
723         return 0;
724 }
725
726 int manager_dns_ipv4_fd(Manager *m) {
727         const int one = 1;
728         int r;
729
730         assert(m);
731
732         if (m->dns_ipv4_fd >= 0)
733                 return m->dns_ipv4_fd;
734
735         m->dns_ipv4_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
736         if (m->dns_ipv4_fd < 0)
737                 return -errno;
738
739         r = setsockopt(m->dns_ipv4_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
740         if (r < 0) {
741                 r = -errno;
742                 goto fail;
743         }
744
745         r = sd_event_add_io(m->event, &m->dns_ipv4_event_source, m->dns_ipv4_fd, EPOLLIN, on_dns_packet, m);
746         if (r < 0)
747                 goto fail;
748
749         return m->dns_ipv4_fd;
750
751 fail:
752         m->dns_ipv4_fd = safe_close(m->dns_ipv4_fd);
753         return r;
754 }
755
756 int manager_dns_ipv6_fd(Manager *m) {
757         const int one = 1;
758         int r;
759
760         assert(m);
761
762         if (m->dns_ipv6_fd >= 0)
763                 return m->dns_ipv6_fd;
764
765         m->dns_ipv6_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
766         if (m->dns_ipv6_fd < 0)
767                 return -errno;
768
769         r = setsockopt(m->dns_ipv6_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
770         if (r < 0) {
771                 r = -errno;
772                 goto fail;
773         }
774
775         r = sd_event_add_io(m->event, &m->dns_ipv6_event_source, m->dns_ipv6_fd, EPOLLIN, on_dns_packet, m);
776         if (r < 0)
777                 goto fail;
778
779         return m->dns_ipv6_fd;
780
781 fail:
782         m->dns_ipv6_fd = safe_close(m->dns_ipv6_fd);
783         return r;
784 }
785
786 static int sendmsg_loop(int fd, struct msghdr *mh, int flags) {
787         int r;
788
789         assert(fd >= 0);
790         assert(mh);
791
792         for (;;) {
793                 if (sendmsg(fd, mh, flags) >= 0)
794                         return 0;
795
796                 if (errno == EINTR)
797                         continue;
798
799                 if (errno != EAGAIN)
800                         return -errno;
801
802                 r = fd_wait_for_event(fd, POLLOUT, SEND_TIMEOUT_USEC);
803                 if (r < 0)
804                         return r;
805                 if (r == 0)
806                         return -ETIMEDOUT;
807         }
808 }
809
810 static int manager_ipv4_send(Manager *m, int fd, int ifindex, const struct in_addr *addr, uint16_t port, DnsPacket *p) {
811         union sockaddr_union sa = {
812                 .in.sin_family = AF_INET,
813         };
814         union {
815                 struct cmsghdr header; /* For alignment */
816                 uint8_t buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
817         } control;
818         struct msghdr mh = {};
819         struct iovec iov;
820
821         assert(m);
822         assert(fd >= 0);
823         assert(addr);
824         assert(port > 0);
825         assert(p);
826
827         iov.iov_base = DNS_PACKET_DATA(p);
828         iov.iov_len = p->size;
829
830         sa.in.sin_addr = *addr;
831         sa.in.sin_port = htobe16(port),
832
833         mh.msg_iov = &iov;
834         mh.msg_iovlen = 1;
835         mh.msg_name = &sa.sa;
836         mh.msg_namelen = sizeof(sa.in);
837
838         if (ifindex > 0) {
839                 struct cmsghdr *cmsg;
840                 struct in_pktinfo *pi;
841
842                 zero(control);
843
844                 mh.msg_control = &control;
845                 mh.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo));
846
847                 cmsg = CMSG_FIRSTHDR(&mh);
848                 cmsg->cmsg_len = mh.msg_controllen;
849                 cmsg->cmsg_level = IPPROTO_IP;
850                 cmsg->cmsg_type = IP_PKTINFO;
851
852                 pi = (struct in_pktinfo*) CMSG_DATA(cmsg);
853                 pi->ipi_ifindex = ifindex;
854         }
855
856         return sendmsg_loop(fd, &mh, 0);
857 }
858
859 static int manager_ipv6_send(Manager *m, int fd, int ifindex, const struct in6_addr *addr, uint16_t port, DnsPacket *p) {
860         union sockaddr_union sa = {
861                 .in6.sin6_family = AF_INET6,
862         };
863         union {
864                 struct cmsghdr header; /* For alignment */
865                 uint8_t buffer[CMSG_SPACE(sizeof(struct in6_pktinfo))];
866         } control;
867         struct msghdr mh = {};
868         struct iovec iov;
869
870         assert(m);
871         assert(fd >= 0);
872         assert(addr);
873         assert(port > 0);
874         assert(p);
875
876         iov.iov_base = DNS_PACKET_DATA(p);
877         iov.iov_len = p->size;
878
879         sa.in6.sin6_addr = *addr;
880         sa.in6.sin6_port = htobe16(port),
881         sa.in6.sin6_scope_id = ifindex;
882
883         mh.msg_iov = &iov;
884         mh.msg_iovlen = 1;
885         mh.msg_name = &sa.sa;
886         mh.msg_namelen = sizeof(sa.in6);
887
888         if (ifindex > 0) {
889                 struct cmsghdr *cmsg;
890                 struct in6_pktinfo *pi;
891
892                 zero(control);
893
894                 mh.msg_control = &control;
895                 mh.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo));
896
897                 cmsg = CMSG_FIRSTHDR(&mh);
898                 cmsg->cmsg_len = mh.msg_controllen;
899                 cmsg->cmsg_level = IPPROTO_IPV6;
900                 cmsg->cmsg_type = IPV6_PKTINFO;
901
902                 pi = (struct in6_pktinfo*) CMSG_DATA(cmsg);
903                 pi->ipi6_ifindex = ifindex;
904         }
905
906         return sendmsg_loop(fd, &mh, 0);
907 }
908
909 int manager_send(Manager *m, int fd, int ifindex, int family, const union in_addr_union *addr, uint16_t port, DnsPacket *p) {
910         assert(m);
911         assert(fd >= 0);
912         assert(addr);
913         assert(port > 0);
914         assert(p);
915
916         log_debug("Sending %s packet with id %u on interface %i/%s", DNS_PACKET_QR(p) ? "response" : "query", DNS_PACKET_ID(p), ifindex, af_to_name(family));
917
918         if (family == AF_INET)
919                 return manager_ipv4_send(m, fd, ifindex, &addr->in, port, p);
920         else if (family == AF_INET6)
921                 return manager_ipv6_send(m, fd, ifindex, &addr->in6, port, p);
922
923         return -EAFNOSUPPORT;
924 }
925
926 DnsServer* manager_find_dns_server(Manager *m, int family, const union in_addr_union *in_addr) {
927         DnsServer *s;
928
929         assert(m);
930         assert(in_addr);
931
932         LIST_FOREACH(servers, s, m->dns_servers) {
933
934                 if (s->family == family &&
935                     in_addr_equal(family, &s->address, in_addr))
936                         return s;
937         }
938
939         return NULL;
940 }
941
942 DnsServer *manager_get_dns_server(Manager *m) {
943         assert(m);
944
945         if (!m->current_dns_server)
946                 m->current_dns_server = m->dns_servers;
947
948         return m->current_dns_server;
949 }
950
951 void manager_next_dns_server(Manager *m) {
952         assert(m);
953
954         if (!m->current_dns_server) {
955                 m->current_dns_server = m->dns_servers;
956                 return;
957         }
958
959         if (!m->current_dns_server)
960                 return;
961
962         if (m->current_dns_server->servers_next) {
963                 m->current_dns_server = m->current_dns_server->servers_next;
964                 return;
965         }
966
967         m->current_dns_server = m->dns_servers;
968 }
969
970 uint32_t manager_find_mtu(Manager *m) {
971         uint32_t mtu = 0;
972         Link *l;
973         Iterator i;
974
975         /* If we don't know on which link a DNS packet would be
976          * delivered, let's find the largest MTU that works on all
977          * interfaces we know of */
978
979         HASHMAP_FOREACH(l, m->links, i) {
980                 if (l->mtu <= 0)
981                         continue;
982
983                 if (mtu <= 0 || l->mtu < mtu)
984                         mtu = l->mtu;
985         }
986
987         return mtu;
988 }
989
990 static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
991         _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
992         DnsQueryTransaction *t = NULL;
993         Manager *m = userdata;
994         int r;
995
996         r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
997         if (r <= 0)
998                 return r;
999
1000         if (dns_packet_validate_reply(p) > 0) {
1001                 log_debug("Got reply packet for id %u", DNS_PACKET_ID(p));
1002
1003                 t = hashmap_get(m->dns_query_transactions, UINT_TO_PTR(DNS_PACKET_ID(p)));
1004                 if (!t)
1005                         return 0;
1006
1007                 dns_query_transaction_process_reply(t, p);
1008
1009         } else if (dns_packet_validate_query(p) > 0) {
1010                 Link *l;
1011
1012                 l = hashmap_get(m->links, INT_TO_PTR(p->ifindex));
1013                 if (l) {
1014                         DnsScope *scope = NULL;
1015
1016                         if (p->family == AF_INET)
1017                                 scope = l->llmnr_ipv4_scope;
1018                         else if (p->family == AF_INET6)
1019                                 scope = l->llmnr_ipv6_scope;
1020
1021                         if (scope)
1022                                 dns_scope_process_query(scope, NULL, p);
1023                 }
1024         } else
1025                 log_debug("Invalid LLMNR packet.");
1026
1027         return 0;
1028 }
1029
1030 int manager_llmnr_ipv4_udp_fd(Manager *m) {
1031         union sockaddr_union sa = {
1032                 .in.sin_family = AF_INET,
1033                 .in.sin_port = htobe16(5355),
1034         };
1035         static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255;
1036         int r;
1037
1038         assert(m);
1039
1040         if (m->llmnr_ipv4_udp_fd >= 0)
1041                 return m->llmnr_ipv4_udp_fd;
1042
1043         m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1044         if (m->llmnr_ipv4_udp_fd < 0)
1045                 return -errno;
1046
1047         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1048         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
1049         if (r < 0) {
1050                 r = -errno;
1051                 goto fail;
1052         }
1053
1054         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
1055         if (r < 0) {
1056                 r = -errno;
1057                 goto fail;
1058         }
1059
1060         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one));
1061         if (r < 0) {
1062                 r = -errno;
1063                 goto fail;
1064         }
1065
1066         r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1067         if (r < 0) {
1068                 r = -errno;
1069                 goto fail;
1070         }
1071
1072         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1073         if (r < 0) {
1074                 r = -errno;
1075                 goto fail;
1076         }
1077
1078         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1079         if (r < 0) {
1080                 r = -errno;
1081                 goto fail;
1082         }
1083
1084         /* Disable Don't-Fragment bit in the IP header */
1085         r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1086         if (r < 0) {
1087                 r = -errno;
1088                 goto fail;
1089         }
1090
1091         r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in));
1092         if (r < 0) {
1093                 r = -errno;
1094                 goto fail;
1095         }
1096
1097         r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m);
1098         if (r < 0)
1099                 goto fail;
1100
1101         return m->llmnr_ipv4_udp_fd;
1102
1103 fail:
1104         m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd);
1105         return r;
1106 }
1107
1108 int manager_llmnr_ipv6_udp_fd(Manager *m) {
1109         union sockaddr_union sa = {
1110                 .in6.sin6_family = AF_INET6,
1111                 .in6.sin6_port = htobe16(5355),
1112         };
1113         static const int one = 1, ttl = 255;
1114         int r;
1115
1116         assert(m);
1117
1118         if (m->llmnr_ipv6_udp_fd >= 0)
1119                 return m->llmnr_ipv6_udp_fd;
1120
1121         m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1122         if (m->llmnr_ipv6_udp_fd < 0)
1123                 return -errno;
1124
1125         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
1126         if (r < 0) {
1127                 r = -errno;
1128                 goto fail;
1129         }
1130
1131         /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */
1132         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
1133         if (r < 0) {
1134                 r = -errno;
1135                 goto fail;
1136         }
1137
1138         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
1139         if (r < 0) {
1140                 r = -errno;
1141                 goto fail;
1142         }
1143
1144         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1145         if (r < 0) {
1146                 r = -errno;
1147                 goto fail;
1148         }
1149
1150         r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1151         if (r < 0) {
1152                 r = -errno;
1153                 goto fail;
1154         }
1155
1156         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1157         if (r < 0) {
1158                 r = -errno;
1159                 goto fail;
1160         }
1161
1162         r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1163         if (r < 0) {
1164                 r = -errno;
1165                 goto fail;
1166         }
1167
1168         r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6));
1169         if (r < 0) {
1170                 r = -errno;
1171                 goto fail;
1172         }
1173
1174         r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m);
1175         if (r < 0)  {
1176                 r = -errno;
1177                 goto fail;
1178         }
1179
1180         return m->llmnr_ipv6_udp_fd;
1181
1182 fail:
1183         m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd);
1184         return r;
1185 }
1186
1187 static int on_llmnr_stream_packet(DnsStream *s) {
1188         assert(s);
1189
1190         if (dns_packet_validate_query(s->read_packet) > 0) {
1191                 Link *l;
1192
1193                 l = hashmap_get(s->manager->links, INT_TO_PTR(s->read_packet->ifindex));
1194                 if (l) {
1195                         DnsScope *scope = NULL;
1196
1197                         if (s->read_packet->family == AF_INET)
1198                                 scope = l->llmnr_ipv4_scope;
1199                         else if (s->read_packet->family == AF_INET6)
1200                                 scope = l->llmnr_ipv6_scope;
1201
1202                         if (scope) {
1203                                 dns_scope_process_query(scope, s, s->read_packet);
1204
1205                                 /* If no reply packet was set, we free the stream */
1206                                 if (s->write_packet)
1207                                         return 0;
1208                         }
1209                 }
1210         }
1211
1212         dns_stream_free(s);
1213         return 0;
1214 }
1215
1216 static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1217         DnsStream *stream;
1218         Manager *m = userdata;
1219         int cfd, r;
1220
1221         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1222         if (cfd < 0) {
1223                 if (errno == EAGAIN || errno == EINTR)
1224                         return 0;
1225
1226                 return -errno;
1227         }
1228
1229         r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd);
1230         if (r < 0) {
1231                 safe_close(cfd);
1232                 return r;
1233         }
1234
1235         stream->on_packet = on_llmnr_stream_packet;
1236         return 0;
1237 }
1238
1239 int manager_llmnr_ipv4_tcp_fd(Manager *m) {
1240         union sockaddr_union sa = {
1241                 .in.sin_family = AF_INET,
1242                 .in.sin_port = htobe16(5355),
1243         };
1244         static const int one = 1, pmtu = IP_PMTUDISC_DONT;
1245         int r;
1246
1247         assert(m);
1248
1249         if (m->llmnr_ipv4_tcp_fd >= 0)
1250                 return m->llmnr_ipv4_tcp_fd;
1251
1252         m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1253         if (m->llmnr_ipv4_tcp_fd < 0)
1254                 return -errno;
1255
1256         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1257         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one));
1258         if (r < 0) {
1259                 r = -errno;
1260                 goto fail;
1261         }
1262
1263         r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1264         if (r < 0) {
1265                 r = -errno;
1266                 goto fail;
1267         }
1268
1269         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
1270         if (r < 0) {
1271                 r = -errno;
1272                 goto fail;
1273         }
1274
1275         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one));
1276         if (r < 0) {
1277                 r = -errno;
1278                 goto fail;
1279         }
1280
1281         /* Disable Don't-Fragment bit in the IP header */
1282         r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
1283         if (r < 0) {
1284                 r = -errno;
1285                 goto fail;
1286         }
1287
1288         r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in));
1289         if (r < 0) {
1290                 r = -errno;
1291                 goto fail;
1292         }
1293
1294         r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN);
1295         if (r < 0) {
1296                 r = -errno;
1297                 goto fail;
1298         }
1299
1300         r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1301         if (r < 0)
1302                 goto fail;
1303
1304         return m->llmnr_ipv4_tcp_fd;
1305
1306 fail:
1307         m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd);
1308         return r;
1309 }
1310
1311 int manager_llmnr_ipv6_tcp_fd(Manager *m) {
1312         union sockaddr_union sa = {
1313                 .in6.sin6_family = AF_INET6,
1314                 .in6.sin6_port = htobe16(5355),
1315         };
1316         static const int one = 1;
1317         int r;
1318
1319         assert(m);
1320
1321         if (m->llmnr_ipv6_tcp_fd >= 0)
1322                 return m->llmnr_ipv6_tcp_fd;
1323
1324         m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1325         if (m->llmnr_ipv6_tcp_fd < 0)
1326                 return -errno;
1327
1328         /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */
1329         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one));
1330         if (r < 0) {
1331                 r = -errno;
1332                 goto fail;
1333         }
1334
1335         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
1336         if (r < 0) {
1337                 r = -errno;
1338                 goto fail;
1339         }
1340
1341         r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1342         if (r < 0) {
1343                 r = -errno;
1344                 goto fail;
1345         }
1346
1347         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
1348         if (r < 0) {
1349                 r = -errno;
1350                 goto fail;
1351         }
1352
1353         r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one));
1354         if (r < 0) {
1355                 r = -errno;
1356                 goto fail;
1357         }
1358
1359         r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6));
1360         if (r < 0) {
1361                 r = -errno;
1362                 goto fail;
1363         }
1364
1365         r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN);
1366         if (r < 0) {
1367                 r = -errno;
1368                 goto fail;
1369         }
1370
1371         r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m);
1372         if (r < 0)  {
1373                 r = -errno;
1374                 goto fail;
1375         }
1376
1377         return m->llmnr_ipv6_tcp_fd;
1378
1379 fail:
1380         m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd);
1381         return r;
1382 }
1383
1384 int manager_ifindex_is_loopback(Manager *m, int ifindex) {
1385         Link *l;
1386         assert(m);
1387
1388         if (ifindex <= 0)
1389                 return -EINVAL;
1390
1391         l = hashmap_get(m->links, INT_TO_PTR(ifindex));
1392         if (l->flags & IFF_LOOPBACK)
1393                 return 1;
1394
1395         return 0;
1396 }
1397
1398 int manager_find_ifindex(Manager *m, int family, const union in_addr_union *in_addr) {
1399         Link *l;
1400         Iterator i;
1401
1402         assert(m);
1403
1404         HASHMAP_FOREACH(l, m->links, i)
1405                 if (link_find_address(l, family, in_addr))
1406                         return l->ifindex;
1407
1408         return 0;
1409 }