[thirdparty/systemd.git] / src / libsystemd-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 <assert.h>
#include <stdlib.h>
#include <byteswap.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"

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;
        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;

        r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &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, "as", 2, "string #1", "string #2");
        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, "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 = bus_message_seal(m, 4711);
        assert_se(r >= 0);

        bus_message_dump(m, stdout, true);

        ms = open_memstream(&first, &first_size);
        bus_message_dump(m, ms, false);
        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 = %lu, contents =\n%s", (unsigned long) 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(buffer, sz, NULL, 0, NULL, NULL, &m);
        assert_se(r >= 0);

        bus_message_dump(m, stdout, true);

        fclose(ms);
        ms = open_memstream(&second, &second_size);
        bus_message_dump(m, ms, false);
        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, "ssas", &x, &x2, 2, &y, &z);
        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"));

        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, "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_peek_type(m, NULL, NULL);
        assert_se(r == 0);

        r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &copy);
        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);
        assert_se(r >= 0);

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

        printf("<%.*s>", (int) first_size, first);
        printf("<%.*s>", (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, "ssas");
        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}");
        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"));

        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
	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
22703094	30	#ifdef HAVE_DBUS
718db961	31	#include <dbus/dbus.h>
22703094	32	#endif
de1c301e LP	33
	34	#include "log.h"
	35	#include "util.h"
	36
	37	#include "sd-bus.h"
	38	#include "bus-message.h"
40ca29a1	39	#include "bus-util.h"
2b5c5383	40	#include "bus-dump.h"
de1c301e LP	41
de1c301e LP	42	int main(int argc, char *argv[]) {
c430fee6	43	_cleanup_bus_message_unref_ sd_bus_message m = NULL, copy = NULL;
9a17484d	44	int r, boolean;
15912917	45	const char x, x2, y, z, a, b, c, d;
de1c301e LP	46	uint8_t u, v;
	47	void *buffer = NULL;
	48	size_t sz;
	49	char *h;
b3af9646	50	const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
f8e013f8	51	char *s;
c430fee6 LP	52	_cleanup_free_ char first = NULL, second = NULL, *third = NULL;
	53	_cleanup_fclose_ FILE *ms = NULL;
	54	size_t first_size = 0, second_size = 0, third_size = 0;
de1c301e LP	55
	56	r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &m);
	57	assert_se(r >= 0);
	58
	59	r = sd_bus_message_append(m, "s", "a string");
	60	assert_se(r >= 0);
	61
b8beb278	62	r = sd_bus_message_append(m, "s", NULL);
15912917	63	assert_se(r >= 0);
b8beb278	64
de1c301e LP	65	r = sd_bus_message_append(m, "as", 2, "string #1", "string #2");
	66	assert_se(r >= 0);
	67
	68	r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
	69	assert_se(r >= 0);
	70
	71	r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
	72	assert_se(r >= 0);
	73
	74	r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
	75	assert_se(r >= 0);
	76
	77	r = sd_bus_message_open_container(m, 'a', "s");
	78	assert_se(r >= 0);
	79
	80	r = sd_bus_message_append_basic(m, 's', "foobar");
	81	assert_se(r >= 0);
	82
	83	r = sd_bus_message_append_basic(m, 's', "waldo");
	84	assert_se(r >= 0);
	85
	86	r = sd_bus_message_close_container(m);
	87	assert_se(r >= 0);
	88
f8e013f8 LP	89	r = sd_bus_message_append_string_space(m, 5, &s);
	90	assert_se(r >= 0);
	91	strcpy(s, "hallo");
	92
b3af9646 LP	93	r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
	94	assert_se(r >= 0);
	95
5e86fd7b LP	96	r = sd_bus_message_append_array(m, 'u', NULL, 0);
	97	assert_se(r >= 0);
	98
9a17484d	99	r = bus_message_seal(m, 4711);
de1c301e LP	100	assert_se(r >= 0);
de1c301e LP	101
c430fee6 LP	102	bus_message_dump(m, stdout, true);
	103
	104	ms = open_memstream(&first, &first_size);
	105	bus_message_dump(m, ms, false);
	106	fflush(ms);
	107	assert_se(!ferror(ms));
de1c301e LP	108
	109	r = bus_message_get_blob(m, &buffer, &sz);
	110	assert_se(r >= 0);
	111
	112	h = hexmem(buffer, sz);
	113	assert_se(h);
	114
	115	log_info("message size = %lu, contents =\n%s", (unsigned long) sz, h);
	116	free(h);
	117
	118	#ifdef HAVE_GLIB
	119	{
	120	GDBusMessage *g;
	121	char *p;
	122
34f856cb	123	#if !defined(GLIB_VERSION_2_36)
de1c301e	124	g_type_init();
34f856cb	125	#endif
de1c301e LP	126
	127	g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
	128	p = g_dbus_message_print(g, 0);
	129	log_info("%s", p);
	130	g_free(p);
	131	g_object_unref(g);
	132	}
	133	#endif
	134
22703094	135	#ifdef HAVE_DBUS
de1c301e LP	136	{
	137	DBusMessage *w;
	138	DBusError error;
	139
	140	dbus_error_init(&error);
	141
	142	w = dbus_message_demarshal(buffer, sz, &error);
	143	if (!w) {
	144	log_error("%s", error.message);
	145	} else
	146	dbus_message_unref(w);
	147	}
