[thirdparty/systemd.git] / src / libsystemd / sd-bus / test-bus-marshal.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdlib.h>
#include <math.h>

#ifdef HAVE_GLIB
#include <gio/gio.h>
#endif

#ifdef HAVE_DBUS
#include <dbus/dbus.h>
#endif

#include "log.h"
#include "util.h"

#include "sd-bus.h"
#include "bus-message.h"
#include "bus-util.h"
#include "bus-dump.h"
#include "bus-label.h"

static void test_bus_path_encode_unique(void) {
        _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL, *d = NULL, *e = NULL;

        assert_se(bus_path_encode_unique(NULL, "/foo/bar", "some.sender", "a.suffix", &a) >= 0 && streq_ptr(a, "/foo/bar/some_2esender/a_2esuffix"));
        assert_se(bus_path_decode_unique(a, "/foo/bar", &b, &c) > 0 && streq_ptr(b, "some.sender") && streq_ptr(c, "a.suffix"));
        assert_se(bus_path_decode_unique(a, "/bar/foo", &d, &d) == 0 && !d);
        assert_se(bus_path_decode_unique("/foo/bar/onlyOneSuffix", "/foo/bar", &d, &d) == 0 && !d);
        assert_se(bus_path_decode_unique("/foo/bar/_/_", "/foo/bar", &d, &e) > 0 && streq_ptr(d, "") && streq_ptr(e, ""));
}

static void test_bus_path_encode(void) {
        _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL, *d = NULL, *e = NULL, *f = NULL;

        assert_se(sd_bus_path_encode("/foo/bar", "waldo", &a) >= 0 && streq(a, "/foo/bar/waldo"));
        assert_se(sd_bus_path_decode(a, "/waldo", &b) == 0 && b == NULL);
        assert_se(sd_bus_path_decode(a, "/foo/bar", &b) > 0 && streq(b, "waldo"));

        assert_se(sd_bus_path_encode("xxxx", "waldo", &c) < 0);
        assert_se(sd_bus_path_encode("/foo/", "waldo", &c) < 0);

        assert_se(sd_bus_path_encode("/foo/bar", "", &c) >= 0 && streq(c, "/foo/bar/_"));
        assert_se(sd_bus_path_decode(c, "/foo/bar", &d) > 0 && streq(d, ""));

        assert_se(sd_bus_path_encode("/foo/bar", "foo.bar", &e) >= 0 && streq(e, "/foo/bar/foo_2ebar"));
        assert_se(sd_bus_path_decode(e, "/foo/bar", &f) > 0 && streq(f, "foo.bar"));
}

static void test_bus_label_escape_one(const char *a, const char *b) {
        _cleanup_free_ char *t = NULL, *x = NULL, *y = NULL;

        assert_se(t = bus_label_escape(a));
        assert_se(streq(t, b));

        assert_se(x = bus_label_unescape(t));
        assert_se(streq(a, x));

        assert_se(y = bus_label_unescape(b));
        assert_se(streq(a, y));
}

static void test_bus_label_escape(void) {
        test_bus_label_escape_one("foo123bar", "foo123bar");
        test_bus_label_escape_one("foo.bar", "foo_2ebar");
        test_bus_label_escape_one("foo_2ebar", "foo_5f2ebar");
        test_bus_label_escape_one("", "_");
        test_bus_label_escape_one("_", "_5f");
        test_bus_label_escape_one("1", "_31");
        test_bus_label_escape_one(":1", "_3a1");
}

