Debian Codegraph @

src/shared/socket-forward.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <fcntl.h>
4 #include <sys/socket.h>
5 #include <unistd.h>
6
7 #include "sd-event.h"
8
9 #include "alloc-util.h"
10 #include "errno-util.h"
11 #include "fd-util.h"
12 #include "log.h"
13 #include "socket-forward.h"
14
15 #define SOCKET_FORWARD_BUFFER_SIZE (256 * 1024)
16
17 /* Unidirectional forwarder: splices data from read_fd to write_fd via a kernel pipe buffer.
18 * Each direction of a full-duplex SocketForward is handled by one of these. */
19 typedef struct SimplexForward {
20 sd_event *event;
21
22 int read_fd, write_fd;
23
24 int buffer[2]; /* a pipe */
25
26 size_t buffer_full, buffer_size;
27
28 sd_event_source *read_event_source, *write_event_source;
29
30 int (*on_done)(struct SimplexForward *fwd, int error, void *userdata);
31 void *userdata;
32 } SimplexForward;
33
34 static SimplexForward* simplex_forward_free(SimplexForward *fwd) {
35 if (!fwd)
36 return NULL;
37
38 sd_event_source_unref(fwd->read_event_source);
39 sd_event_source_unref(fwd->write_event_source);
40
41 safe_close(fwd->read_fd);
42 safe_close(fwd->write_fd);
43
44 safe_close_pair(fwd->buffer);
45
46 sd_event_unref(fwd->event);
47
48 return mfree(fwd);
49 }
50
51 DEFINE_TRIVIAL_CLEANUP_FUNC(SimplexForward*, simplex_forward_free);
52
53 static int socket_forward_create_pipes(int buffer[static 2], size_t *ret_size) {
54 int r;
55
56 assert(buffer);
57 assert(ret_size);
58
59 if (buffer[0] >= 0)
60 return 0;
61
62 r = pipe2(buffer, O_CLOEXEC|O_NONBLOCK);
63 if (r < 0)
64 return log_debug_errno(errno, "Failed to allocate pipe buffer: %m");
65
66 (void) fcntl(buffer[0], F_SETPIPE_SZ, SOCKET_FORWARD_BUFFER_SIZE);
67
68 r = fcntl(buffer[0], F_GETPIPE_SZ);
69 if (r < 0)
70 return log_debug_errno(errno, "Failed to get pipe buffer size: %m");
71
72 assert(r > 0);
73 *ret_size = r;
74
75 return 0;
76 }
77
78 static int simplex_forward_shovel(
79 int *from, int buffer[2], int *to,
80 size_t *full, size_t *sz,
81 sd_event_source **from_source, sd_event_source **to_source) {
82
83 bool shoveled;
84
85 assert(from);
86 assert(buffer);
87 assert(buffer[0] >= 0);
88 assert(buffer[1] >= 0);
89 assert(to);
90 assert(full);
91 assert(sz);
92 assert(from_source);
93 assert(to_source);
94
95 do {
96 ssize_t z;
97
98 shoveled = false;
99
100 if (*full < *sz && *from >= 0 && *to >= 0) {
101 z = splice(*from, NULL, buffer[1], NULL, *sz - *full, SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
102 if (z > 0) {
103 *full += z;
104 shoveled = true;
105 } else if (z == 0 || ERRNO_IS_DISCONNECT(errno)) {
106 *from_source = sd_event_source_unref(*from_source);
107 *from = safe_close(*from);
108 } else if (!ERRNO_IS_TRANSIENT(errno))
109 return log_debug_errno(errno, "Failed to splice: %m");
110 }
111
112 if (*full > 0 && *to >= 0) {
113 z = splice(buffer[0], NULL, *to, NULL, *full, SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
114 if (z > 0) {
115 *full -= z;
116 shoveled = true;
117 } else if (z == 0 || ERRNO_IS_DISCONNECT(errno)) {
118 *to_source = sd_event_source_unref(*to_source);
119 *to = safe_close(*to);
120 } else if (!ERRNO_IS_TRANSIENT(errno))
121 return log_debug_errno(errno, "Failed to splice: %m");
122 }
123 } while (shoveled);
124
125 return 0;
126 }
127
128 static int simplex_forward_enable_event_sources(SimplexForward *fwd);
129
130 static int simplex_forward_traffic(SimplexForward *fwd) {
131 int r;
132
133 r = simplex_forward_shovel(
134 &fwd->read_fd, fwd->buffer, &fwd->write_fd,
135 &fwd->buffer_full, &fwd->buffer_size,
136 &fwd->read_event_source, &fwd->write_event_source);
137 if (r < 0)
138 goto quit;
139
140 /* Read side closed and all buffered data written? */
141 if (fwd->read_fd < 0 && fwd->buffer_full <= 0)
142 goto quit;
143
144 /* Write side closed? */
145 if (fwd->write_fd < 0)
146 goto quit;
147
148 r = simplex_forward_enable_event_sources(fwd);
149 if (r < 0)
150 goto quit;
151
152 return 1;
153
154 quit:
155 fwd->read_event_source = sd_event_source_disable_unref(fwd->read_event_source);
156 fwd->write_event_source = sd_event_source_disable_unref(fwd->write_event_source);
157 return fwd->on_done(fwd, r, fwd->userdata);
158 }
159
160 static int simplex_forward_io_cb(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
161 SimplexForward *fwd = ASSERT_PTR(userdata);
162
163 return simplex_forward_traffic(fwd);
164 }
165
166 static int simplex_forward_defer_cb(sd_event_source *s, void *userdata) {
167 SimplexForward *fwd = ASSERT_PTR(userdata);
168
169 return simplex_forward_traffic(fwd);
170 }
171
172 static int simplex_forward_enable_event_sources(SimplexForward *fwd) {
173 bool can_read, can_write;
174 int r;
175
176 assert(fwd);
177
178 can_read = fwd->buffer_full < fwd->buffer_size;
179 can_write = fwd->buffer_full > 0;
180
181 /* Event sources may have been unref'd by the shovel on EOF/disconnect */
182 if (fwd->read_event_source) {
183 r = sd_event_source_set_enabled(fwd->read_event_source, can_read ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
184 if (r < 0)
185 return log_debug_errno(r, "Failed to update read event source: %m");
186 }
187
188 if (fwd->write_event_source) {
189 r = sd_event_source_set_enabled(fwd->write_event_source, can_write ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
190 if (r < 0)
191 return log_debug_errno(r, "Failed to update write event source: %m");
192 }
193
194 return 0;
195 }
196
197 static int simplex_forward_create_event_source(
198 SimplexForward *fwd,
199 sd_event_source **ret,
200 int fd,
201 uint32_t events) {
202
203 int r;
204
205 r = sd_event_add_io(fwd->event, ret, fd, events, simplex_forward_io_cb, fwd);
206 if (r == -EPERM)
207 /* fd is not pollable (e.g. regular file). Fall back to a defer event source
208 * which fires on each event loop iteration. This works because regular
209 * file are always ready for I/O so we don't need to poll. */
210 r = sd_event_add_defer(fwd->event, ret, simplex_forward_defer_cb, fwd);
211
212 return r;
213 }
214
215 static int simplex_forward_new(
216 sd_event *event,
217 int read_fd,
218 int write_fd,
219 int (*on_done)(SimplexForward *fwd, int error, void *userdata),
220 void *userdata,
221 SimplexForward **ret) {
222
223 _cleanup_(simplex_forward_freep) SimplexForward *fwd = NULL;
224 int r;
225
226 assert(event);
227 assert(read_fd >= 0);
228 assert(write_fd >= 0);
229 assert(read_fd != write_fd);
230 assert(on_done);
231 assert(ret);
232
233 fwd = new(SimplexForward, 1);
234 if (!fwd) {
235 safe_close(read_fd);
236 safe_close(write_fd);
237 return log_oom_debug();
238 }
239
240 *fwd = (SimplexForward) {
241 .event = sd_event_ref(event),
242 .read_fd = read_fd,
243 .write_fd = write_fd,
244 .buffer = EBADF_PAIR,
245 .on_done = on_done,
246 .userdata = userdata,
247 };
248
249 r = socket_forward_create_pipes(fwd->buffer, &fwd->buffer_size);
250 if (r < 0)
251 return r;
252
253 r = simplex_forward_create_event_source(fwd, &fwd->read_event_source, fwd->read_fd, EPOLLIN);
254 if (r < 0)
255 return r;
256
257 r = simplex_forward_create_event_source(fwd, &fwd->write_event_source, fwd->write_fd, EPOLLOUT);
258 if (r < 0)
259 return r;
260
261 r = simplex_forward_enable_event_sources(fwd);
262 if (r < 0)
263 return r;
264
265 *ret = TAKE_PTR(fwd);
266 return 0;
267 }
268
269 /* Full-duplex forwarder from two SimplexForward instances */
270 struct SocketForward {
271 SimplexForward *server_to_client;
272 SimplexForward *client_to_server;
273
274 socket_forward_done_t on_done;
275 void *userdata;
276
277 int first_error;
278 unsigned directions_done;
279 };
280
281 SocketForward* socket_forward_free(SocketForward *sf) {
282 if (!sf)
283 return NULL;
284
285 simplex_forward_free(sf->server_to_client);
286 simplex_forward_free(sf->client_to_server);
287
288 return mfree(sf);
289 }
290
291 static int socket_forward_direction_done(SimplexForward *fwd, int error, void *userdata) {
292 SocketForward *sf = ASSERT_PTR(userdata);
293
294 /* Half-close the write side so the remote end sees EOF. For sockets,
295 * shutdown(SHUT_WR) sends FIN while keeping the fd open for the read side
296 * (which belongs to the other direction's dup'd fd). For pipes/FIFOs,
297 * shutdown() fails with ENOTSOCK - close the fd instead, which is the
298 * only way to signal EOF on a pipe. */
299 if (fwd->write_fd >= 0 && shutdown(fwd->write_fd, SHUT_WR) < 0) {
300 if (errno == ENOTSOCK)
301 fwd->write_fd = safe_close(fwd->write_fd);
302 else
303 log_debug_errno(errno, "Failed to shutdown write side of fd %d: %m, ignoring",
304 fwd->write_fd);
305 }
306
307 if (error < 0 && sf->first_error >= 0)
308 sf->first_error = error;
309
310 sf->directions_done++;
311
312 if (sf->directions_done >= 2)
313 return sf->on_done(sf, sf->first_error, sf->userdata);
314
315 return 0;
316 }
317
318 int socket_forward_new_pair(
319 sd_event *event,
320 int server_read_fd,
321 int server_write_fd,
322 int client_read_fd,
323 int client_write_fd,
324 socket_forward_done_t on_done,
325 void *userdata,
326 SocketForward **ret) {
327
328 _cleanup_close_ int server_read_fd_close = server_read_fd,
329 server_write_fd_close = server_write_fd,
330 client_read_fd_close = client_read_fd,
331 client_write_fd_close = client_write_fd;
332 _cleanup_(socket_forward_freep) SocketForward *sf = NULL;
333 int r;
334
335 assert(event);
336 assert(server_read_fd >= 0);
337 assert(server_write_fd >= 0);
338 assert(client_read_fd >= 0);
339 assert(client_write_fd >= 0);
340 assert(server_read_fd != server_write_fd);
341 assert(client_read_fd != client_write_fd);
342 assert(server_read_fd != client_read_fd);
343 assert(server_read_fd != client_write_fd);
344 assert(server_write_fd != client_read_fd);
345 assert(server_write_fd != client_write_fd);
346 assert(on_done);
347 assert(ret);
348
349 sf = new(SocketForward, 1);
350 if (!sf)
351 return log_oom_debug();
352
353 *sf = (SocketForward) {
354 .on_done = on_done,
355 .userdata = userdata,
356 };
357
358 r = simplex_forward_new(event,
359 TAKE_FD(server_read_fd_close), TAKE_FD(client_write_fd_close),
360 socket_forward_direction_done, sf,
361 &sf->server_to_client);
362 if (r < 0)
363 return r;
364
365 r = simplex_forward_new(event,
366 TAKE_FD(client_read_fd_close), TAKE_FD(server_write_fd_close),
367 socket_forward_direction_done, sf,
368 &sf->client_to_server);
369 if (r < 0)
370 return r;
371
372 *ret = TAKE_PTR(sf);
373 return 0;
374 }
375
376 int socket_forward_new(
377 sd_event *event,
378 int server_fd,
379 int client_fd,
380 socket_forward_done_t on_done,
381 void *userdata,
382 SocketForward **ret) {
383
384 _cleanup_close_ int server_fd_close = server_fd, client_fd_close = client_fd,
385 server_write_fd = -EBADF, client_write_fd = -EBADF;
386
387 assert(event);
388 assert(server_fd >= 0);
389 assert(client_fd >= 0);
390 assert(on_done);
391 assert(ret);
392
393 server_write_fd = fcntl(server_fd, F_DUPFD_CLOEXEC, 3);
394 if (server_write_fd < 0)
395 return -errno;
396
397 client_write_fd = fcntl(client_fd, F_DUPFD_CLOEXEC, 3);
398 if (client_write_fd < 0)
399 return -errno;
400
401 return socket_forward_new_pair(
402 event,
403 TAKE_FD(server_fd_close), TAKE_FD(server_write_fd),
404 TAKE_FD(client_fd_close), TAKE_FD(client_write_fd),
405 on_done, userdata, ret);
406 }