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, *x2, *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, "ssas", &x, &x2, 2, &y, &z);
 164         assert_se(r > 0);
 165         assert_se(streq(x, "a string"));
 166         assert_se(streq(x2, ""));
 167         assert_se(streq(y, "string #1"));
 168         assert_se(streq(z, "string #2"));
 169
 170         r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
 171         assert_se(r > 0);
 172         assert_se(streq(x, "foobar"));
 173         assert_se(streq(y, "foo"));
 174         assert_se(streq(z, "bar"));
 175         assert_se(streq(a, "waldo"));
 176         assert_se(streq(b, "piep"));
 177         assert_se(streq(c, "pap"));
 178         assert_se(streq(d, "after"));
 179
 180         r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
 181         assert_se(r > 0);
 182         assert_se(u == 3);
 183         assert_se(streq(x, "foo"));
 184         assert_se(v == 5);
 185         assert_se(streq(y, "waldo"));
 186
 187         r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
 188         assert_se(r > 0);
 189         assert_se(boolean);
 190         assert_se(streq(x, "aaa"));
 191         assert_se(streq(y, "1"));
 192         assert_se(streq(a, "bbb"));
 193         assert_se(streq(b, "2"));
 194         assert_se(streq(c, "ccc"));
 195         assert_se(streq(d, "3"));
 196
 197         assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
 198
 199         r = sd_bus_message_read(m, "as", 2, &x, &y);
 200         assert_se(r > 0);
 201         assert_se(streq(x, "foobar"));
 202         assert_se(streq(y, "waldo"));
 203
 204         r = sd_bus_message_read_basic(m, 's', &s);
 205         assert_se(r > 0);
 206         assert_se(streq(s, "hallo"));
 207
 208         r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
 209         assert_se(r > 0);
 210         assert_se(sz == sizeof(integer_array));
 211         assert_se(memcmp(integer_array, return_array, sz) == 0);
 212
 213         r = sd_bus_message_peek_type(m, NULL, NULL);
 214         assert_se(r == 0);
 215
 216         r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &copy);
 217         assert_se(r >= 0);
 218
 219         r = sd_bus_message_rewind(m, true);
 220         assert_se(r >= 0);
 221
 222         r = sd_bus_message_copy(copy, m, true);
 223         assert_se(r >= 0);
 224
 225         r = bus_message_seal(copy, 4712);
 226         assert_se(r >= 0);
 227
 228         fclose(ms);
 229         ms = open_memstream(&third, &third_size);
 230         bus_message_dump(copy, ms, false);
 231         fflush(ms);
 232         assert_se(!ferror(ms));
 233
 234         printf("<%.*s>", (int) first_size, first);
 235         printf("<%.*s>", (int) third_size, third);
 236
 237         assert_se(first_size == third_size);
 238         assert_se(memcmp(first, third, third_size) == 0);
 239
 240         r = sd_bus_message_rewind(m, true);
 241         assert_se(r >= 0);
 242
 243         assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
 244
 245         r = sd_bus_message_skip(m, "ssas");
 246         assert_se(r > 0);
 247
 248         assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
 249
 250         r = sd_bus_message_skip(m, "sass");
 251         assert_se(r >= 0);
 252
 253         assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
 254
 255         r = sd_bus_message_skip(m, "a{yv}");
 256         assert_se(r >= 0);
 257
 258         assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
 259
 260         r = sd_bus_message_read(m, "b", &boolean);
 261         assert_se(r > 0);
 262         assert_se(boolean);
 263
 264         r = sd_bus_message_enter_container(m, 0, NULL);
 265         assert_se(r > 0);
 266
 267         r = sd_bus_message_read(m, "(ss)", &x, &y);
 268         assert_se(r > 0);
 269
 270         r = sd_bus_message_read(m, "(ss)", &a, &b);
 271         assert_se(r > 0);
 272
 273         r = sd_bus_message_read(m, "(ss)", &c, &d);
 274         assert_se(r > 0);
 275
 276         r = sd_bus_message_read(m, "(ss)", &x, &y);
 277         assert_se(r == 0);
 278
 279         r = sd_bus_message_exit_container(m);
 280         assert_se(r >= 0);
 281
 282         assert_se(streq(x, "aaa"));
 283         assert_se(streq(y, "1"));
 284         assert_se(streq(a, "bbb"));
 285         assert_se(streq(b, "2"));
 286         assert_se(streq(c, "ccc"));
 287         assert_se(streq(d, "3"));
 288
 289         return 0;
 290 }