int main(int argc, char *argv[]) {
        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *copy = NULL;
        int r, boolean;
        const char *x, *x2, *y, *z, *a, *b, *c, *d, *a_signature;
        uint8_t u, v;
        void *buffer = NULL;
        size_t sz;
        char *h;
        const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
        char *s;
        _cleanup_free_ char *first = NULL, *second = NULL, *third = NULL;
        _cleanup_fclose_ FILE *ms = NULL;
        size_t first_size = 0, second_size = 0, third_size = 0;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        double dbl;
        uint64_t u64;

        r = sd_bus_default_system(&bus);
        if (r < 0)
                return EXIT_TEST_SKIP;

        r = sd_bus_message_new_method_call(bus, &m, "foobar.waldo", "/", "foobar.waldo", "Piep");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "s", "a string");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "s", NULL);
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "asg", 2, "string #1", "string #2", "sba(tt)ss");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "y(ty)y(yt)y", 8, 777ULL, 7, 9, 77, 7777ULL, 10);
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "()");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
        assert_se(r >= 0);

        r = sd_bus_message_open_container(m, 'a', "s");
        assert_se(r >= 0);

        r = sd_bus_message_append_basic(m, 's', "foobar");
        assert_se(r >= 0);

        r = sd_bus_message_append_basic(m, 's', "waldo");
        assert_se(r >= 0);

        r = sd_bus_message_close_container(m);
        assert_se(r >= 0);

        r = sd_bus_message_append_string_space(m, 5, &s);
        assert_se(r >= 0);
        strcpy(s, "hallo");

        r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
        assert_se(r >= 0);

        r = sd_bus_message_append_array(m, 'u', NULL, 0);
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/");
        assert_se(r >= 0);

        r = bus_message_seal(m, 4711, 0);
        assert_se(r >= 0);

        bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);

        ms = open_memstream(&first, &first_size);
        bus_message_dump(m, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));

        r = bus_message_get_blob(m, &buffer, &sz);
        assert_se(r >= 0);

        h = hexmem(buffer, sz);
        assert_se(h);

        log_info("message size = %zu, contents =\n%s", sz, h);
        free(h);

#ifdef HAVE_GLIB
        {
                GDBusMessage *g;
                char *p;

#if !defined(GLIB_VERSION_2_36)
                g_type_init();
#endif

                g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
                p = g_dbus_message_print(g, 0);
                log_info("%s", p);
                g_free(p);
                g_object_unref(g);
        }
#endif

#ifdef HAVE_DBUS
        {
                DBusMessage *w;
                DBusError error;

                dbus_error_init(&error);

                w = dbus_message_demarshal(buffer, sz, &error);
                if (!w)
                        log_error("%s", error.message);
                else
                        dbus_message_unref(w);
        }
