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

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   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 "errno-util.h"
  15 #include "fd-util.h"
  16 #include "format-util.h"
  17 #include "log.h"
  18 #include "macro.h"
  19 #include "string-util.h"
  20 #include "tests.h"
  21 #include "util.h"
  22
  23 static int match_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
  24         log_info("Match triggered! interface=%s member=%s", strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)));
  25         return 0;
  26 }
  27
  28 static int object_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
  29         int r;
  30
  31         if (sd_bus_message_is_method_error(m, NULL))
  32                 return 0;
  33
  34         if (sd_bus_message_is_method_call(m, "org.object.test", "Foobar")) {
  35                 log_info("Invoked Foobar() on %s", sd_bus_message_get_path(m));
  36
  37                 r = sd_bus_reply_method_return(m, NULL);
  38                 if (r < 0)
  39                         return log_error_errno(r, "Failed to send reply: %m");
  40
  41                 return 1;
  42         }
  43
  44         return 0;
  45 }
  46
  47 static int server_init(sd_bus **_bus) {
  48         sd_bus *bus = NULL;
  49         sd_id128_t id;
  50         int r;
  51         const char *unique, *desc;
  52
  53         assert_se(_bus);
  54
  55         r = sd_bus_open_user_with_description(&bus, "my bus!");
  56         if (r < 0) {
  57                 log_error_errno(r, "Failed to connect to user bus: %m");
  58                 goto fail;
  59         }
  60
  61         r = sd_bus_get_bus_id(bus, &id);
  62         if (r < 0) {
  63                 log_error_errno(r, "Failed to get server ID: %m");
  64                 goto fail;
  65         }
  66
  67         r = sd_bus_get_unique_name(bus, &unique);
  68         if (r < 0) {
  69                 log_error_errno(r, "Failed to get unique name: %m");
  70                 goto fail;
  71         }
  72
  73         assert_se(sd_bus_get_description(bus, &desc) >= 0);
  74         assert_se(streq(desc, "my bus!"));
  75
  76         log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
  77         log_info("Unique ID: %s", unique);
  78         log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));
  79
  80         r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
  81         if (r < 0) {
  82                 log_error_errno(r, "Failed to acquire name: %m");
  83                 goto fail;
  84         }
  85
  86         r = sd_bus_add_fallback(bus, NULL, "/foo/bar", object_callback, NULL);
  87         if (r < 0) {
  88                 log_error_errno(r, "Failed to add object: %m");
  89                 goto fail;
  90         }
  91
  92         r = sd_bus_match_signal(bus, NULL, NULL, NULL, "foo.bar", "Notify", match_callback, NULL);
  93         if (r < 0) {
  94                 log_error_errno(r, "Failed to request match: %m");
  95                 goto fail;
  96         }
  97
  98         r = sd_bus_add_match(bus, NULL, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", match_callback, NULL);
  99         if (r < 0) {
 100                 log_error_errno(r, "Failed to add match: %m");
 101                 goto fail;
 102         }
 103
 104         bus_match_dump(&bus->match_callbacks, 0);
 105
 106         *_bus = bus;
 107         return 0;
 108
 109 fail:
 110         sd_bus_unref(bus);
 111         return r;
 112 }
 113
 114 static int server(sd_bus *bus) {
 115         int r;
 116         bool client1_gone = false, client2_gone = false;
 117
 118         while (!client1_gone || !client2_gone) {
 119                 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 120                 pid_t pid = 0;
 121                 const char *label = NULL;
 122
 123                 r = sd_bus_process(bus, &m);
 124                 if (r < 0) {
 125                         log_error_errno(r, "Failed to process requests: %m");
 126                         goto fail;
 127                 }
 128
 129                 if (r == 0) {
 130                         r = sd_bus_wait(bus, (uint64_t) -1);
 131                         if (r < 0) {
 132                                 log_error_errno(r, "Failed to wait: %m");
 133                                 goto fail;
 134                         }
 135
 136                         continue;
 137                 }
 138
 139                 if (!m)
 140                         continue;
 141
 142                 sd_bus_creds_get_pid(sd_bus_message_get_creds(m), &pid);
 143                 sd_bus_creds_get_selinux_context(sd_bus_message_get_creds(m), &label);
 144                 log_info("Got message! member=%s pid="PID_FMT" label=%s",
 145                          strna(sd_bus_message_get_member(m)),
 146                          pid,
 147                          strna(label));
 148                 /* sd_bus_message_dump(m); */
 149                 /* sd_bus_message_rewind(m, true); */
 150
 151                 if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
 152                         const char *hello;
 153                         _cleanup_free_ char *lowercase = NULL;
 154
 155                         r = sd_bus_message_read(m, "s", &hello);
 156                         if (r < 0) {
 157                                 log_error_errno(r, "Failed to get parameter: %m");
 158                                 goto fail;
 159                         }
 160
 161                         lowercase = strdup(hello);
 162                         if (!lowercase) {
 163                                 r = log_oom();
 164                                 goto fail;
 165                         }
 166
 167                         ascii_strlower(lowercase);
 168
 169                         r = sd_bus_reply_method_return(m, "s", lowercase);
 170                         if (r < 0) {
 171                                 log_error_errno(r, "Failed to send reply: %m");
 172                                 goto fail;
 173                         }
 174                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
 175
 176                         r = sd_bus_reply_method_return(m, NULL);
 177                         if (r < 0) {
 178                                 log_error_errno(r, "Failed to send reply: %m");
 179                                 goto fail;
 180                         }
 181
 182                         client1_gone = true;
 183                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
 184
 185                         r = sd_bus_reply_method_return(m, NULL);
 186                         if (r < 0) {
 187                                 log_error_errno(r, "Failed to send reply: %m");
 188                                 goto fail;
 189                         }
 190
 191                         client2_gone = true;
 192                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
 193
 194                         sleep(1);
 195
 196                         r = sd_bus_reply_method_return(m, NULL);
 197                         if (r < 0) {
 198                                 log_error_errno(r, "Failed to send reply: %m");
 199                                 goto fail;
 200                         }
 201
 202                 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "FileDescriptor")) {
 203                         int fd;
 204                         static const char x = 'X';
 205
 206                         r = sd_bus_message_read(m, "h", &fd);
 207                         if (r < 0) {
 208                                 log_error_errno(r, "Failed to get parameter: %m");
 209                                 goto fail;
 210                         }
 211
 212                         log_info("Received fd=%d", fd);
 213
 214                         if (write(fd, &x, 1) < 0) {
 215                                 log_error_errno(errno, "Failed to write to fd: %m");
 216                                 safe_close(fd);
 217                                 goto fail;
 218                         }
 219
 220                         r = sd_bus_reply_method_return(m, NULL);
 221                         if (r < 0) {
 222                                 log_error_errno(r, "Failed to send reply: %m");
 223                                 goto fail;
 224                         }
 225
 226                 } else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
 227
 228                         r = sd_bus_reply_method_error(
 229                                         m,
 230                                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
 231                         if (r < 0) {
 232                                 log_error_errno(r, "Failed to send reply: %m");
 233                                 goto fail;
 234                         }
 235                 }
 236         }
 237
 238         r = 0;
 239
 240 fail:
 241         if (bus) {
 242                 sd_bus_flush(bus);
 243                 sd_bus_unref(bus);
 244         }
 245
 246         return r;
 247 }
 248
 249 static void* client1(void *p) {
 250         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 251         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 252         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 253         const char *hello;
 254         int r;
 255         _cleanup_close_pair_ int pp[2] = { -1, -1 };
 256         char x;
 257
 258         r = sd_bus_open_user(&bus);
 259         if (r < 0) {
 260                 log_error_errno(r, "Failed to connect to user bus: %m");
 261                 goto finish;
 262         }
 263
 264         r = sd_bus_call_method(
 265                         bus,
 266                         "org.freedesktop.systemd.test",
 267                         "/",
 268                         "org.freedesktop.systemd.test",
 269                         "LowerCase",
 270                         &error,
 271                         &reply,
 272                         "s",
 273                         "HELLO");
 274         if (r < 0) {
 275                 log_error_errno(r, "Failed to issue method call: %m");
 276                 goto finish;
 277         }
 278
 279         r = sd_bus_message_read(reply, "s", &hello);
 280         if (r < 0) {
 281                 log_error_errno(r, "Failed to get string: %m");
 282                 goto finish;
 283         }
 284
 285         assert_se(streq(hello, "hello"));
 286
 287         if (pipe2(pp, O_CLOEXEC|O_NONBLOCK) < 0) {
 288                 r = log_error_errno(errno, "Failed to allocate pipe: %m");
 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 != 0 ? strerror_safe(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 = NULL;
 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 = NULL;
 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 }