src/test/test-varlink.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <fcntl.h>
   4 #include <poll.h>
   5 #include <pthread.h>
   6
   7 #include "sd-event.h"
   8
   9 #include "data-fd-util.h"
  10 #include "fd-util.h"
  11 #include "json.h"
  12 #include "rm-rf.h"
  13 #include "strv.h"
  14 #include "tests.h"
  15 #include "tmpfile-util.h"
  16 #include "user-util.h"
  17 #include "varlink.h"
  18
  19 /* Let's pick some high value, that is higher than the largest listen() backlog, but leaves enough room below
  20    the typical RLIMIT_NOFILE value of 1024 so that we can process both sides of each socket in our
  21    process. Or in other words: "OVERLOAD_CONNECTIONS * 2 + x < 1024" should hold, for some small x that
  22    should cover any auxiliary fds, the listener server fds, stdin/stdout/stderr and whatever else. */
  23 #define OVERLOAD_CONNECTIONS 333
  24
  25 static int n_done = 0;
  26 static int block_write_fd = -EBADF;
  27
  28 static int method_something(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
  29         _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
  30         JsonVariant *a, *b;
  31         int64_t x, y;
  32         int r;
  33
  34         a = json_variant_by_key(parameters, "a");
  35         if (!a)
  36                 return varlink_error(link, "io.test.BadParameters", NULL);
  37
  38         x = json_variant_integer(a);
  39
  40         b = json_variant_by_key(parameters, "b");
  41         if (!b)
  42                 return varlink_error(link, "io.test.BadParameters", NULL);
  43
  44         y = json_variant_integer(b);
  45
  46         r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(x + y))));
  47         if (r < 0)
  48                 return r;
  49
  50         return varlink_reply(link, ret);
  51 }
  52
  53 static int method_something_more(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
  54         _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
  55         int r;
  56
  57         struct Something {
  58                 int x;
  59                 int y;
  60         };
  61
  62         static const JsonDispatch dispatch_table[] = {
  63                 { "a", JSON_VARIANT_INTEGER, json_dispatch_int, offsetof(struct Something, x), JSON_MANDATORY },
  64                 { "b", JSON_VARIANT_INTEGER, json_dispatch_int, offsetof(struct Something, y), JSON_MANDATORY},
  65                 {}
  66         };
  67         struct Something s = {};
  68
  69         r = varlink_dispatch(link, parameters, dispatch_table, &s);
  70         if (r != 0)
  71                 return r;
  72
  73         for (int i = 0; i < 5; i++) {
  74                 _cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
  75
  76                 r = json_build(&w, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(s.x + (s.y * i)))));
  77                 if (r < 0)
  78                         return r;
  79
  80                 r = varlink_notify(link, w);
  81                 if (r < 0)
  82                         return r;
  83         }
  84
  85         r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("sum", JSON_BUILD_INTEGER(s.x + (s.y * 5)))));
  86         if (r < 0)
  87                 return r;
  88
  89         return varlink_reply(link, ret);
  90 }
  91
  92 static void test_fd(int fd, const void *buf, size_t n) {
  93         char rbuf[n + 1];
  94         ssize_t m;
  95
  96         m = read(fd, rbuf, n + 1);
  97         assert_se(m >= 0);
  98         assert_se(memcmp_nn(buf, n, rbuf, m) == 0);
  99 }
 100
 101 static int method_passfd(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
 102         _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
 103         JsonVariant *a;
 104         int r;
 105
 106         a = json_variant_by_key(parameters, "fd");
 107         if (!a)
 108                 return varlink_error(link, "io.test.BadParameters", NULL);
 109
 110         assert_se(streq_ptr(json_variant_string(a), "whoop"));
 111
 112         int xx = varlink_peek_fd(link, 0),
 113                 yy = varlink_peek_fd(link, 1),
 114                 zz = varlink_peek_fd(link, 2);
 115
 116         log_info("%i %i %i", xx, yy, zz);
 117
 118         assert_se(xx >= 0);
 119         assert_se(yy >= 0);
 120         assert_se(zz >= 0);
 121
 122         test_fd(xx, "foo", 3);
 123         test_fd(yy, "bar", 3);
 124         test_fd(zz, "quux", 4);
 125
 126         _cleanup_close_ int vv = acquire_data_fd("miau", 4, 0);
 127         _cleanup_close_ int ww = acquire_data_fd("wuff", 4, 0);
 128
 129         assert_se(vv >= 0);
 130         assert_se(ww >= 0);
 131
 132         r = json_build(&ret, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("yo", JSON_BUILD_INTEGER(88))));
 133         if (r < 0)
 134                 return r;
 135
 136         assert_se(varlink_push_fd(link, vv) == 0);
 137         assert_se(varlink_push_fd(link, ww) == 1);
 138
 139         TAKE_FD(vv);
 140         TAKE_FD(ww);
 141
 142         return varlink_reply(link, ret);
 143 }
 144
 145 static int method_done(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
 146
 147         if (++n_done == 2)
 148                 sd_event_exit(varlink_get_event(link), EXIT_FAILURE);
 149
 150         return 0;
 151 }
 152
 153 static int reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
 154         JsonVariant *sum;
 155
 156         sum = json_variant_by_key(parameters, "sum");
 157
 158         assert_se(json_variant_integer(sum) == 7+22);
 159
 160         if (++n_done == 2)
 161                 sd_event_exit(varlink_get_event(link), EXIT_FAILURE);
 162
 163         return 0;
 164 }
 165
 166 static int on_connect(VarlinkServer *s, Varlink *link, void *userdata) {
 167         uid_t uid = UID_INVALID;
 168
 169         assert_se(s);
 170         assert_se(link);
 171
 172         assert_se(varlink_get_peer_uid(link, &uid) >= 0);
 173         assert_se(getuid() == uid);
 174         assert_se(varlink_set_allow_fd_passing_input(link, true) >= 0);
 175         assert_se(varlink_set_allow_fd_passing_output(link, true) >= 0);
 176
 177         return 0;
 178 }
 179
 180 static int overload_reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
 181
 182         /* This method call reply should always be called with a disconnection, since the method call should
 183          * be talking to an overloaded server */
 184
 185         log_debug("Over reply triggered with error: %s", strna(error_id));
 186         assert_se(streq(error_id, VARLINK_ERROR_DISCONNECTED));
 187         sd_event_exit(varlink_get_event(link), 0);
 188
 189         return 0;
 190 }
 191
 192 static void flood_test(const char *address) {
 193         _cleanup_(varlink_flush_close_unrefp) Varlink *c = NULL;
 194         _cleanup_(sd_event_unrefp) sd_event *e = NULL;
 195         _cleanup_free_ Varlink **connections = NULL;
 196         size_t k;
 197         char x = 'x';
 198
 199         log_debug("Flooding server...");
 200
 201         /* Block the main event loop while we flood */
 202         assert_se(write(block_write_fd, &x, sizeof(x)) == sizeof(x));
 203
 204         assert_se(sd_event_default(&e) >= 0);
 205
 206         /* Flood the server with connections */
 207         assert_se(connections = new0(Varlink*, OVERLOAD_CONNECTIONS));
 208         for (k = 0; k < OVERLOAD_CONNECTIONS; k++) {
 209                 _cleanup_free_ char *t = NULL;
 210                 log_debug("connection %zu", k);
 211                 assert_se(varlink_connect_address(connections + k, address) >= 0);
 212
 213                 assert_se(asprintf(&t, "flood-%zu", k) >= 0);
 214                 assert_se(varlink_set_description(connections[k], t) >= 0);
 215                 assert_se(varlink_attach_event(connections[k], e, k) >= 0);
 216                 assert_se(varlink_sendb(connections[k], "io.test.Rubbish", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("id", JSON_BUILD_INTEGER(k)))) >= 0);
 217         }
 218
 219         /* Then, create one more, which should fail */
 220         log_debug("Creating overload connection...");
 221         assert_se(varlink_connect_address(&c, address) >= 0);
 222         assert_se(varlink_set_description(c, "overload-client") >= 0);
 223         assert_se(varlink_attach_event(c, e, k) >= 0);
 224         assert_se(varlink_bind_reply(c, overload_reply) >= 0);
 225         assert_se(varlink_invokeb(c, "io.test.Overload", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("foo", JSON_BUILD_CONST_STRING("bar")))) >= 0);
 226
 227         /* Unblock it */
 228         log_debug("Unblocking server...");
 229         block_write_fd = safe_close(block_write_fd);
 230
 231         /* This loop will terminate as soon as the overload reply callback is called */
 232         assert_se(sd_event_loop(e) >= 0);
 233
 234         /* And close all connections again */
 235         for (k = 0; k < OVERLOAD_CONNECTIONS; k++)
 236                 connections[k] = varlink_unref(connections[k]);
 237 }
 238
 239 static void *thread(void *arg) {
 240         _cleanup_(varlink_flush_close_unrefp) Varlink *c = NULL;
 241         _cleanup_(json_variant_unrefp) JsonVariant *i = NULL;
 242         JsonVariant *o = NULL, *k = NULL, *j = NULL;
 243         const char *error_id;
 244         const char *e;
 245         int x = 0;
 246
 247         assert_se(json_build(&i, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_INTEGER(88)),
 248                                                    JSON_BUILD_PAIR("b", JSON_BUILD_INTEGER(99)))) >= 0);
 249
 250         assert_se(varlink_connect_address(&c, arg) >= 0);
 251         assert_se(varlink_set_description(c, "thread-client") >= 0);
 252         assert_se(varlink_set_allow_fd_passing_input(c, true) >= 0);
 253         assert_se(varlink_set_allow_fd_passing_output(c, true) >= 0);
 254
 255         assert_se(varlink_collect(c, "io.test.DoSomethingMore", i, &j, &error_id) >= 0);
 256
 257         assert_se(!error_id);
 258         assert_se(json_variant_is_array(j) && !json_variant_is_blank_array(j));
 259
 260         JSON_VARIANT_ARRAY_FOREACH(k, j) {
 261                 assert_se(json_variant_integer(json_variant_by_key(k, "sum")) == 88 + (99 * x));
 262                 x++;
 263         }
 264         assert_se(x == 6);
 265
 266         assert_se(varlink_call(c, "io.test.DoSomething", i, &o, &e) >= 0);
 267         assert_se(json_variant_integer(json_variant_by_key(o, "sum")) == 88 + 99);
 268         assert_se(!e);
 269
 270         int fd1 = acquire_data_fd("foo", 3, 0);
 271         int fd2 = acquire_data_fd("bar", 3, 0);
 272         int fd3 = acquire_data_fd("quux", 4, 0);
 273
 274         assert_se(fd1 >= 0);
 275         assert_se(fd2 >= 0);
 276         assert_se(fd3 >= 0);
 277
 278         assert_se(varlink_push_fd(c, fd1) == 0);
 279         assert_se(varlink_push_fd(c, fd2) == 1);
 280         assert_se(varlink_push_fd(c, fd3) == 2);
 281
 282         assert_se(varlink_callb(c, "io.test.PassFD", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("fd", JSON_BUILD_STRING("whoop")))) >= 0);
 283
 284         int fd4 = varlink_peek_fd(c, 0);
 285         int fd5 = varlink_peek_fd(c, 1);
 286
 287         assert_se(fd4 >= 0);
 288         assert_se(fd5 >= 0);
 289
 290         test_fd(fd4, "miau", 4);
 291         test_fd(fd5, "wuff", 4);
 292
 293         assert_se(varlink_callb(c, "io.test.IDontExist", &o, &e, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_REAL(5.5)))) >= 0);
 294         assert_se(streq_ptr(json_variant_string(json_variant_by_key(o, "method")), "io.test.IDontExist"));
 295         assert_se(streq(e, VARLINK_ERROR_METHOD_NOT_FOUND));
 296
 297         flood_test(arg);
 298
 299         assert_se(varlink_send(c, "io.test.Done", NULL) >= 0);
 300
 301         return NULL;
 302 }
 303
 304 static int block_fd_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 305         char c;
 306
 307         assert_se(fd_nonblock(fd, false) >= 0);
 308
 309         assert_se(read(fd, &c, sizeof(c)) == sizeof(c));
 310         /* When a character is written to this pipe we'll block until the pipe is closed. */
 311
 312         assert_se(read(fd, &c, sizeof(c)) == 0);
 313
 314         assert_se(fd_nonblock(fd, true) >= 0);
 315
 316         assert_se(sd_event_source_set_enabled(s, SD_EVENT_OFF) >= 0);
 317
 318         return 0;
 319 }
 320
 321 int main(int argc, char *argv[]) {
 322         _cleanup_(sd_event_source_unrefp) sd_event_source *block_event = NULL;
 323         _cleanup_(varlink_server_unrefp) VarlinkServer *s = NULL;
 324         _cleanup_(varlink_flush_close_unrefp) Varlink *c = NULL;
 325         _cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
 326         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
 327         _cleanup_(sd_event_unrefp) sd_event *e = NULL;
 328         _cleanup_close_pair_ int block_fds[2] = EBADF_PAIR;
 329         pthread_t t;
 330         const char *sp;
 331
 332         test_setup_logging(LOG_DEBUG);
 333
 334         assert_se(mkdtemp_malloc("/tmp/varlink-test-XXXXXX", &tmpdir) >= 0);
 335         sp = strjoina(tmpdir, "/socket");
 336
 337         assert_se(sd_event_default(&e) >= 0);
 338
 339         assert_se(pipe2(block_fds, O_NONBLOCK|O_CLOEXEC) >= 0);
 340         assert_se(sd_event_add_io(e, &block_event, block_fds[0], EPOLLIN, block_fd_handler, NULL) >= 0);
 341         assert_se(sd_event_source_set_priority(block_event, SD_EVENT_PRIORITY_IMPORTANT) >= 0);
 342         block_write_fd = TAKE_FD(block_fds[1]);
 343
 344         assert_se(varlink_server_new(&s, VARLINK_SERVER_ACCOUNT_UID) >= 0);
 345         assert_se(varlink_server_set_description(s, "our-server") >= 0);
 346
 347         assert_se(varlink_server_bind_method(s, "io.test.PassFD", method_passfd) >= 0);
 348         assert_se(varlink_server_bind_method(s, "io.test.DoSomething", method_something) >= 0);
 349         assert_se(varlink_server_bind_method(s, "io.test.DoSomethingMore", method_something_more) >= 0);
 350         assert_se(varlink_server_bind_method(s, "io.test.Done", method_done) >= 0);
 351         assert_se(varlink_server_bind_connect(s, on_connect) >= 0);
 352         assert_se(varlink_server_listen_address(s, sp, 0600) >= 0);
 353         assert_se(varlink_server_attach_event(s, e, 0) >= 0);
 354         assert_se(varlink_server_set_connections_max(s, OVERLOAD_CONNECTIONS) >= 0);
 355
 356         assert_se(json_build(&v, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("a", JSON_BUILD_INTEGER(7)),
 357                                                    JSON_BUILD_PAIR("b", JSON_BUILD_INTEGER(22)))) >= 0);
 358
 359         assert_se(varlink_connect_address(&c, sp) >= 0);
 360         assert_se(varlink_set_description(c, "main-client") >= 0);
 361         assert_se(varlink_bind_reply(c, reply) >= 0);
 362
 363         assert_se(varlink_invoke(c, "io.test.DoSomething", v) >= 0);
 364
 365         assert_se(varlink_attach_event(c, e, 0) >= 0);
 366
 367         assert_se(pthread_create(&t, NULL, thread, (void*) sp) == 0);
 368
 369         assert_se(sd_event_loop(e) >= 0);
 370
 371         assert_se(pthread_join(t, NULL) == 0);
 372
 373         return 0;
 374 }