#endif

        m = sd_bus_message_unref(m);

        r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, &m);
        assert_se(r >= 0);

        bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);

        fclose(ms);
        ms = open_memstream(&second, &second_size);
        bus_message_dump(m, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));
        assert_se(first_size == second_size);
        assert_se(memcmp(first, second, first_size) == 0);

        assert_se(sd_bus_message_rewind(m, true) >= 0);

        r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature);
        assert_se(r > 0);
        assert_se(streq(x, "a string"));
        assert_se(streq(x2, ""));
        assert_se(streq(y, "string #1"));
        assert_se(streq(z, "string #2"));
        assert_se(streq(a_signature, "sba(tt)ss"));

        r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
        assert_se(r > 0);
        assert_se(streq(x, "foobar"));
        assert_se(streq(y, "foo"));
        assert_se(streq(z, "bar"));
        assert_se(streq(a, "waldo"));
        assert_se(streq(b, "piep"));
        assert_se(streq(c, "pap"));
        assert_se(streq(d, "after"));

        r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
        assert_se(r > 0);
        assert_se(u == 3);
        assert_se(streq(x, "foo"));
        assert_se(v == 5);
        assert_se(streq(y, "waldo"));

        r = sd_bus_message_read(m, "y(ty)", &v, &u64, &u);
        assert_se(r > 0);
        assert_se(v == 8);
        assert_se(u64 == 777);
        assert_se(u == 7);

        r = sd_bus_message_read(m, "y(yt)", &v, &u, &u64);
        assert_se(r > 0);
        assert_se(v == 9);
        assert_se(u == 77);
        assert_se(u64 == 7777);

        r = sd_bus_message_read(m, "y", &v);
        assert_se(r > 0);
        assert_se(v == 10);

        r = sd_bus_message_read(m, "()");
        assert_se(r > 0);

        r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
        assert_se(r > 0);
        assert_se(boolean);
        assert_se(streq(x, "aaa"));
        assert_se(streq(y, "1"));
        assert_se(streq(a, "bbb"));
        assert_se(streq(b, "2"));
        assert_se(streq(c, "ccc"));
        assert_se(streq(d, "3"));

        assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);

        r = sd_bus_message_read(m, "as", 2, &x, &y);
        assert_se(r > 0);
        assert_se(streq(x, "foobar"));
        assert_se(streq(y, "waldo"));

        r = sd_bus_message_read_basic(m, 's', &s);
        assert_se(r > 0);
        assert_se(streq(s, "hallo"));

        r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
        assert_se(r > 0);
        assert_se(sz == sizeof(integer_array));
        assert_se(memcmp(integer_array, return_array, sz) == 0);

        r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
        assert_se(r > 0);
        assert_se(sz == 0);

        r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y);
        assert_se(r > 0);
        assert_se(streq(x, "foo"));
        assert_se(u64 == 815ULL);
        assert_se(fabs(dbl - 47.0) < 0.1);
        assert_se(streq(y, "/"));

        r = sd_bus_message_peek_type(m, NULL, NULL);
        assert_se(r == 0);

        r = sd_bus_message_new_method_call(bus, &copy, "foobar.waldo", "/", "foobar.waldo", "Piep");
        assert_se(r >= 0);

        r = sd_bus_message_rewind(m, true);
        assert_se(r >= 0);

        r = sd_bus_message_copy(copy, m, true);
        assert_se(r >= 0);

        r = bus_message_seal(copy, 4712, 0);
        assert_se(r >= 0);

        fclose(ms);
        ms = open_memstream(&third, &third_size);
        bus_message_dump(copy, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));

        printf("<%.*s>\n", (int) first_size, first);
        printf("<%.*s>\n", (int) third_size, third);

        assert_se(first_size == third_size);
        assert_se(memcmp(first, third, third_size) == 0);

        r = sd_bus_message_rewind(m, true);
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);

        r = sd_bus_message_skip(m, "ssasg");
        assert_se(r > 0);

        assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);

        r = sd_bus_message_skip(m, "sass");
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);

        r = sd_bus_message_skip(m, "a{yv}y(ty)y(yt)y()");
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);

        r = sd_bus_message_read(m, "b", &boolean);
        assert_se(r > 0);
        assert_se(boolean);

        r = sd_bus_message_enter_container(m, 0, NULL);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &x, &y);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &a, &b);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &c, &d);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &x, &y);
        assert_se(r == 0);

        r = sd_bus_message_exit_container(m);
        assert_se(r >= 0);

        assert_se(streq(x, "aaa"));
        assert_se(streq(y, "1"));
        assert_se(streq(a, "bbb"));
        assert_se(streq(b, "2"));
        assert_se(streq(c, "ccc"));
        assert_se(streq(d, "3"));

        test_bus_label_escape();
        test_bus_path_encode();
        test_bus_path_encode_unique();

        return 0;
}
Commit	Line	Data
de1c301e LP	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
de1c301e	22	#include <stdlib.h>
6cd37a5e	23	#include <math.h>
de1c301e LP	24
	25	#ifdef HAVE_GLIB
	26	#include <gio/gio.h>
	27	#endif
	28
22703094	29	#ifdef HAVE_DBUS
718db961	30	#include <dbus/dbus.h>
22703094	31	#endif
de1c301e LP	32
	33	#include "log.h"
	34	#include "util.h"
	35
	36	#include "sd-bus.h"
	37	#include "bus-message.h"