22703094	148	#endif
de1c301e	149
80a46c73 LP	150	m = sd_bus_message_unref(m);
80a46c73 LP	151
2c93b4ef	152	r = bus_message_from_malloc(buffer, sz, NULL, 0, NULL, NULL, &m);
80a46c73 LP	153	assert_se(r >= 0);
80a46c73 LP	154
c430fee6 LP	155	bus_message_dump(m, stdout, true);
	156
	157	fclose(ms);
	158	ms = open_memstream(&second, &second_size);
	159	bus_message_dump(m, ms, false);
	160	fflush(ms);
	161	assert_se(!ferror(ms));
	162	assert_se(first_size == second_size);
	163	assert_se(memcmp(first, second, first_size) == 0);
de1c301e	164
9a17484d LP	165	assert_se(sd_bus_message_rewind(m, true) >= 0);
9a17484d LP	166
15912917	167	r = sd_bus_message_read(m, "ssas", &x, &x2, 2, &y, &z);
9a17484d LP	168	assert_se(r > 0);
9a17484d LP	169	assert_se(streq(x, "a string"));
15912917	170	assert_se(streq(x2, ""));
9a17484d LP	171	assert_se(streq(y, "string #1"));
	172	assert_se(streq(z, "string #2"));
	173
	174	r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
	175	assert_se(r > 0);
	176	assert_se(streq(x, "foobar"));
	177	assert_se(streq(y, "foo"));
	178	assert_se(streq(z, "bar"));
	179	assert_se(streq(a, "waldo"));
	180	assert_se(streq(b, "piep"));
	181	assert_se(streq(c, "pap"));
	182	assert_se(streq(d, "after"));
	183
	184	r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
	185	assert_se(r > 0);
	186	assert_se(u == 3);
	187	assert_se(streq(x, "foo"));
	188	assert_se(v == 5);
	189	assert_se(streq(y, "waldo"));
	190
	191	r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
	192	assert_se(r > 0);
	193	assert_se(boolean);
	194	assert_se(streq(x, "aaa"));
	195	assert_se(streq(y, "1"));
	196	assert_se(streq(a, "bbb"));
	197	assert_se(streq(b, "2"));
	198	assert_se(streq(c, "ccc"));
	199	assert_se(streq(d, "3"));
	200
c430fee6 LP	201	assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
c430fee6 LP	202
9a17484d LP	203	r = sd_bus_message_read(m, "as", 2, &x, &y);
	204	assert_se(r > 0);
	205	assert_se(streq(x, "foobar"));
	206	assert_se(streq(y, "waldo"));
	207
f8e013f8 LP	208	r = sd_bus_message_read_basic(m, 's', &s);
	209	assert_se(r > 0);
	210	assert_se(streq(s, "hallo"));
	211
b3af9646 LP	212	r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
	213	assert_se(r > 0);
	214	assert_se(sz == sizeof(integer_array));
	215	assert_se(memcmp(integer_array, return_array, sz) == 0);
	216
5e86fd7b LP	217	r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
	218	assert_se(r > 0);
	219	assert_se(sz == 0);
	220
9a17484d LP	221	r = sd_bus_message_peek_type(m, NULL, NULL);
9a17484d LP	222	assert_se(r == 0);
de1c301e	223
c430fee6 LP	224	r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &copy);
	225	assert_se(r >= 0);
	226
	227	r = sd_bus_message_rewind(m, true);
	228	assert_se(r >= 0);
	229
	230	r = sd_bus_message_copy(copy, m, true);
	231	assert_se(r >= 0);
	232
	233	r = bus_message_seal(copy, 4712);
	234	assert_se(r >= 0);
	235
	236	fclose(ms);
	237	ms = open_memstream(&third, &third_size);
	238	bus_message_dump(copy, ms, false);
	239	fflush(ms);
	240	assert_se(!ferror(ms));
	241
	242	printf("<%.*s>", (int) first_size, first);
	243	printf("<%.*s>", (int) third_size, third);
	244
	245	assert_se(first_size == third_size);
	246	assert_se(memcmp(first, third, third_size) == 0);
	247
9b07511d LP	248	r = sd_bus_message_rewind(m, true);
	249	assert_se(r >= 0);
	250
	251	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	252
15912917	253	r = sd_bus_message_skip(m, "ssas");
9b07511d LP	254	assert_se(r > 0);
	255
	256	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	257
	258	r = sd_bus_message_skip(m, "sass");
	259	assert_se(r >= 0);
	260
	261	assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
	262
	263	r = sd_bus_message_skip(m, "a{yv}");
	264	assert_se(r >= 0);
	265
	266	assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
	267
275b39fe	268	r = sd_bus_message_read(m, "b", &boolean);
9b07511d LP	269	assert_se(r > 0);
9b07511d LP	270	assert_se(boolean);
275b39fe LP	271
	272	r = sd_bus_message_enter_container(m, 0, NULL);
	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_read(m, "(ss)", &a, &b);
	279	assert_se(r > 0);
	280
	281	r = sd_bus_message_read(m, "(ss)", &c, &d);
	282	assert_se(r > 0);
	283
	284	r = sd_bus_message_read(m, "(ss)", &x, &y);
	285	assert_se(r == 0);
	286
	287	r = sd_bus_message_exit_container(m);
	288	assert_se(r >= 0);
	289
9b07511d LP	290	assert_se(streq(x, "aaa"));
	291	assert_se(streq(y, "1"));
	292	assert_se(streq(a, "bbb"));
	293	assert_se(streq(b, "2"));
	294	assert_se(streq(c, "ccc"));
	295	assert_se(streq(d, "3"));
	296
de1c301e LP	297	return 0;
de1c301e LP	298	}