src/libsystemd-bus/test-bus-marshal.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #include <byteswap.h>
  25
  26 #ifdef HAVE_GLIB
  27 #include <gio/gio.h>
  28 #endif
  29
  30 #ifdef HAVE_DBUS
  31 #include <dbus.h>
  32 #endif
  33
  34 #include "log.h"
  35 #include "util.h"
  36
  37 #include "sd-bus.h"
  38 #include "bus-message.h"
  39 #include "bus-util.h"
  40
  41 int main(int argc, char *argv[]) {
  42         _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *copy = NULL;
  43         int r, boolean;
  44         const char *x, *y, *z, *a, *b, *c, *d;
  45         uint8_t u, v;
  46         void *buffer = NULL;
  47         size_t sz;
  48         char *h;
  49         const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
  50         char *s;
  51         _cleanup_free_ char *first = NULL, *second = NULL, *third = NULL;
  52         _cleanup_fclose_ FILE *ms = NULL;
  53         size_t first_size = 0, second_size = 0, third_size = 0;
  54
  55         r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &m);
  56         assert_se(r >= 0);
  57
  58         r = sd_bus_message_append(m, "s", "a string");
  59         assert_se(r >= 0);
  60
  61         r = sd_bus_message_append(m, "s", NULL);
  62         assert_se(r < 0);
  63
  64         r = sd_bus_message_append(m, "as", 2, "string #1", "string #2");
  65         assert_se(r >= 0);
  66
  67         r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
  68         assert_se(r >= 0);
  69
  70         r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
  71         assert_se(r >= 0);
  72
  73         r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
  74         assert_se(r >= 0);
  75
  76         r = sd_bus_message_open_container(m, 'a', "s");
  77         assert_se(r >= 0);
  78
  79         r = sd_bus_message_append_basic(m, 's', "foobar");
  80         assert_se(r >= 0);
  81
  82         r = sd_bus_message_append_basic(m, 's', "waldo");
  83         assert_se(r >= 0);
  84
  85         r = sd_bus_message_close_container(m);
  86         assert_se(r >= 0);
  87
  88         r = sd_bus_message_append_string_space(m, 5, &s);
  89         assert_se(r >= 0);
  90         strcpy(s, "hallo");
  91
  92         r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
  93         assert_se(r >= 0);
  94
  95         r = bus_message_seal(m, 4711);
  96         assert_se(r >= 0);
  97
  98         bus_message_dump(m, stdout, true);
  99
 100         ms = open_memstream(&first, &first_size);
 101         bus_message_dump(m, ms, false);
 102         fflush(ms);
 103         assert_se(!ferror(ms));
 104
 105         r = bus_message_get_blob(m, &buffer, &sz);
 106         assert_se(r >= 0);
 107
 108         h = hexmem(buffer, sz);
 109         assert_se(h);
 110
 111         log_info("message size = %lu, contents =\n%s", (unsigned long) sz, h);
 112         free(h);
 113
 114 #ifdef HAVE_GLIB
 115         {
 116                 GDBusMessage *g;
 117                 char *p;
 118
 119 #if !defined(GLIB_VERSION_2_36)
 120                 g_type_init();
 121 #endif
 122
 123                 g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
 124                 p = g_dbus_message_print(g, 0);
 125                 log_info("%s", p);
 126                 g_free(p);
 127                 g_object_unref(g);
 128         }
 129 #endif
 130
 131 #ifdef HAVE_DBUS
 132         {
 133                 DBusMessage *w;
 134                 DBusError error;
 135
 136                 dbus_error_init(&error);
 137
 138                 w = dbus_message_demarshal(buffer, sz, &error);
 139                 if (!w) {
 140                         log_error("%s", error.message);
 141                 } else
 142                         dbus_message_unref(w);
 143         }
 144 #endif
 145
 146         m = sd_bus_message_unref(m);
 147
 148         r = bus_message_from_malloc(buffer, sz, NULL, 0, NULL, NULL, &m);
 149         assert_se(r >= 0);
 150
 151         bus_message_dump(m, stdout, true);
 152
 153         fclose(ms);
 154         ms = open_memstream(&second, &second_size);
 155         bus_message_dump(m, ms, false);
 156         fflush(ms);
 157         assert_se(!ferror(ms));
 158         assert_se(first_size == second_size);
 159         assert_se(memcmp(first, second, first_size) == 0);
 160
 161         assert_se(sd_bus_message_rewind(m, true) >= 0);
 162
 163         r = sd_bus_message_read(m, "sas", &x, 2, &y, &z);
 164         assert_se(r > 0);
 165         assert_se(streq(x, "a string"));
 166         assert_se(streq(y, "string #1"));
 167         assert_se(streq(z, "string #2"));
 168
 169         r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
 170         assert_se(r > 0);
 171         assert_se(streq(x, "foobar"));
 172         assert_se(streq(y, "foo"));
 173         assert_se(streq(z, "bar"));
 174         assert_se(streq(a, "waldo"));
 175         assert_se(streq(b, "piep"));
 176         assert_se(streq(c, "pap"));
 177         assert_se(streq(d, "after"));
 178
 179         r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
 180         assert_se(r > 0);
 181         assert_se(u == 3);
 182         assert_se(streq(x, "foo"));
 183         assert_se(v == 5);
 184         assert_se(streq(y, "waldo"));
 185
 186         r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
 187         assert_se(r > 0);
 188         assert_se(boolean);
 189         assert_se(streq(x, "aaa"));
 190         assert_se(streq(y, "1"));
 191         assert_se(streq(a, "bbb"));
 192         assert_se(streq(b, "2"));
 193         assert_se(streq(c, "ccc"));
 194         assert_se(streq(d, "3"));
 195
 196         assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
 197
 198         r = sd_bus_message_read(m, "as", 2, &x, &y);
 199         assert_se(r > 0);
 200         assert_se(streq(x, "foobar"));
 201         assert_se(streq(y, "waldo"));
 202
 203         r = sd_bus_message_read_basic(m, 's', &s);
 204         assert_se(r > 0);
 205         assert_se(streq(s, "hallo"));
 206
 207         r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
 208         assert_se(r > 0);
 209         assert_se(sz == sizeof(integer_array));
 210         assert_se(memcmp(integer_array, return_array, sz) == 0);
 211
 212         r = sd_bus_message_peek_type(m, NULL, NULL);
 213         assert_se(r == 0);
 214
 215         r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &copy);
 216         assert_se(r >= 0);
 217
 218         r = sd_bus_message_rewind(m, true);
 219         assert_se(r >= 0);
 220
 221         r = sd_bus_message_copy(copy, m, true);
 222         assert_se(r >= 0);
 223
 224         r = bus_message_seal(copy, 4712);
 225         assert_se(r >= 0);
 226
 227         fclose(ms);
 228         ms = open_memstream(&third, &third_size);
 229         bus_message_dump(copy, ms, false);
 230         fflush(ms);
 231         assert_se(!ferror(ms));
 232
 233         printf("<%.*s>", (int) first_size, first);
 234         printf("<%.*s>", (int) third_size, third);
 235
 236         assert_se(first_size == third_size);
 237         assert_se(memcmp(first, third, third_size) == 0);
 238
 239         r = sd_bus_message_rewind(m, true);
 240         assert_se(r >= 0);
 241
 242         assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
 243
 244         r = sd_bus_message_skip(m, "sas");
 245         assert_se(r > 0);
 246
 247         assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
 248
 249         r = sd_bus_message_skip(m, "sass");
 250         assert_se(r >= 0);
 251
 252         assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
 253
 254         r = sd_bus_message_skip(m, "a{yv}");
 255         assert_se(r >= 0);
 256
 257         assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
 258
 259         r = sd_bus_message_read(m, "b", &boolean);
 260         assert_se(r > 0);
 261         assert_se(boolean);
 262
 263         r = sd_bus_message_enter_container(m, 0, NULL);
 264         assert_se(r > 0);
 265
 266         r = sd_bus_message_read(m, "(ss)", &x, &y);
 267         assert_se(r > 0);
 268
 269         r = sd_bus_message_read(m, "(ss)", &a, &b);
 270         assert_se(r > 0);
 271
 272         r = sd_bus_message_read(m, "(ss)", &c, &d);
 273         assert_se(r > 0);
 274
 275         r = sd_bus_message_read(m, "(ss)", &x, &y);
 276         assert_se(r == 0);
 277
 278         r = sd_bus_message_exit_container(m);
 279         assert_se(r >= 0);
 280
 281         assert_se(streq(x, "aaa"));
 282         assert_se(streq(y, "1"));
 283         assert_se(streq(a, "bbb"));
 284         assert_se(streq(b, "2"));
 285         assert_se(streq(c, "ccc"));
 286         assert_se(streq(d, "3"));
 287
 288         return 0;
 289 }