src/stdio-bridge/stdio-bridge.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright 2010 Lennart Poettering
   4 ***/
   5
   6 #include <errno.h>
   7 #include <getopt.h>
   8 #include <poll.h>
   9 #include <stddef.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12
  13 #include "sd-bus.h"
  14 #include "sd-daemon.h"
  15
  16 #include "bus-internal.h"
  17 #include "bus-util.h"
  18 #include "build.h"
  19 #include "log.h"
  20 #include "util.h"
  21
  22 #define DEFAULT_BUS_PATH "unix:path=/run/dbus/system_bus_socket"
  23
  24 const char *arg_bus_path = DEFAULT_BUS_PATH;
  25
  26 static int help(void) {
  27
  28         printf("%s [OPTIONS...]\n\n"
  29                "STDIO or socket-activatable proxy to a given DBus endpoint.\n\n"
  30                "  -h --help              Show this help\n"
  31                "     --version           Show package version\n"
  32                "  -p --bus-path=PATH     Path to the kernel bus (default: %s)\n",
  33                program_invocation_short_name, DEFAULT_BUS_PATH);
  34
  35         return 0;
  36 }
  37
  38 static int parse_argv(int argc, char *argv[]) {
  39
  40         enum {
  41                 ARG_VERSION = 0x100,
  42         };
  43
  44         static const struct option options[] = {
  45                 { "help",            no_argument,       NULL, 'h'         },
  46                 { "version",         no_argument,       NULL, ARG_VERSION },
  47                 { "bus-path",        required_argument, NULL, 'p'         },
  48                 {},
  49         };
  50
  51         int c;
  52
  53         assert(argc >= 0);
  54         assert(argv);
  55
  56         while ((c = getopt_long(argc, argv, "hsup:", options, NULL)) >= 0) {
  57
  58                 switch (c) {
  59
  60                 case 'h':
  61                         help();
  62                         return 0;
  63
  64                 case ARG_VERSION:
  65                         return version();
  66
  67                 case '?':
  68                         return -EINVAL;
  69
  70                 case 'p':
  71                         arg_bus_path = optarg;
  72                         break;
  73
  74                 default:
  75                         log_error("Unknown option code %c", c);
  76                         return -EINVAL;
  77                 }
  78         }
  79
  80         return 1;
  81 }
  82
  83 int main(int argc, char *argv[]) {
  84         _cleanup_(sd_bus_unrefp) sd_bus *a = NULL, *b = NULL;
  85         sd_id128_t server_id;
  86         bool is_unix;
  87         int r, in_fd, out_fd;
  88
  89         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
  90         log_parse_environment();
  91         log_open();
  92
  93         r = parse_argv(argc, argv);
  94         if (r <= 0)
  95                 goto finish;
  96
  97         r = sd_listen_fds(0);
  98         if (r == 0) {
  99                 in_fd = STDIN_FILENO;
 100                 out_fd = STDOUT_FILENO;
 101         } else if (r == 1) {
 102                 in_fd = SD_LISTEN_FDS_START;
 103                 out_fd = SD_LISTEN_FDS_START;
 104         } else {
 105                 log_error("Illegal number of file descriptors passed.");
 106                 goto finish;
 107         }
 108
 109         is_unix =
 110                 sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
 111                 sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
 112
 113         r = sd_bus_new(&a);
 114         if (r < 0) {
 115                 log_error_errno(r, "Failed to allocate bus: %m");
 116                 goto finish;
 117         }
 118
 119         r = sd_bus_set_address(a, arg_bus_path);
 120         if (r < 0) {
 121                 log_error_errno(r, "Failed to set address to connect to: %m");
 122                 goto finish;
 123         }
 124
 125         r = sd_bus_negotiate_fds(a, is_unix);
 126         if (r < 0) {
 127                 log_error_errno(r, "Failed to set FD negotiation: %m");
 128                 goto finish;
 129         }
 130
 131         r = sd_bus_start(a);
 132         if (r < 0) {
 133                 log_error_errno(r, "Failed to start bus client: %m");
 134                 goto finish;
 135         }
 136
 137         r = sd_bus_get_bus_id(a, &server_id);
 138         if (r < 0) {
 139                 log_error_errno(r, "Failed to get server ID: %m");
 140                 goto finish;
 141         }
 142
 143         r = sd_bus_new(&b);
 144         if (r < 0) {
 145                 log_error_errno(r, "Failed to allocate bus: %m");
 146                 goto finish;
 147         }
 148
 149         r = sd_bus_set_fd(b, in_fd, out_fd);
 150         if (r < 0) {
 151                 log_error_errno(r, "Failed to set fds: %m");
 152                 goto finish;
 153         }
 154
 155         r = sd_bus_set_server(b, 1, server_id);
 156         if (r < 0) {
 157                 log_error_errno(r, "Failed to set server mode: %m");
 158                 goto finish;
 159         }
 160
 161         r = sd_bus_negotiate_fds(b, is_unix);
 162         if (r < 0) {
 163                 log_error_errno(r, "Failed to set FD negotiation: %m");
 164                 goto finish;
 165         }
 166
 167         r = sd_bus_set_anonymous(b, true);
 168         if (r < 0) {
 169                 log_error_errno(r, "Failed to set anonymous authentication: %m");
 170                 goto finish;
 171         }
 172
 173         r = sd_bus_start(b);
 174         if (r < 0) {
 175                 log_error_errno(r, "Failed to start bus client: %m");
 176                 goto finish;
 177         }
 178
 179         for (;;) {
 180                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 181                 int events_a, events_b, fd;
 182                 uint64_t timeout_a, timeout_b, t;
 183                 struct timespec _ts, *ts;
 184
 185                 r = sd_bus_process(a, &m);
 186                 if (r < 0) {
 187                         log_error_errno(r, "Failed to process bus a: %m");
 188                         goto finish;
 189                 }
 190
 191                 if (m) {
 192                         r = sd_bus_send(b, m, NULL);
 193                         if (r < 0) {
 194                                 log_error_errno(r, "Failed to send message: %m");
 195                                 goto finish;
 196                         }
 197                 }
 198
 199                 if (r > 0)
 200                         continue;
 201
 202                 r = sd_bus_process(b, &m);
 203                 if (r < 0) {
 204                         /* treat 'connection reset by peer' as clean exit condition */
 205                         if (r == -ECONNRESET)
 206                                 r = 0;
 207
 208                         goto finish;
 209                 }
 210
 211                 if (m) {
 212                         r = sd_bus_send(a, m, NULL);
 213                         if (r < 0) {
 214                                 log_error_errno(r, "Failed to send message: %m");
 215                                 goto finish;
 216                         }
 217                 }
 218
 219                 if (r > 0)
 220                         continue;
 221
 222                 fd = sd_bus_get_fd(a);
 223                 if (fd < 0) {
 224                         r = fd;
 225                         log_error_errno(r, "Failed to get fd: %m");
 226                         goto finish;
 227                 }
 228
 229                 events_a = sd_bus_get_events(a);
 230                 if (events_a < 0) {
 231                         r = events_a;
 232                         log_error_errno(r, "Failed to get events mask: %m");
 233                         goto finish;
 234                 }
 235
 236                 r = sd_bus_get_timeout(a, &timeout_a);
 237                 if (r < 0) {
 238                         log_error_errno(r, "Failed to get timeout: %m");
 239                         goto finish;
 240                 }
 241
 242                 events_b = sd_bus_get_events(b);
 243                 if (events_b < 0) {
 244                         r = events_b;
 245                         log_error_errno(r, "Failed to get events mask: %m");
 246                         goto finish;
 247                 }
 248
 249                 r = sd_bus_get_timeout(b, &timeout_b);
 250                 if (r < 0) {
 251                         log_error_errno(r, "Failed to get timeout: %m");
 252                         goto finish;
 253                 }
 254
 255                 t = timeout_a;
 256                 if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
 257                         t = timeout_b;
 258
 259                 if (t == (uint64_t) -1)
 260                         ts = NULL;
 261                 else {
 262                         usec_t nw;
 263
 264                         nw = now(CLOCK_MONOTONIC);
 265                         if (t > nw)
 266                                 t -= nw;
 267                         else
 268                                 t = 0;
 269
 270                         ts = timespec_store(&_ts, t);
 271                 }
 272
 273                 {
 274                         struct pollfd p[3] = {
 275                                 {.fd = fd,            .events = events_a, },
 276                                 {.fd = STDIN_FILENO,  .events = events_b & POLLIN, },
 277                                 {.fd = STDOUT_FILENO, .events = events_b & POLLOUT, }};
 278
 279                         r = ppoll(p, ELEMENTSOF(p), ts, NULL);
 280                 }
 281                 if (r < 0) {
 282                         log_error_errno(errno, "ppoll() failed: %m");
 283                         goto finish;
 284                 }
 285         }
 286
 287 finish:
 288         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 289 }