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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  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 "bus-gvariant.h"
#include "bus-signature.h"
#include "bus-type.h"

int bus_gvariant_get_size(const char *signature) {
        const char *p;
        int sum = 0, r;

        /* For fixed size structs. Fails for variable size structs. */

        p = signature;
        while (*p != 0) {
                size_t n;

                r = signature_element_length(p, &n);
                if (r < 0)
                        return r;
                else {
                        char t[n+1];

                        memcpy(t, p, n);
                        t[n] = 0;

                        r = bus_gvariant_get_alignment(t);
                        if (r < 0)
                                return r;

                        sum = ALIGN_TO(sum, r);
                }

                switch (*p) {

                case SD_BUS_TYPE_BOOLEAN:
                case SD_BUS_TYPE_BYTE:
                        sum += 1;
                        break;

                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16:
                        sum += 2;
                        break;

                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                case SD_BUS_TYPE_UNIX_FD:
                        sum += 4;
                        break;

                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64:
                case SD_BUS_TYPE_DOUBLE:
                        sum += 8;
                        break;

                case SD_BUS_TYPE_STRUCT_BEGIN:
                case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                        if (n == 2) {
                                /* unary type () has fixed size of 1 */
                                r = 1;
                        } else {
                                char t[n-1];

                                memcpy(t, p + 1, n - 2);
                                t[n - 2] = 0;

                                r = bus_gvariant_get_size(t);
                                if (r < 0)
                                        return r;
                        }

                        sum += r;
                        break;
                }

                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE:
                case SD_BUS_TYPE_ARRAY:
                case SD_BUS_TYPE_VARIANT:
                        return -EINVAL;

                default:
                        assert_not_reached("Unknown signature type");
                }

                p += n;
        }

        r = bus_gvariant_get_alignment(signature);
        if (r < 0)
                return r;

        return ALIGN_TO(sum, r);
}

int bus_gvariant_get_alignment(const char *signature) {
        size_t alignment = 1;
        const char *p;
        int r;

        p = signature;
        while (*p != 0 && alignment < 8) {
                size_t n;
                int a;

                r = signature_element_length(p, &n);
                if (r < 0)
                        return r;

                switch (*p) {

                case SD_BUS_TYPE_BYTE:
                case SD_BUS_TYPE_BOOLEAN:
                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE:
                        a = 1;
                        break;

                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16:
                        a = 2;
                        break;

                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                case SD_BUS_TYPE_UNIX_FD:
                        a = 4;
                        break;

                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64:
                case SD_BUS_TYPE_DOUBLE:
                case SD_BUS_TYPE_VARIANT:
                        a = 8;
                        break;

                case SD_BUS_TYPE_ARRAY: {
                        char t[n];

                        memcpy(t, p + 1, n - 1);
                        t[n - 1] = 0;

                        a = bus_gvariant_get_alignment(t);
                        break;
                }

                case SD_BUS_TYPE_STRUCT_BEGIN:
                case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                        char t[n-1];

                        memcpy(t, p + 1, n - 2);
                        t[n - 2] = 0;

                        a = bus_gvariant_get_alignment(t);
                        break;
                }

                default:
                        assert_not_reached("Unknown signature type");
                }

                if (a < 0)
                        return a;

                assert(a > 0 && a <= 8);
                if ((size_t) a > alignment)
                        alignment = (size_t) a;

                p += n;
        }

        return alignment;
}

int bus_gvariant_is_fixed_size(const char *signature) {
        const char *p;
        int r;

        assert(signature);

        p = signature;
        while (*p != 0) {
                size_t n;

                r = signature_element_length(p, &n);
                if (r < 0)
                        return r;

                switch (*p) {

                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE:
                case SD_BUS_TYPE_ARRAY:
                case SD_BUS_TYPE_VARIANT:
                        return 0;

                case SD_BUS_TYPE_BYTE:
                case SD_BUS_TYPE_BOOLEAN:
                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16:
                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                case SD_BUS_TYPE_UNIX_FD:
                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64:
                case SD_BUS_TYPE_DOUBLE:
                        break;

                case SD_BUS_TYPE_STRUCT_BEGIN:
                case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                        char t[n-1];

                        memcpy(t, p + 1, n - 2);
                        t[n - 2] = 0;

                        r = bus_gvariant_is_fixed_size(t);
                        if (r <= 0)
                                return r;
                        break;
                }

                default:
                        assert_not_reached("Unknown signature type");
                }

                p += n;
        }

        return true;
}

size_t bus_gvariant_determine_word_size(size_t sz, size_t extra) {
        if (sz + extra <= 0xFF)
                return 1;
        else if (sz + extra*2 <= 0xFFFF)
                return 2;
        else if (sz + extra*4 <= 0xFFFFFFFF)
                return 4;
        else
                return 8;
}