40ca29a1	38	#include "bus-util.h"
2b5c5383	39	#include "bus-dump.h"
a6278b88 LP	40	#include "bus-label.h"
a6278b88 LP	41
98a4c30b DH	42	static void test_bus_path_encode_unique(void) {
	43	_cleanup_free_ char a = NULL, b = NULL, c = NULL, d = NULL, *e = NULL;
	44
	45	assert_se(bus_path_encode_unique(NULL, "/foo/bar", "some.sender", "a.suffix", &a) >= 0 && streq_ptr(a, "/foo/bar/some_2esender/a_2esuffix"));
	46	assert_se(bus_path_decode_unique(a, "/foo/bar", &b, &c) > 0 && streq_ptr(b, "some.sender") && streq_ptr(c, "a.suffix"));
	47	assert_se(bus_path_decode_unique(a, "/bar/foo", &d, &d) == 0 && !d);
	48	assert_se(bus_path_decode_unique("/foo/bar/onlyOneSuffix", "/foo/bar", &d, &d) == 0 && !d);
	49	assert_se(bus_path_decode_unique("/foo/bar/_/_", "/foo/bar", &d, &e) > 0 && streq_ptr(d, "") && streq_ptr(e, ""));
	50	}
	51
a6278b88 LP	52	static void test_bus_path_encode(void) {
	53	_cleanup_free_ char a = NULL, b = NULL, c = NULL, d = NULL, e = NULL, f = NULL;
	54
	55	assert_se(sd_bus_path_encode("/foo/bar", "waldo", &a) >= 0 && streq(a, "/foo/bar/waldo"));
	56	assert_se(sd_bus_path_decode(a, "/waldo", &b) == 0 && b == NULL);
	57	assert_se(sd_bus_path_decode(a, "/foo/bar", &b) > 0 && streq(b, "waldo"));
	58
	59	assert_se(sd_bus_path_encode("xxxx", "waldo", &c) < 0);
	60	assert_se(sd_bus_path_encode("/foo/", "waldo", &c) < 0);
	61
	62	assert_se(sd_bus_path_encode("/foo/bar", "", &c) >= 0 && streq(c, "/foo/bar/_"));
	63	assert_se(sd_bus_path_decode(c, "/foo/bar", &d) > 0 && streq(d, ""));
	64
	65	assert_se(sd_bus_path_encode("/foo/bar", "foo.bar", &e) >= 0 && streq(e, "/foo/bar/foo_2ebar"));
	66	assert_se(sd_bus_path_decode(e, "/foo/bar", &f) > 0 && streq(f, "foo.bar"));
	67	}
de1c301e	68
28383ba1 LP	69	static void test_bus_label_escape_one(const char a, const char b) {
	70	_cleanup_free_ char t = NULL, x = NULL, *y = NULL;
	71
a6278b88	72	assert_se(t = bus_label_escape(a));
28383ba1 LP	73	assert_se(streq(t, b));
28383ba1 LP	74
a6278b88	75	assert_se(x = bus_label_unescape(t));
28383ba1 LP	76	assert_se(streq(a, x));
28383ba1 LP	77
a6278b88	78	assert_se(y = bus_label_unescape(b));
28383ba1 LP	79	assert_se(streq(a, y));
	80	}
	81
	82	static void test_bus_label_escape(void) {
	83	test_bus_label_escape_one("foo123bar", "foo123bar");
	84	test_bus_label_escape_one("foo.bar", "foo_2ebar");
	85	test_bus_label_escape_one("foo_2ebar", "foo_5f2ebar");
	86	test_bus_label_escape_one("", "_");
	87	test_bus_label_escape_one("_", "_5f");
	88	test_bus_label_escape_one("1", "_31");
	89	test_bus_label_escape_one(":1", "_3a1");
	90	}
	91
