SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

shared: rename internal variables in SimplexForwarder

Browse Source 
The SimplexForwader was using the naming of the SocketForwarder
for bi-directional sockets. This was to keep the diff small and
to make it easier to follow what changed and what was reused.

However the name "client/server" for the SimplexForwader does
no longer make much sense. The SimplexForwader is no longer
about client/server but really just read/write. So this commit
adjusts the naming.
This commit is contained in:
Michael Vogt
2026-03-31 18:25:09 +02:00
parent 1af2d1c3e1
commit 555dde10a0
1 changed files with 42 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/shared/socket-forward.c
+42 -42
View File
@@ -14,18 +14,18 @@
#define SOCKET_FORWARD_BUFFER_SIZE (256 * 1024)
/* Half-duplex forwarder: splices data from server_fd to client_fd via a kernel pipe buffer.
/* Unidirectional forwarder: splices data from read_fd to write_fd via a kernel pipe buffer.
* Each direction of a full-duplex SocketForward is handled by one of these. */
typedef struct SimplexForward {
sd_event *event;
int server_fd, client_fd;
int read_fd, write_fd;
int server_to_client_buffer[2]; /* a pipe */
int buffer[2]; /* a pipe */
size_t server_to_client_buffer_full, server_to_client_buffer_size;
size_t buffer_full, buffer_size;
sd_event_source *server_event_source, *client_event_source;
sd_event_source *read_event_source, *write_event_source;
int (*on_done)(struct SimplexForward *fwd, int error, void *userdata);
void *userdata;
@@ -35,13 +35,13 @@ static SimplexForward* simplex_forward_free(SimplexForward *fwd) {
if (!fwd)
return NULL;
sd_event_source_unref(fwd->server_event_source);
sd_event_source_unref(fwd->client_event_source);
sd_event_source_unref(fwd->read_event_source);
sd_event_source_unref(fwd->write_event_source);
safe_close(fwd->server_fd);
safe_close(fwd->client_fd);
safe_close(fwd->read_fd);
safe_close(fwd->write_fd);
safe_close_pair(fwd->server_to_client_buffer);
safe_close_pair(fwd->buffer);
sd_event_unref(fwd->event);
@@ -131,18 +131,18 @@ static int simplex_forward_traffic(SimplexForward *fwd) {
int r;
r = simplex_forward_shovel(
&fwd->server_fd, fwd->server_to_client_buffer, &fwd->client_fd,
&fwd->server_to_client_buffer_full, &fwd->server_to_client_buffer_size,
&fwd->server_event_source, &fwd->client_event_source);
&fwd->read_fd, fwd->buffer, &fwd->write_fd,
&fwd->buffer_full, &fwd->buffer_size,
&fwd->read_event_source, &fwd->write_event_source);
if (r < 0)
goto quit;
/* Server closed, and all data written to client? */
if (fwd->server_fd < 0 && fwd->server_to_client_buffer_full <= 0)
/* Read side closed and all buffered data written? */
if (fwd->read_fd < 0 && fwd->buffer_full <= 0)
goto quit;
/* Write side closed? */
if (fwd->client_fd < 0)
if (fwd->write_fd < 0)
goto quit;
r = simplex_forward_enable_event_sources(fwd);
@@ -152,8 +152,8 @@ static int simplex_forward_traffic(SimplexForward *fwd) {
return 1;
quit:
fwd->server_event_source = sd_event_source_disable_unref(fwd->server_event_source);
fwd->client_event_source = sd_event_source_disable_unref(fwd->client_event_source);
fwd->read_event_source = sd_event_source_disable_unref(fwd->read_event_source);
fwd->write_event_source = sd_event_source_disable_unref(fwd->write_event_source);
return fwd->on_done(fwd, r, fwd->userdata);
}
@@ -175,20 +175,20 @@ static int simplex_forward_enable_event_sources(SimplexForward *fwd) {
assert(fwd);
can_read = fwd->server_to_client_buffer_full < fwd->server_to_client_buffer_size;
can_write = fwd->server_to_client_buffer_full > 0;
can_read = fwd->buffer_full < fwd->buffer_size;
can_write = fwd->buffer_full > 0;
/* Event sources may have been unref'd by the shovel on EOF/disconnect */
if (fwd->server_event_source) {
r = sd_event_source_set_enabled(fwd->server_event_source, can_read ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
if (fwd->read_event_source) {
r = sd_event_source_set_enabled(fwd->read_event_source, can_read ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
if (r < 0)
return log_debug_errno(r, "Failed to update server event source: %m");
return log_debug_errno(r, "Failed to update read event source: %m");
}
if (fwd->client_event_source) {
r = sd_event_source_set_enabled(fwd->client_event_source, can_write ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
if (fwd->write_event_source) {
r = sd_event_source_set_enabled(fwd->write_event_source, can_write ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
if (r < 0)
return log_debug_errno(r, "Failed to update client event source: %m");
return log_debug_errno(r, "Failed to update write event source: %m");
}
return 0;
@@ -214,8 +214,8 @@ static int simplex_forward_create_event_source(
static int simplex_forward_new(
sd_event *event,
int server_fd,
int client_fd,
int read_fd,
int write_fd,
int (*on_done)(SimplexForward *fwd, int error, void *userdata),
void *userdata,
SimplexForward **ret) {
@@ -224,37 +224,37 @@ static int simplex_forward_new(
int r;
assert(event);
assert(server_fd >= 0);
assert(client_fd >= 0);
assert(server_fd != client_fd);
assert(read_fd >= 0);
assert(write_fd >= 0);
assert(read_fd != write_fd);
assert(on_done);
assert(ret);
fwd = new(SimplexForward, 1);
if (!fwd) {
safe_close(server_fd);
safe_close(client_fd);
safe_close(read_fd);
safe_close(write_fd);
return log_oom_debug();
}
*fwd = (SimplexForward) {
.event = sd_event_ref(event),
.server_fd = server_fd,
.client_fd = client_fd,
.server_to_client_buffer = EBADF_PAIR,
.read_fd = read_fd,
.write_fd = write_fd,
.buffer = EBADF_PAIR,
.on_done = on_done,
.userdata = userdata,
};
r = socket_forward_create_pipes(fwd->server_to_client_buffer, &fwd->server_to_client_buffer_size);
r = socket_forward_create_pipes(fwd->buffer, &fwd->buffer_size);
if (r < 0)
return r;
r = simplex_forward_create_event_source(fwd, &fwd->server_event_source, fwd->server_fd, EPOLLIN);
r = simplex_forward_create_event_source(fwd, &fwd->read_event_source, fwd->read_fd, EPOLLIN);
if (r < 0)
return r;
r = simplex_forward_create_event_source(fwd, &fwd->client_event_source, fwd->client_fd, EPOLLOUT);
r = simplex_forward_create_event_source(fwd, &fwd->write_event_source, fwd->write_fd, EPOLLOUT);
if (r < 0)
return r;
@@ -296,12 +296,12 @@ static int socket_forward_direction_done(SimplexForward *fwd, int error, void *u
* (which belongs to the other direction's dup'd fd). For pipes/FIFOs,
* shutdown() fails with ENOTSOCK - close the fd instead, which is the
* only way to signal EOF on a pipe. */
if (fwd->client_fd >= 0 && shutdown(fwd->client_fd, SHUT_WR) < 0) {
if (fwd->write_fd >= 0 && shutdown(fwd->write_fd, SHUT_WR) < 0) {
if (errno == ENOTSOCK)
fwd->client_fd = safe_close(fwd->client_fd);
fwd->write_fd = safe_close(fwd->write_fd);
else
log_debug_errno(errno, "Failed to shutdown write side of fd %d: %m, ignoring",
fwd->client_fd);
fwd->write_fd);
}
if (error < 0 && sf->first_error >= 0)