| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#include "sd-event.h" |
| 4 |
#include "alloc-util.h" |
| 5 |
#include "assert-util.h" |
| 6 |
#include "log.h" |
| 7 |
#include "resolved-manager.h" |
| 8 |
#include "resolved-socket-graveyard.h" |
| 9 |
#include "time-util.h" |
| 10 |
|
| 11 |
#define SOCKET_GRAVEYARD_USEC (5 * USEC_PER_SEC) |
| 12 |
#define SOCKET_GRAVEYARD_MAX 100 |
| 13 |
|
| 14 |
/* This implements a socket "graveyard" for UDP sockets. If a socket fd is added to the graveyard it is kept |
| 15 |
* open for a couple of more seconds, expecting one reply. Once the reply is received the fd is closed |
| 16 |
* immediately, or if none is received it is closed after the timeout. Why all this? So that if we contact a |
| 17 |
* DNS server, and it doesn't reply instantly, and we lose interest in the response and thus close the fd, we |
| 18 |
* don't end up sending back an ICMP error once the server responds but we aren't listening anymore. (See |
| 19 |
* https://github.com/systemd/systemd/issues/17421 for further information.) |
| 20 |
* |
| 21 |
* Note that we don't allocate any timer event source to clear up the graveyard once the socket's timeout is |
| 22 |
* reached. Instead we operate lazily: we close old entries when adding a new fd to the graveyard, or |
| 23 |
* whenever any code runs manager_socket_graveyard_process() — which the DNS transaction code does right |
| 24 |
* before allocating a new UDP socket. */ |
| 25 |
|
| 26 |
static SocketGraveyard* socket_graveyard_free(SocketGraveyard *g) { |
| 27 |
if (!g) |
| 28 |
return NULL; |
| 29 |
|
| 30 |
if (g->manager) { |
| 31 |
assert(g->manager->n_socket_graveyard > 0); |
| 32 |
g->manager->n_socket_graveyard--; |
| 33 |
|
| 34 |
if (g->manager->socket_graveyard_oldest == g) |
| 35 |
g->manager->socket_graveyard_oldest = g->graveyard_prev; |
| 36 |
|
| 37 |
LIST_REMOVE(graveyard, g->manager->socket_graveyard, g); |
| 38 |
|
| 39 |
assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard); |
| 40 |
assert((g->manager->n_socket_graveyard > 0) == !!g->manager->socket_graveyard_oldest); |
| 41 |
} |
| 42 |
|
| 43 |
if (g->io_event_source) { |
| 44 |
log_debug("Closing graveyard socket fd %i", sd_event_source_get_io_fd(g->io_event_source)); |
| 45 |
sd_event_source_disable_unref(g->io_event_source); |
| 46 |
} |
| 47 |
|
| 48 |
return mfree(g); |
| 49 |
} |
| 50 |
|
| 51 |
DEFINE_TRIVIAL_CLEANUP_FUNC(SocketGraveyard*, socket_graveyard_free); |
| 52 |
|
| 53 |
void manager_socket_graveyard_process(Manager *m) { |
| 54 |
usec_t n = USEC_INFINITY; |
| 55 |
|
| 56 |
assert(m); |
| 57 |
|
| 58 |
while (m->socket_graveyard_oldest) { |
| 59 |
SocketGraveyard *g = m->socket_graveyard_oldest; |
| 60 |
|
| 61 |
if (n == USEC_INFINITY) |
| 62 |
assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &n) >= 0); |
| 63 |
|
| 64 |
if (g->deadline > n) |
| 65 |
break; |
| 66 |
|
| 67 |
socket_graveyard_free(g); |
| 68 |
} |
| 69 |
} |
| 70 |
|
| 71 |
void manager_socket_graveyard_clear(Manager *m) { |
| 72 |
assert(m); |
| 73 |
|
| 74 |
while (m->socket_graveyard) |
| 75 |
socket_graveyard_free(m->socket_graveyard); |
| 76 |
} |
| 77 |
|
| 78 |
static int on_io_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) { |
| 79 |
SocketGraveyard *g = ASSERT_PTR(userdata); |
| 80 |
|
| 81 |
/* An IO event happened on the graveyard fd. We don't actually care which event that is, and we don't |
| 82 |
* read any incoming packet off the socket. We just close the fd, that's enough to not trigger the |
| 83 |
* ICMP unreachable port event */ |
| 84 |
|
| 85 |
socket_graveyard_free(g); |
| 86 |
return 0; |
| 87 |
} |
| 88 |
|
| 89 |
static void manager_socket_graveyard_make_room(Manager *m) { |
| 90 |
assert(m); |
| 91 |
|
| 92 |
while (m->n_socket_graveyard >= SOCKET_GRAVEYARD_MAX) |
| 93 |
socket_graveyard_free(m->socket_graveyard_oldest); |
| 94 |
} |
| 95 |
|
| 96 |
int manager_add_socket_to_graveyard(Manager *m, int fd) { |
| 97 |
_cleanup_(socket_graveyard_freep) SocketGraveyard *g = NULL; |
| 98 |
int r; |
| 99 |
|
| 100 |
assert(m); |
| 101 |
assert(fd >= 0); |
| 102 |
|
| 103 |
manager_socket_graveyard_process(m); |
| 104 |
manager_socket_graveyard_make_room(m); |
| 105 |
|
| 106 |
g = new(SocketGraveyard, 1); |
| 107 |
if (!g) |
| 108 |
return log_oom(); |
| 109 |
|
| 110 |
*g = (SocketGraveyard) { |
| 111 |
.manager = m, |
| 112 |
}; |
| 113 |
|
| 114 |
LIST_PREPEND(graveyard, m->socket_graveyard, g); |
| 115 |
if (!m->socket_graveyard_oldest) |
| 116 |
m->socket_graveyard_oldest = g; |
| 117 |
|
| 118 |
m->n_socket_graveyard++; |
| 119 |
|
| 120 |
assert_se(sd_event_now(m->event, CLOCK_BOOTTIME, &g->deadline) >= 0); |
| 121 |
g->deadline += SOCKET_GRAVEYARD_USEC; |
| 122 |
|
| 123 |
r = sd_event_add_io(m->event, &g->io_event_source, fd, EPOLLIN, on_io_event, g); |
| 124 |
if (r < 0) |
| 125 |
return log_error_errno(r, "Failed to create graveyard IO source: %m"); |
| 126 |
|
| 127 |
r = sd_event_source_set_io_fd_own(g->io_event_source, true); |
| 128 |
if (r < 0) |
| 129 |
return log_error_errno(r, "Failed to enable graveyard IO source fd ownership: %m"); |
| 130 |
|
| 131 |
(void) sd_event_source_set_description(g->io_event_source, "graveyard"); |
| 132 |
|
| 133 |
log_debug("Added socket %i to graveyard", fd); |
| 134 |
|
| 135 |
TAKE_PTR(g); |
| 136 |
return 0; |
| 137 |
} |