de1c301e	92	int main(int argc, char *argv[]) {
c430fee6	93	_cleanup_bus_message_unref_ sd_bus_message m = NULL, copy = NULL;
9a17484d	94	int r, boolean;
d44fdf49	95	const char x, x2, y, z, a, b, c, d, *a_signature;
de1c301e LP	96	uint8_t u, v;
	97	void *buffer = NULL;
	98	size_t sz;
	99	char *h;
b3af9646	100	const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
f8e013f8	101	char *s;
c430fee6 LP	102	_cleanup_free_ char first = NULL, second = NULL, *third = NULL;
	103	_cleanup_fclose_ FILE *ms = NULL;
	104	size_t first_size = 0, second_size = 0, third_size = 0;
2a0958d2	105	_cleanup_bus_unref_ sd_bus *bus = NULL;
6cd37a5e LP	106	double dbl;
6cd37a5e LP	107	uint64_t u64;
de1c301e	108
2a0958d2 LP	109	r = sd_bus_default_system(&bus);
	110	if (r < 0)
	111	return EXIT_TEST_SKIP;
	112
	113	r = sd_bus_message_new_method_call(bus, &m, "foobar.waldo", "/", "foobar.waldo", "Piep");
de1c301e LP	114	assert_se(r >= 0);
de1c301e LP	115
effbc8e4 ZJS	116	r = sd_bus_message_append(m, "");
	117	assert_se(r >= 0);
	118
de1c301e LP	119	r = sd_bus_message_append(m, "s", "a string");
	120	assert_se(r >= 0);
	121
b8beb278	122	r = sd_bus_message_append(m, "s", NULL);
15912917	123	assert_se(r >= 0);
b8beb278	124
d44fdf49	125	r = sd_bus_message_append(m, "asg", 2, "string #1", "string #2", "sba(tt)ss");
de1c301e LP	126	assert_se(r >= 0);
	127
	128	r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
	129	assert_se(r >= 0);
	130
	131	r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
	132	assert_se(r >= 0);
	133
4f1d7741	134	r = sd_bus_message_append(m, "y(ty)y(yt)y", 8, 777ULL, 7, 9, 77, 7777ULL, 10);
443a5598 DH	135	assert_se(r >= 0);
443a5598 DH	136
a388569f DH	137	r = sd_bus_message_append(m, "()");
	138	assert_se(r >= 0);
	139
de1c301e LP	140	r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
	141	assert_se(r >= 0);
	142
	143	r = sd_bus_message_open_container(m, 'a', "s");
	144	assert_se(r >= 0);
	145
	146	r = sd_bus_message_append_basic(m, 's', "foobar");
	147	assert_se(r >= 0);
	148
	149	r = sd_bus_message_append_basic(m, 's', "waldo");
	150	assert_se(r >= 0);
	151
	152	r = sd_bus_message_close_container(m);
	153	assert_se(r >= 0);
	154
f8e013f8 LP	155	r = sd_bus_message_append_string_space(m, 5, &s);
	156	assert_se(r >= 0);
	157	strcpy(s, "hallo");
	158
b3af9646 LP	159	r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
	160	assert_se(r >= 0);
	161
5e86fd7b LP	162	r = sd_bus_message_append_array(m, 'u', NULL, 0);
	163	assert_se(r >= 0);
	164
6cd37a5e LP	165	r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/");
	166	assert_se(r >= 0);
	167
3df7a7e6	168	r = bus_message_seal(m, 4711, 0);
de1c301e LP	169	assert_se(r >= 0);
de1c301e LP	170
d55192ad	171	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	172
c430fee6 LP	173	ms = open_memstream(&first, &first_size);
d55192ad	174	bus_message_dump(m, ms, 0);
c430fee6 LP	175	fflush(ms);
c430fee6 LP	176	assert_se(!ferror(ms));
de1c301e LP	177
	178	r = bus_message_get_blob(m, &buffer, &sz);
	179	assert_se(r >= 0);
	180
	181	h = hexmem(buffer, sz);
	182	assert_se(h);
	183
de0671ee	184	log_info("message size = %zu, contents =\n%s", sz, h);
de1c301e LP	185	free(h);
	186
	187	#ifdef HAVE_GLIB
	188	{
	189	GDBusMessage *g;
	190	char *p;
	191
34f856cb	192	#if !defined(GLIB_VERSION_2_36)
de1c301e	193	g_type_init();
34f856cb	194	#endif
de1c301e LP	195
	196	g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
	197	p = g_dbus_message_print(g, 0);
	198	log_info("%s", p);
	199	g_free(p);
	200	g_object_unref(g);
	201	}
	202	#endif
	203
22703094	204	#ifdef HAVE_DBUS
de1c301e LP	205	{
	206	DBusMessage *w;
	207	DBusError error;
	208
	209	dbus_error_init(&error);
	210
	211	w = dbus_message_demarshal(buffer, sz, &error);
c1b9d935	212	if (!w)
de1c301e	213	log_error("%s", error.message);
c1b9d935	214	else
de1c301e LP	215	dbus_message_unref(w);
de1c301e LP	216	}
22703094	217	#endif
de1c301e	218
80a46c73 LP	219	m = sd_bus_message_unref(m);
80a46c73 LP	220
aa0d0ed6	221	r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, &m);
80a46c73 LP	222	assert_se(r >= 0);
80a46c73 LP	223
d55192ad	224	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	225
	226	fclose(ms);
	227	ms = open_memstream(&second, &second_size);
