[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, "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, "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
de1c301e LP	137	r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
	138	assert_se(r >= 0);
	139
	140	r = sd_bus_message_open_container(m, 'a', "s");
	141	assert_se(r >= 0);
	142
	143	r = sd_bus_message_append_basic(m, 's', "foobar");
	144	assert_se(r >= 0);
	145
	146	r = sd_bus_message_append_basic(m, 's', "waldo");
	147	assert_se(r >= 0);
	148
	149	r = sd_bus_message_close_container(m);
	150	assert_se(r >= 0);
	151
f8e013f8 LP	152	r = sd_bus_message_append_string_space(m, 5, &s);
	153	assert_se(r >= 0);
	154	strcpy(s, "hallo");
	155
b3af9646 LP	156	r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
	157	assert_se(r >= 0);
	158
5e86fd7b LP	159	r = sd_bus_message_append_array(m, 'u', NULL, 0);
	160	assert_se(r >= 0);
	161
6cd37a5e LP	162	r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/");
	163	assert_se(r >= 0);
	164
3df7a7e6	165	r = bus_message_seal(m, 4711, 0);
de1c301e LP	166	assert_se(r >= 0);
de1c301e LP	167
d55192ad	168	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	169
c430fee6 LP	170	ms = open_memstream(&first, &first_size);
d55192ad	171	bus_message_dump(m, ms, 0);
c430fee6 LP	172	fflush(ms);
c430fee6 LP	173	assert_se(!ferror(ms));
de1c301e LP	174
	175	r = bus_message_get_blob(m, &buffer, &sz);
	176	assert_se(r >= 0);
	177
	178	h = hexmem(buffer, sz);
	179	assert_se(h);
	180
de0671ee	181	log_info("message size = %zu, contents =\n%s", sz, h);
de1c301e LP	182	free(h);
	183
	184	#ifdef HAVE_GLIB
	185	{
	186	GDBusMessage *g;
	187	char *p;
	188
34f856cb	189	#if !defined(GLIB_VERSION_2_36)
de1c301e	190	g_type_init();
34f856cb	191	#endif
de1c301e LP	192
	193	g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
	194	p = g_dbus_message_print(g, 0);
	195	log_info("%s", p);
	196	g_free(p);
	197	g_object_unref(g);
	198	}
	199	#endif
	200
22703094	201	#ifdef HAVE_DBUS
de1c301e LP	202	{
	203	DBusMessage *w;
	204	DBusError error;
	205
	206	dbus_error_init(&error);
	207
	208	w = dbus_message_demarshal(buffer, sz, &error);
c1b9d935	209	if (!w)
de1c301e	210	log_error("%s", error.message);
c1b9d935	211	else
de1c301e LP	212	dbus_message_unref(w);
de1c301e LP	213	}
22703094	214	#endif
de1c301e	215
80a46c73 LP	216	m = sd_bus_message_unref(m);
80a46c73 LP	217
aa0d0ed6	218	r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, &m);
80a46c73 LP	219	assert_se(r >= 0);
80a46c73 LP	220
d55192ad	221	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	222
	223	fclose(ms);
	224	ms = open_memstream(&second, &second_size);
d55192ad	225	bus_message_dump(m, ms, 0);
c430fee6 LP	226	fflush(ms);
	227	assert_se(!ferror(ms));
	228	assert_se(first_size == second_size);
	229	assert_se(memcmp(first, second, first_size) == 0);
de1c301e	230
9a17484d LP	231	assert_se(sd_bus_message_rewind(m, true) >= 0);
9a17484d LP	232
d44fdf49	233	r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature);
9a17484d LP	234	assert_se(r > 0);
9a17484d LP	235	assert_se(streq(x, "a string"));
15912917	236	assert_se(streq(x2, ""));
9a17484d LP	237	assert_se(streq(y, "string #1"));
9a17484d LP	238	assert_se(streq(z, "string #2"));
d44fdf49	239	assert_se(streq(a_signature, "sba(tt)ss"));
9a17484d LP	240
	241	r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
	242	assert_se(r > 0);
	243	assert_se(streq(x, "foobar"));
	244	assert_se(streq(y, "foo"));
	245	assert_se(streq(z, "bar"));
	246	assert_se(streq(a, "waldo"));
	247	assert_se(streq(b, "piep"));
	248	assert_se(streq(c, "pap"));
	249	assert_se(streq(d, "after"));
	250
	251	r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
	252	assert_se(r > 0);
	253	assert_se(u == 3);
	254	assert_se(streq(x, "foo"));
	255	assert_se(v == 5);
	256	assert_se(streq(y, "waldo"));
	257
443a5598 DH	258	r = sd_bus_message_read(m, "y(ty)", &v, &u64, &u);
	259	assert_se(r > 0);
	260	assert_se(v == 8);
	261	assert_se(u64 == 777);
	262	assert_se(u == 7);
	263
	264	r = sd_bus_message_read(m, "y(yt)", &v, &u, &u64);
	265	assert_se(r > 0);
	266	assert_se(v == 9);
	267	assert_se(u == 77);
	268	assert_se(u64 == 7777);
	269
	270	r = sd_bus_message_read(m, "y", &v);
	271	assert_se(r > 0);
	272	assert_se(v == 10);
	273