size_t bus_gvariant_read_word_le(void *p, size_t sz) {
        union {
                uint16_t u16;
                uint32_t u32;
                uint64_t u64;
        } x;

        assert(p);

        if (sz == 1)
                return *(uint8_t*) p;

        memcpy(&x, p, sz);

        if (sz == 2)
                return le16toh(x.u16);
        else if (sz == 4)
                return le32toh(x.u32);
        else if (sz == 8)
                return le64toh(x.u64);

        assert_not_reached("unknown word width");
}

void bus_gvariant_write_word_le(void *p, size_t sz, size_t value) {
        union {
                uint16_t u16;
                uint32_t u32;
                uint64_t u64;
        } x;

        assert(p);
        assert(sz == 8 || (value < (1ULL << (sz*8))));

        if (sz == 1) {
                *(uint8_t*) p = value;
                return;
        } else if (sz == 2)
                x.u16 = htole16((uint16_t) value);
        else if (sz == 4)
                x.u32 = htole32((uint32_t) value);
        else if (sz == 8)
                x.u64 = htole64((uint64_t) value);
        else
                assert_not_reached("unknown word width");

        memcpy(p, &x, sz);
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1+ */
	2	/***
	3	This file is part of systemd.
	4
	5	Copyright 2013 Lennart Poettering
	6
	7	systemd is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU Lesser General Public License as published by
	9	the Free Software Foundation; either version 2.1 of the License, or
	10	(at your option) any later version.
	11
	12	systemd is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	Lesser General Public License for more details.
	16
	17	You should have received a copy of the GNU Lesser General Public License
	18	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	19	***/
	20
	21	#include "bus-gvariant.h"
	22	#include "bus-signature.h"
	23	#include "bus-type.h"
	24
	25	int bus_gvariant_get_size(const char *signature) {
	26	const char *p;
	27	int sum = 0, r;
	28
	29	/* For fixed size structs. Fails for variable size structs. */
	30
	31	p = signature;
	32	while (*p != 0) {
	33	size_t n;
	34
	35	r = signature_element_length(p, &n);
	36	if (r < 0)
	37	return r;
	38	else {
	39	char t[n+1];
	40
	41	memcpy(t, p, n);
	42	t[n] = 0;
	43
	44	r = bus_gvariant_get_alignment(t);
	45	if (r < 0)
	46	return r;
	47
	48	sum = ALIGN_TO(sum, r);
	49	}
	50
	51	switch (*p) {
	52
	53	case SD_BUS_TYPE_BOOLEAN:
	54	case SD_BUS_TYPE_BYTE:
	55	sum += 1;
	56	break;
	57
	58	case SD_BUS_TYPE_INT16:
	59	case SD_BUS_TYPE_UINT16:
	60	sum += 2;
	61	break;
	62
	63	case SD_BUS_TYPE_INT32:
	64	case SD_BUS_TYPE_UINT32:
	65	case SD_BUS_TYPE_UNIX_FD:
	66	sum += 4;
	67	break;
	68
	69	case SD_BUS_TYPE_INT64:
	70	case SD_BUS_TYPE_UINT64:
	71	case SD_BUS_TYPE_DOUBLE:
	72	sum += 8;
	73	break;
	74
	75	case SD_BUS_TYPE_STRUCT_BEGIN:
	76	case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
	77	if (n == 2) {
	78	/* unary type () has fixed size of 1 */
	79	r = 1;
	80	} else {
	81	char t[n-1];
	82
	83	memcpy(t, p + 1, n - 2);
	84	t[n - 2] = 0;
	85
	86	r = bus_gvariant_get_size(t);
	87	if (r < 0)
	88	return r;
	89	}
	90
	91	sum += r;
	92	break;
	93	}
	94
	95	case SD_BUS_TYPE_STRING:
	96	case SD_BUS_TYPE_OBJECT_PATH:
	97	case SD_BUS_TYPE_SIGNATURE:
	98	case SD_BUS_TYPE_ARRAY:
	99	case SD_BUS_TYPE_VARIANT:
	100	return -EINVAL;
	101
	102	default:
	103	assert_not_reached("Unknown signature type");
	104	}
	105
	106	p += n;
	107	}
	108
	109	r = bus_gvariant_get_alignment(signature);
	110	if (r < 0)
	111	return r;
	112
	113	return ALIGN_TO(sum, r);
	114	}
	115
	116	int bus_gvariant_get_alignment(const char *signature) {
	117	size_t alignment = 1;
	118	const char *p;
	119	int r;
	120
	121	p = signature;
	122	while (*p != 0 && alignment < 8) {
	123	size_t n;
	124	int a;
	125
	126	r = signature_element_length(p, &n);
	127	if (r < 0)
	128	return r;
	129
	130	switch (*p) {
	131
	132	case SD_BUS_TYPE_BYTE:
	133	case SD_BUS_TYPE_BOOLEAN:
	134	case SD_BUS_TYPE_STRING:
	135	case SD_BUS_TYPE_OBJECT_PATH:
	136	case SD_BUS_TYPE_SIGNATURE:
	137	a = 1;
	138	break;
	139
	140	case SD_BUS_TYPE_INT16:
	141	case SD_BUS_TYPE_UINT16:
	142	a = 2;
	143	break;
	144
	145	case SD_BUS_TYPE_INT32:
	146	case SD_BUS_TYPE_UINT32:
	147	case SD_BUS_TYPE_UNIX_FD:
	148	a = 4;
	149	break;
	150
	151	case SD_BUS_TYPE_INT64:
	152	case SD_BUS_TYPE_UINT64:
	153	case SD_BUS_TYPE_DOUBLE:
	154	case SD_BUS_TYPE_VARIANT:
	155	a = 8;
	156	break;
	157
	158	case SD_BUS_TYPE_ARRAY: {
	159	char t[n];
	160
	161	memcpy(t, p + 1, n - 1);
	162	t[n - 1] = 0;
	163
	164	a = bus_gvariant_get_alignment(t);
	165	break;
	166	}
	167
	168	case SD_BUS_TYPE_STRUCT_BEGIN:
	169	case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
	170	char t[n-1];
	171
	172	memcpy(t, p + 1, n - 2);
	173	t[n - 2] = 0;
	174
	175	a = bus_gvariant_get_alignment(t);
	176	break;
	177	}
	178
	179	default:
	180	assert_not_reached("Unknown signature type");
	181	}
	182
	183	if (a < 0)
	184	return a;
	185
	186	assert(a > 0 && a <= 8);
	187	if ((size_t) a > alignment)
	188	alignment = (size_t) a;
	189
	190	p += n;
	191	}
	192
	193	return alignment;
	194	}
	195
	196	int bus_gvariant_is_fixed_size(const char *signature) {
	197	const char *p;
	198	int r;
	199
	200	assert(signature);
	201
	202	p = signature;
	203	while (*p != 0) {
	204	size_t n;
	205
	206	r = signature_element_length(p, &n);
	207	if (r < 0)
	208	return r;
	209
	210	switch (*p) {
	211
	212	case SD_BUS_TYPE_STRING:
	213	case SD_BUS_TYPE_OBJECT_PATH:
	214	case SD_BUS_TYPE_SIGNATURE:
	215	case SD_BUS_TYPE_ARRAY:
	216	case SD_BUS_TYPE_VARIANT:
	217	return 0;
	218
	219	case SD_BUS_TYPE_BYTE:
	220	case SD_BUS_TYPE_BOOLEAN:
	221	case SD_BUS_TYPE_INT16:
	222	case SD_BUS_TYPE_UINT16:
	223	case SD_BUS_TYPE_INT32:
	224	case SD_BUS_TYPE_UINT32:
	225	case SD_BUS_TYPE_UNIX_FD:
	226	case SD_BUS_TYPE_INT64:
	227	case SD_BUS_TYPE_UINT64:
	228	case SD_BUS_TYPE_DOUBLE:
	229	break;
	230
	231	case SD_BUS_TYPE_STRUCT_BEGIN:
	232	case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
	233	char t[n-1];
	234
	235	memcpy(t, p + 1, n - 2);
	236	t[n - 2] = 0;
	237
	238	r = bus_gvariant_is_fixed_size(t);
	239	if (r <= 0)
	240	return r;
	241	break;
	242	}
	243
	244	default:
	245	assert_not_reached("Unknown signature type");
	246	}
	247
	248	p += n;
	249	}
	250
	251	return true;
	252	}
	253
	254	size_t bus_gvariant_determine_word_size(size_t sz, size_t extra) {
	255	if (sz + extra <= 0xFF)
	256	return 1;
	257	else if (sz + extra*2 <= 0xFFFF)
	258	return 2;
	259	else if (sz + extra*4 <= 0xFFFFFFFF)
	260	return 4;
	261	else
	262	return 8;
	263	}
	264
	265	size_t bus_gvariant_read_word_le(void *p, size_t sz) {
	266	union {
	267	uint16_t u16;
	268	uint32_t u32;
	269	uint64_t u64;
	270	} x;
	271
	272	assert(p);
	273
	274	if (sz == 1)
	275	return (uint8_t) p;
	276
	277	memcpy(&x, p, sz);
	278
	279	if (sz == 2)
	280	return le16toh(x.u16);
	281	else if (sz == 4)
	282	return le32toh(x.u32);
	283	else if (sz == 8)
	284	return le64toh(x.u64);
	285
	286	assert_not_reached("unknown word width");
	287	}
	288
	289	void bus_gvariant_write_word_le(void *p, size_t sz, size_t value) {
	290	union {
	291	uint16_t u16;
	292	uint32_t u32;
	293	uint64_t u64;
	294	} x;
	295
	296	assert(p);
	297	assert(sz == 8 \|\| (value < (1ULL << (sz*8))));
	298
	299	if (sz == 1) {
	300	(uint8_t) p = value;
	301	return;
	302	} else if (sz == 2)
	303	x.u16 = htole16((uint16_t) value);
	304	else if (sz == 4)
	305	x.u32 = htole32((uint32_t) value);
	306	else if (sz == 8)
	307	x.u64 = htole64((uint64_t) value);
	308	else
	309	assert_not_reached("unknown word width");
	310
	311	memcpy(p, &x, sz);
	312	}