d55192ad	228	bus_message_dump(m, ms, 0);
c430fee6 LP	229	fflush(ms);
	230	assert_se(!ferror(ms));
	231	assert_se(first_size == second_size);
	232	assert_se(memcmp(first, second, first_size) == 0);
de1c301e	233
9a17484d LP	234	assert_se(sd_bus_message_rewind(m, true) >= 0);
9a17484d LP	235
d44fdf49	236	r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature);
9a17484d LP	237	assert_se(r > 0);
9a17484d LP	238	assert_se(streq(x, "a string"));
15912917	239	assert_se(streq(x2, ""));
9a17484d LP	240	assert_se(streq(y, "string #1"));
9a17484d LP	241	assert_se(streq(z, "string #2"));
d44fdf49	242	assert_se(streq(a_signature, "sba(tt)ss"));
9a17484d LP	243
	244	r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
	245	assert_se(r > 0);
	246	assert_se(streq(x, "foobar"));
	247	assert_se(streq(y, "foo"));
	248	assert_se(streq(z, "bar"));
	249	assert_se(streq(a, "waldo"));
	250	assert_se(streq(b, "piep"));
	251	assert_se(streq(c, "pap"));
	252	assert_se(streq(d, "after"));
	253
	254	r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
	255	assert_se(r > 0);
	256	assert_se(u == 3);
	257	assert_se(streq(x, "foo"));
	258	assert_se(v == 5);
	259	assert_se(streq(y, "waldo"));
	260
443a5598 DH	261	r = sd_bus_message_read(m, "y(ty)", &v, &u64, &u);
	262	assert_se(r > 0);
	263	assert_se(v == 8);
	264	assert_se(u64 == 777);
	265	assert_se(u == 7);
	266
	267	r = sd_bus_message_read(m, "y(yt)", &v, &u, &u64);
	268	assert_se(r > 0);
	269	assert_se(v == 9);
	270	assert_se(u == 77);
	271	assert_se(u64 == 7777);
	272
	273	r = sd_bus_message_read(m, "y", &v);
	274	assert_se(r > 0);
	275	assert_se(v == 10);
	276
a388569f DH	277	r = sd_bus_message_read(m, "()");
	278	assert_se(r > 0);
	279
9a17484d LP	280	r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
	281	assert_se(r > 0);
	282	assert_se(boolean);
	283	assert_se(streq(x, "aaa"));
	284	assert_se(streq(y, "1"));
	285	assert_se(streq(a, "bbb"));
	286	assert_se(streq(b, "2"));
	287	assert_se(streq(c, "ccc"));
	288	assert_se(streq(d, "3"));
	289
c430fee6 LP	290	assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
c430fee6 LP	291
9a17484d LP	292	r = sd_bus_message_read(m, "as", 2, &x, &y);
	293	assert_se(r > 0);
	294	assert_se(streq(x, "foobar"));
	295	assert_se(streq(y, "waldo"));
	296
f8e013f8 LP	297	r = sd_bus_message_read_basic(m, 's', &s);
	298	assert_se(r > 0);
	299	assert_se(streq(s, "hallo"));
	300