9a17484d LP	274	r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
	275	assert_se(r > 0);
	276	assert_se(boolean);
	277	assert_se(streq(x, "aaa"));
	278	assert_se(streq(y, "1"));
	279	assert_se(streq(a, "bbb"));
	280	assert_se(streq(b, "2"));
	281	assert_se(streq(c, "ccc"));
	282	assert_se(streq(d, "3"));
	283
c430fee6 LP	284	assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
c430fee6 LP	285
9a17484d LP	286	r = sd_bus_message_read(m, "as", 2, &x, &y);
	287	assert_se(r > 0);
	288	assert_se(streq(x, "foobar"));
	289	assert_se(streq(y, "waldo"));
	290
f8e013f8 LP	291	r = sd_bus_message_read_basic(m, 's', &s);
	292	assert_se(r > 0);
	293	assert_se(streq(s, "hallo"));
	294
b3af9646 LP	295	r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
	296	assert_se(r > 0);
	297	assert_se(sz == sizeof(integer_array));
	298	assert_se(memcmp(integer_array, return_array, sz) == 0);
	299
5e86fd7b LP	300	r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
	301	assert_se(r > 0);
	302	assert_se(sz == 0);
	303
6cd37a5e LP	304	r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y);
	305	assert_se(r > 0);
	306	assert_se(streq(x, "foo"));
	307	assert_se(u64 == 815ULL);
	308	assert_se(fabs(dbl - 47.0) < 0.1);
	309	assert_se(streq(y, "/"));
	310
9a17484d LP	311	r = sd_bus_message_peek_type(m, NULL, NULL);
9a17484d LP	312	assert_se(r == 0);
de1c301e	313
2a0958d2	314	r = sd_bus_message_new_method_call(bus, &copy, "foobar.waldo", "/", "foobar.waldo", "Piep");
c430fee6 LP	315	assert_se(r >= 0);
	316
	317	r = sd_bus_message_rewind(m, true);
	318	assert_se(r >= 0);
	319
	320	r = sd_bus_message_copy(copy, m, true);
	321	assert_se(r >= 0);
	322
3df7a7e6	323	r = bus_message_seal(copy, 4712, 0);
c430fee6 LP	324	assert_se(r >= 0);
	325
	326	fclose(ms);
	327	ms = open_memstream(&third, &third_size);
d55192ad	328	bus_message_dump(copy, ms, 0);
c430fee6 LP	329	fflush(ms);
	330	assert_se(!ferror(ms));
	331
9b55cd56 ZJS	332	printf("<%.*s>\n", (int) first_size, first);
9b55cd56 ZJS	333	printf("<%.*s>\n", (int) third_size, third);
c430fee6 LP	334
	335	assert_se(first_size == third_size);
	336	assert_se(memcmp(first, third, third_size) == 0);
	337
9b07511d LP	338	r = sd_bus_message_rewind(m, true);
	339	assert_se(r >= 0);
	340
	341	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	342
d44fdf49	343	r = sd_bus_message_skip(m, "ssasg");
9b07511d LP	344	assert_se(r > 0);
	345
	346	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	347
	348	r = sd_bus_message_skip(m, "sass");
	349	assert_se(r >= 0);
	350
	351	assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
	352
443a5598	353	r = sd_bus_message_skip(m, "a{yv}y(ty)y(yt)y");
9b07511d LP	354	assert_se(r >= 0);
	355
	356	assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
	357
275b39fe	358	r = sd_bus_message_read(m, "b", &boolean);
9b07511d LP	359	assert_se(r > 0);
9b07511d LP	360	assert_se(boolean);
275b39fe LP	361
	362	r = sd_bus_message_enter_container(m, 0, NULL);
	363	assert_se(r > 0);
	364
	365	r = sd_bus_message_read(m, "(ss)", &x, &y);
	366	assert_se(r > 0);
	367
	368	r = sd_bus_message_read(m, "(ss)", &a, &b);
	369	assert_se(r > 0);
	370
	371	r = sd_bus_message_read(m, "(ss)", &c, &d);
	372	assert_se(r > 0);
	373
	374	r = sd_bus_message_read(m, "(ss)", &x, &y);
	375	assert_se(r == 0);
	376
	377	r = sd_bus_message_exit_container(m);
	378	assert_se(r >= 0);
	379
9b07511d LP	380	assert_se(streq(x, "aaa"));
	381	assert_se(streq(y, "1"));
	382	assert_se(streq(a, "bbb"));
	383	assert_se(streq(b, "2"));
	384	assert_se(streq(c, "ccc"));
	385	assert_se(streq(d, "3"));
	386
28383ba1	387	test_bus_label_escape();
a6278b88	388	test_bus_path_encode();
98a4c30b	389	test_bus_path_encode_unique();
28383ba1	390
de1c301e LP	391	return 0;
de1c301e LP	392	}