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

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <sys/socket.h>
   4
   5 #include "sd-bus.h"
   6 #include "sd-event.h"
   7
   8 #include "tests.h"
   9
  10 static bool track_cb_called_x = false;
  11 static bool track_cb_called_y = false;
  12 static bool track_destroy_called_z = false;
  13
  14 static int track_cb_x(sd_bus_track *t, void *userdata) {
  15
  16         log_error("TRACK CB X");
  17
  18         assert_se(!track_cb_called_x);
  19         track_cb_called_x = true;
  20
  21         /* This means b's name disappeared. Let's now disconnect, to make sure the track handling on disconnect works
  22          * as it should. */
  23
  24         assert_se(shutdown(sd_bus_get_fd(sd_bus_track_get_bus(t)), SHUT_RDWR) >= 0);
  25         return 1;
  26 }
  27
  28 static int track_cb_y(sd_bus_track *t, void *userdata) {
  29
  30         log_error("TRACK CB Y");
  31
  32         assert_se(!track_cb_called_y);
  33         track_cb_called_y = true;
  34
  35         /* We got disconnected, let's close everything */
  36
  37         assert_se(sd_event_exit(sd_bus_get_event(sd_bus_track_get_bus(t)), EXIT_SUCCESS) >= 0);
  38
  39         return 0;
  40 }
  41
  42 static int track_cb_z(sd_bus_track *t, void *userdata) {
  43         assert_not_reached();
  44 }
  45
  46 static void track_destroy_z(void *userdata) {
  47         track_destroy_called_z = true;
  48 }
  49
  50 int main(int argc, char *argv[]) {
  51         _cleanup_(sd_event_unrefp) sd_event *event = NULL;
  52         _cleanup_(sd_bus_track_unrefp) sd_bus_track *x = NULL, *y = NULL, *z = NULL;
  53         _cleanup_(sd_bus_unrefp) sd_bus *a = NULL, *b = NULL;
  54         bool use_system_bus = false;
  55         const char *unique;
  56         int r;
  57
  58         test_setup_logging(LOG_INFO);
  59
  60         assert_se(sd_event_default(&event) >= 0);
  61
  62         r = sd_bus_open_user(&a);
  63         if (IN_SET(r, -ECONNREFUSED, -ENOENT, -ENOMEDIUM)) {
  64                 r = sd_bus_open_system(&a);
  65                 if (IN_SET(r, -ECONNREFUSED, -ENOENT))
  66                         return log_tests_skipped("Failed to connect to bus");
  67                 use_system_bus = true;
  68         }
  69         assert_se(r >= 0);
  70
  71         assert_se(sd_bus_attach_event(a, event, SD_EVENT_PRIORITY_NORMAL) >= 0);
  72
  73         if (use_system_bus)
  74                 assert_se(sd_bus_open_system(&b) >= 0);
  75         else
  76                 assert_se(sd_bus_open_user(&b) >= 0);
  77
  78         assert_se(sd_bus_attach_event(b, event, SD_EVENT_PRIORITY_NORMAL) >= 0);
  79
  80         /* Watch b's name from a */
  81         assert_se(sd_bus_track_new(a, &x, track_cb_x, NULL) >= 0);
  82
  83         assert_se(sd_bus_get_unique_name(b, &unique) >= 0);
  84
  85         assert_se(sd_bus_track_add_name(x, unique) >= 0);
  86
  87         /* Watch's a's own name from a */
  88         assert_se(sd_bus_track_new(a, &y, track_cb_y, NULL) >= 0);
  89
  90         assert_se(sd_bus_get_unique_name(a, &unique) >= 0);
  91
  92         assert_se(sd_bus_track_add_name(y, unique) >= 0);
  93
  94         /* Basic tests. */
  95         assert_se(sd_bus_track_new(a, &z, track_cb_z, NULL) >= 0);
  96
  97         /* non-recursive case */
  98         assert_se(sd_bus_track_set_recursive(z, false) >= 0);
  99         assert_se(sd_bus_track_get_recursive(z) == 0);
 100         assert_se(!sd_bus_track_contains(z, unique));
 101         assert_se(sd_bus_track_count_name(z, unique) == 0);
 102         assert_se(sd_bus_track_remove_name(z, unique) == 0);
 103         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 104         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 105         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 106         assert_se(sd_bus_track_set_recursive(z, true) == -EBUSY);
 107         assert_se(sd_bus_track_contains(z, unique));
 108         assert_se(sd_bus_track_count_name(z, unique) == 1);
 109         assert_se(sd_bus_track_remove_name(z, unique) == 1);
 110         assert_se(!sd_bus_track_contains(z, unique));
 111         assert_se(sd_bus_track_count_name(z, unique) == 0);
 112         assert_se(sd_bus_track_remove_name(z, unique) == 0);
 113
 114         /* recursive case */
 115         assert_se(sd_bus_track_set_recursive(z, true) >= 0);
 116         assert_se(sd_bus_track_get_recursive(z) == 1);
 117         assert_se(!sd_bus_track_contains(z, unique));
 118         assert_se(sd_bus_track_count_name(z, unique) == 0);
 119         assert_se(sd_bus_track_remove_name(z, unique) == 0);
 120         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 121         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 122         assert_se(sd_bus_track_add_name(z, unique) >= 0);
 123         assert_se(sd_bus_track_set_recursive(z, false) == -EBUSY);
 124         assert_se(sd_bus_track_contains(z, unique));
 125         assert_se(sd_bus_track_count_name(z, unique) == 3);
 126         assert_se(sd_bus_track_remove_name(z, unique) == 1);
 127         assert_se(sd_bus_track_contains(z, unique));
 128         assert_se(sd_bus_track_count_name(z, unique) == 2);
 129         assert_se(sd_bus_track_remove_name(z, unique) == 1);
 130         assert_se(sd_bus_track_contains(z, unique));
 131         assert_se(sd_bus_track_count_name(z, unique) == 1);
 132         assert_se(sd_bus_track_remove_name(z, unique) == 1);
 133         assert_se(!sd_bus_track_contains(z, unique));
 134         assert_se(sd_bus_track_count_name(z, unique) == 0);
 135         assert_se(sd_bus_track_remove_name(z, unique) == 0);
 136
 137         assert_se(sd_bus_track_set_destroy_callback(z, track_destroy_z) >= 0);
 138         z = sd_bus_track_unref(z);
 139         assert_se(track_destroy_called_z);
 140
 141         /* Now make b's name disappear */
 142         sd_bus_close(b);
 143
 144         assert_se(sd_event_loop(event) >= 0);
 145
 146         assert_se(track_cb_called_x);
 147         assert_se(track_cb_called_y);
 148
 149         return 0;
 150 }