b3af9646 LP	301	r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
	302	assert_se(r > 0);
	303	assert_se(sz == sizeof(integer_array));
	304	assert_se(memcmp(integer_array, return_array, sz) == 0);
	305
5e86fd7b LP	306	r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
	307	assert_se(r > 0);
	308	assert_se(sz == 0);
	309
6cd37a5e LP	310	r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y);
	311	assert_se(r > 0);
	312	assert_se(streq(x, "foo"));
	313	assert_se(u64 == 815ULL);
	314	assert_se(fabs(dbl - 47.0) < 0.1);
	315	assert_se(streq(y, "/"));
	316
9a17484d LP	317	r = sd_bus_message_peek_type(m, NULL, NULL);
9a17484d LP	318	assert_se(r == 0);
de1c301e	319
2a0958d2	320	r = sd_bus_message_new_method_call(bus, &copy, "foobar.waldo", "/", "foobar.waldo", "Piep");
c430fee6 LP	321	assert_se(r >= 0);
	322
	323	r = sd_bus_message_rewind(m, true);
	324	assert_se(r >= 0);
	325
	326	r = sd_bus_message_copy(copy, m, true);
	327	assert_se(r >= 0);
	328
3df7a7e6	329	r = bus_message_seal(copy, 4712, 0);
c430fee6 LP	330	assert_se(r >= 0);
	331
	332	fclose(ms);
	333	ms = open_memstream(&third, &third_size);
d55192ad	334	bus_message_dump(copy, ms, 0);
c430fee6 LP	335	fflush(ms);
	336	assert_se(!ferror(ms));
	337
9b55cd56 ZJS	338	printf("<%.*s>\n", (int) first_size, first);
9b55cd56 ZJS	339	printf("<%.*s>\n", (int) third_size, third);
c430fee6 LP	340
	341	assert_se(first_size == third_size);
	342	assert_se(memcmp(first, third, third_size) == 0);
	343
9b07511d LP	344	r = sd_bus_message_rewind(m, true);
	345	assert_se(r >= 0);
	346
	347	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	348
d44fdf49	349	r = sd_bus_message_skip(m, "ssasg");
9b07511d LP	350	assert_se(r > 0);
	351
	352	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	353
	354	r = sd_bus_message_skip(m, "sass");
	355	assert_se(r >= 0);
	356
	357	assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
	358
a388569f	359	r = sd_bus_message_skip(m, "a{yv}y(ty)y(yt)y()");
9b07511d LP	360	assert_se(r >= 0);
	361
	362	assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
	363
275b39fe	364	r = sd_bus_message_read(m, "b", &boolean);
9b07511d LP	365	assert_se(r > 0);
9b07511d LP	366	assert_se(boolean);
275b39fe LP	367
	368	r = sd_bus_message_enter_container(m, 0, NULL);
	369	assert_se(r > 0);
	370
	371	r = sd_bus_message_read(m, "(ss)", &x, &y);
	372	assert_se(r > 0);
	373
	374	r = sd_bus_message_read(m, "(ss)", &a, &b);
	375	assert_se(r > 0);
	376
	377	r = sd_bus_message_read(m, "(ss)", &c, &d);
	378	assert_se(r > 0);
	379
	380	r = sd_bus_message_read(m, "(ss)", &x, &y);
	381	assert_se(r == 0);
	382
	383	r = sd_bus_message_exit_container(m);
	384	assert_se(r >= 0);
	385
9b07511d LP	386	assert_se(streq(x, "aaa"));
	387	assert_se(streq(y, "1"));
	388	assert_se(streq(a, "bbb"));
	389	assert_se(streq(b, "2"));
	390	assert_se(streq(c, "ccc"));
	391	assert_se(streq(d, "3"));
	392
28383ba1	393	test_bus_label_escape();
a6278b88	394	test_bus_path_encode();
98a4c30b	395	test_bus_path_encode_unique();
28383ba1	396
de1c301e LP	397	return 0;
de1c301e LP	398	}