src/libsystemd/sd-bus/test-bus-chat.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <fcntl.h>
   4 #include <pthread.h>
   5 #include <stdlib.h>
   6 #include <unistd.h>
   7
   8 #include "sd-bus.h"
   9
  10 #include "alloc-util.h"
  11 #include "bus-error.h"
  12 #include "bus-internal.h"
  13 #include "bus-match.h"
  14 #include "bus-util.h"
  15 #include "fd-util.h"
  16 #include "format-util.h"
  17 #include "log.h"
  18 #include "macro.h"
  19 #include "tests.h"
  20 #include "util.h"
  21
  22 static int match_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
  23         log_info("Match triggered! interface=%s member=%s", strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)));
  24         return 0;
  25 }
  26
  27 static int object_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
  28         int r;
  29
  30         if (sd_bus_message_is_method_error(m, NULL))
  31                 return 0;
  32
  33         if (sd_bus_message_is_method_call(m, "org.object.test", "Foobar")) {
  34                 log_info("Invoked Foobar() on %s", sd_bus_message_get_path(m));
  35
  36                 r = sd_bus_reply_method_return(m, NULL);
  37                 if (r < 0)
  38                         return log_error_errno(r, "Failed to send reply: %m");
  39
  40                 return 1;
  41         }
  42
  43         return 0;
  44 }
  45
  46 static int server_init(sd_bus **_bus) {
  47         sd_bus *bus = NULL;
  48         sd_id128_t id;
  49         int r;
  50         const char *unique, *desc;
  51
  52         assert_se(_bus);
  53
  54         r = sd_bus_open_user_with_description(&bus, "my bus!");
  55         if (r < 0) {
  56                 log_error_errno(r, "Failed to connect to user bus: %m");
  57                 goto fail;
  58         }
  59
  60         r = sd_bus_get_bus_id(bus, &id);
  61         if (r < 0) {
  62                 log_error_errno(r, "Failed to get server ID: %m");
  63                 goto fail;
  64         }
  65
  66         r = sd_bus_get_unique_name(bus, &unique);
  67         if (r < 0) {
  68                 log_error_errno(r, "Failed to get unique name: %m");
  69                 goto fail;
  70         }
  71
  72         r = sd_bus_get_description(bus, &desc);
  73         assert_se(streq(desc, "my bus!"));
  74
  75         log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
  76         log_info("Unique ID: %s", unique);
  77         log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));
  78
  79         r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
  80         if (r < 0) {
  81                 log_error_errno(r, "Failed to acquire name: %m");
  82                 goto fail;
  83         }
  84
  85         r = sd_bus_add_fallback(bus, NULL, "/foo/bar", object_callback, NULL);
  86         if (r < 0) {
  87                 log_error_errno(r, "Failed to add object: %m");
  88                 goto fail;
  89         }
  90
  91         r = sd_bus_match_signal(bus, NULL, NULL, NULL, "foo.bar", "Notify", match_callback, NULL);
  92         if (r < 0) {
  93                 log_error_errno(r, "Failed to request match: %m");
  94                 goto fail;
  95         }
  96
  97         r = sd_bus_add_match(bus, NULL, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", match_callback, NULL);
  98         if (r < 0) {
  99                 log_error_errno(r, "Failed to add match: %m");
 100                 goto fail;
 101         }
 102
 103         bus_match_dump(&bus->match_callbacks, 0);
 104
 105         *_bus = bus;
 106         return 0;
 107
 108 fail:
 109         sd_bus_unref(bus);
 110         return r;
 111 }
 112
 113 static int server(sd_bus *bus) {
 114         int r;
 115         bool client1_gone = false, client2_gone = false;
 116
 117         while (!client1_gone || !client2_gone) {
 118                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 119                 pid_t pid = 0;
 120                 const char *label = NULL;
 121
 122                 r = sd_bus_process(bus, &m);
 123                 if (r < 0) {
 124                         log_error_errno(r, "Failed to process requests: %m");
 125                         goto fail;
 126                 }
 127
 128                 if (r == 0) {
 129                         r = sd_bus_wait(bus, (uint64_t) -1);
 130                         if (r < 0) {
 131                                 log_error_errno(r, "Failed to wait: %m");
 132                                 goto fail;
 133                         }
 134
 135                         continue;
 136                 }
 137
 138                 if (!m)
 139                         continue;
 140
 141                 sd_bus_creds_get_pid(sd_bus_message_get_creds(m), &pid);
 142                 sd_bus_creds_get_selinux_context(sd_bus_message_get_creds(m), &label);
 143                 log_info("Got message! member=%s pid="PID_FMT" label=%s",
 144                          strna(sd_bus_message_get_member(m)),
 145                          pid,
 146                          strna(label));
 147                 /* bus_message_dump(m); */
 148                 /* sd_bus_message_rewind(m, true); */
 149
 150                 if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
 151                         const char *hello;
 152                         _cleanup_free_ char *lowercase = NULL;
 153
 154                         r = sd_bus_message_read(m, "s", &hello);
 155                         if (r < 0) {
 156                                 log_error_errno(r, "Failed to get parameter: %m");
 157                                 goto fail;
 158                         }
 159
 160                         lowercase = strdup(hello);
 161                         if (!lowercase) {
 162                                 r = log_oom();
 163                                 goto fail;
 164                         }
 165
 166                         ascii_strlower(lowercase);
 167
 168                         r = sd_bus_reply_method_return(m, "s", lowercase);
 169                         if (r < 0) {
 170                                 log_error_errno(r, "Failed to send reply: %m");
 171                                 goto fail;
 172                         }
 173                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
 174
 175                         r = sd_bus_reply_method_return(m, NULL);
 176                         if (r < 0) {
 177                                 log_error_errno(r, "Failed to send reply: %m");
 178                                 goto fail;
 179                         }
 180
 181                         client1_gone = true;
 182                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
 183
 184                         r = sd_bus_reply_method_return(m, NULL);
 185                         if (r < 0) {
 186                                 log_error_errno(r, "Failed to send reply: %m");
 187                                 goto fail;
 188                         }
 189
 190                         client2_gone = true;
 191                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
 192
 193                         sleep(1);
 194
 195                         r = sd_bus_reply_method_return(m, NULL);
 196                         if (r < 0) {
 197                                 log_error_errno(r, "Failed to send reply: %m");
 198                                 goto fail;
 199                         }
 200
 201                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "FileDescriptor")) {
 202                         int fd;
 203                         static const char x = 'X';
 204
 205                         r = sd_bus_message_read(m, "h", &fd);
 206                         if (r < 0) {
 207                                 log_error_errno(r, "Failed to get parameter: %m");
 208                                 goto fail;
 209                         }
 210
 211                         log_info("Received fd=%d", fd);
 212
 213                         if (write(fd, &x, 1) < 0) {
 214                                 log_error_errno(errno, "Failed to write to fd: %m");
 215                                 safe_close(fd);
 216                                 goto fail;
 217                         }
 218
 219                         r = sd_bus_reply_method_return(m, NULL);
 220                         if (r < 0) {
 221                                 log_error_errno(r, "Failed to send reply: %m");
 222                                 goto fail;
 223                         }
 224
 225                 } else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
 226
 227                         r = sd_bus_reply_method_error(
 228                                         m,
 229                                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
 230                         if (r < 0) {
 231                                 log_error_errno(r, "Failed to send reply: %m");
 232                                 goto fail;
 233                         }
 234                 }
 235         }
 236
 237         r = 0;
 238
 239 fail:
 240         if (bus) {
 241                 sd_bus_flush(bus);
 242                 sd_bus_unref(bus);
 243         }
 244
 245         return r;
 246 }
 247
 248 static void* client1(void *p) {
 249         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 250         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 251         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 252         const char *hello;
 253         int r;
 254         _cleanup_close_pair_ int pp[2] = { -1, -1 };
 255         char x;
 256
 257         r = sd_bus_open_user(&bus);
 258         if (r < 0) {
 259                 log_error_errno(r, "Failed to connect to user bus: %m");
 260                 goto finish;
 261         }
 262
 263         r = sd_bus_call_method(
 264                         bus,
 265                         "org.freedesktop.systemd.test",
 266                         "/",
 267                         "org.freedesktop.systemd.test",
 268                         "LowerCase",
 269                         &error,
 270                         &reply,
 271                         "s",
 272                         "HELLO");
 273         if (r < 0) {
 274                 log_error_errno(r, "Failed to issue method call: %m");
 275                 goto finish;
 276         }
 277
 278         r = sd_bus_message_read(reply, "s", &hello);
 279         if (r < 0) {
 280                 log_error_errno(r, "Failed to get string: %m");
 281                 goto finish;
 282         }
 283
 284         assert_se(streq(hello, "hello"));
 285
 286         if (pipe2(pp, O_CLOEXEC|O_NONBLOCK) < 0) {
 287                 log_error_errno(errno, "Failed to allocate pipe: %m");
 288                 r = -errno;
 289                 goto finish;
 290         }
 291
 292         log_info("Sending fd=%d", pp[1]);
 293
 294         r = sd_bus_call_method(
 295                         bus,
 296                         "org.freedesktop.systemd.test",
 297                         "/",
 298                         "org.freedesktop.systemd.test",
 299                         "FileDescriptor",
 300                         &error,
 301                         NULL,
 302                         "h",
 303                         pp[1]);
 304         if (r < 0) {
 305                 log_error_errno(r, "Failed to issue method call: %m");
 306                 goto finish;
 307         }
 308
 309         errno = 0;
 310         if (read(pp[0], &x, 1) <= 0) {
 311                 log_error("Failed to read from pipe: %s", errno ? strerror(errno) : "early read");
 312                 goto finish;
 313         }
 314
 315         r = 0;
 316
 317 finish:
 318         if (bus) {
 319                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *q;
 320
 321                 r = sd_bus_message_new_method_call(
 322                                 bus,
 323                                 &q,
 324                                 "org.freedesktop.systemd.test",
 325                                 "/",
 326                                 "org.freedesktop.systemd.test",
 327                                 "ExitClient1");
 328                 if (r < 0)
 329                         log_error_errno(r, "Failed to allocate method call: %m");
 330                 else
 331                         sd_bus_send(bus, q, NULL);
 332
 333         }
 334
 335         return INT_TO_PTR(r);
 336 }
 337
 338 static int quit_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 339         bool *x = userdata;
 340
 341         log_error_errno(sd_bus_message_get_errno(m), "Quit callback: %m");
 342
 343         *x = 1;
 344         return 1;
 345 }
 346
 347 static void* client2(void *p) {
 348         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
 349         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 350         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 351         bool quit = false;
 352         const char *mid;
 353         int r;
 354
 355         r = sd_bus_open_user(&bus);
 356         if (r < 0) {
 357                 log_error_errno(r, "Failed to connect to user bus: %m");
 358                 goto finish;
 359         }
 360
 361         r = sd_bus_message_new_method_call(
 362                         bus,
 363                         &m,
 364                         "org.freedesktop.systemd.test",
 365                         "/foo/bar/waldo/piep",
 366                         "org.object.test",
 367                         "Foobar");
 368         if (r < 0) {
 369                 log_error_errno(r, "Failed to allocate method call: %m");
 370                 goto finish;
 371         }
 372
 373         r = sd_bus_send(bus, m, NULL);
 374         if (r < 0) {
 375                 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
 376                 goto finish;
 377         }
 378
 379         m = sd_bus_message_unref(m);
 380
 381         r = sd_bus_message_new_signal(
 382                         bus,
 383                         &m,
 384                         "/foobar",
 385                         "foo.bar",
 386                         "Notify");
 387         if (r < 0) {
 388                 log_error_errno(r, "Failed to allocate signal: %m");
 389                 goto finish;
 390         }
 391
 392         r = sd_bus_send(bus, m, NULL);
 393         if (r < 0) {
 394                 log_error("Failed to issue signal: %s", bus_error_message(&error, -r));
 395                 goto finish;
 396         }
 397
 398         m = sd_bus_message_unref(m);
 399
 400         r = sd_bus_message_new_method_call(
 401                         bus,
 402                         &m,
 403                         "org.freedesktop.systemd.test",
 404                         "/",
 405                         "org.freedesktop.DBus.Peer",
 406                         "GetMachineId");
 407         if (r < 0) {
 408                 log_error_errno(r, "Failed to allocate method call: %m");
 409                 goto finish;
 410         }
 411
 412         r = sd_bus_call(bus, m, 0, &error, &reply);
 413         if (r < 0) {
 414                 log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
 415                 goto finish;
 416         }
 417
 418         r = sd_bus_message_read(reply, "s", &mid);
 419         if (r < 0) {
 420                 log_error_errno(r, "Failed to parse machine ID: %m");
 421                 goto finish;
 422         }
 423
 424         log_info("Machine ID is %s.", mid);
 425
 426         m = sd_bus_message_unref(m);
 427
 428         r = sd_bus_message_new_method_call(
 429                         bus,
 430                         &m,
 431                         "org.freedesktop.systemd.test",
 432                         "/",
 433                         "org.freedesktop.systemd.test",
 434                         "Slow");
 435         if (r < 0) {
 436                 log_error_errno(r, "Failed to allocate method call: %m");
 437                 goto finish;
 438         }
 439
 440         reply = sd_bus_message_unref(reply);
 441
 442         r = sd_bus_call(bus, m, 200 * USEC_PER_MSEC, &error, &reply);
 443         if (r < 0)
 444                 log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
 445         else
 446                 log_info("Slow call succeed.");
 447
 448         m = sd_bus_message_unref(m);
 449
 450         r = sd_bus_message_new_method_call(
 451                         bus,
 452                         &m,
 453                         "org.freedesktop.systemd.test",
 454                         "/",
 455                         "org.freedesktop.systemd.test",
 456                         "Slow");
 457         if (r < 0) {
 458                 log_error_errno(r, "Failed to allocate method call: %m");
 459                 goto finish;
 460         }
 461
 462         r = sd_bus_call_async(bus, NULL, m, quit_callback, &quit, 200 * USEC_PER_MSEC);
 463         if (r < 0) {
 464                 log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
 465                 goto finish;
 466         }
 467
 468         while (!quit) {
 469                 r = sd_bus_process(bus, NULL);
 470                 if (r < 0) {
 471                         log_error_errno(r, "Failed to process requests: %m");
 472                         goto finish;
 473                 }
 474                 if (r == 0) {
 475                         r = sd_bus_wait(bus, (uint64_t) -1);
 476                         if (r < 0) {
 477                                 log_error_errno(r, "Failed to wait: %m");
 478                                 goto finish;
 479                         }
 480                 }
 481         }
 482
 483         r = 0;
 484
 485 finish:
 486         if (bus) {
 487                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *q;
 488
 489                 r = sd_bus_message_new_method_call(
 490                                 bus,
 491                                 &q,
 492                                 "org.freedesktop.systemd.test",
 493                                 "/",
 494                                 "org.freedesktop.systemd.test",
 495                                 "ExitClient2");
 496                 if (r < 0) {
 497                         log_error_errno(r, "Failed to allocate method call: %m");
 498                         goto finish;
 499                 }
 500
 501                 (void) sd_bus_send(bus, q, NULL);
 502         }
 503
 504         return INT_TO_PTR(r);
 505 }
 506
 507 int main(int argc, char *argv[]) {
 508         pthread_t c1, c2;
 509         sd_bus *bus;
 510         void *p;
 511         int q, r;
 512
 513         test_setup_logging(LOG_INFO);
 514
 515         r = server_init(&bus);
 516         if (r < 0)
 517                 return log_tests_skipped("Failed to connect to bus");
 518
 519         log_info("Initialized...");
 520
 521         r = pthread_create(&c1, NULL, client1, bus);
 522         if (r != 0)
 523                 return EXIT_FAILURE;
 524
 525         r = pthread_create(&c2, NULL, client2, bus);
 526         if (r != 0)
 527                 return EXIT_FAILURE;
 528
 529         r = server(bus);
 530
 531         q = pthread_join(c1, &p);
 532         if (q != 0)
 533                 return EXIT_FAILURE;
 534         if (PTR_TO_INT(p) < 0)
 535                 return EXIT_FAILURE;
 536
 537         q = pthread_join(c2, &p);
 538         if (q != 0)
 539                 return EXIT_FAILURE;
 540         if (PTR_TO_INT(p) < 0)
 541                 return EXIT_FAILURE;
 542
 543         if (r < 0)
 544                 return EXIT_FAILURE;
 545
 546         return EXIT_SUCCESS;
 547 }