[deliverable/lttng-ust.git] / libmsgpack / msgpack.c

/*
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com>
 */

#define _GNU_SOURCE
#define _LGPL_SOURCE
#include <stddef.h>

#define MSGPACK_FIXSTR_ID_MASK		0xA0
#define MSGPACK_FIXMAP_ID_MASK		0x80
#define MSGPACK_FIXARRAY_ID_MASK	0x90

#define MSGPACK_NIL_ID		0xC0
#define MSGPACK_FALSE_ID	0xC2
#define MSGPACK_TRUE_ID		0xC3
#define MSGPACK_MAP16_ID	0xDE
#define MSGPACK_ARRAY16_ID	0xDC

#define MSGPACK_UINT8_ID	0xCC
#define MSGPACK_UINT16_ID	0xCD
#define MSGPACK_UINT32_ID	0xCE
#define MSGPACK_UINT64_ID	0xCF

#define MSGPACK_INT8_ID		0xD0
#define MSGPACK_INT16_ID	0xD1
#define MSGPACK_INT32_ID	0xD2
#define MSGPACK_INT64_ID	0xD3

#define MSGPACK_FLOAT64_ID	0xCB
#define MSGPACK_STR16_ID	0xDA

#define MSGPACK_FIXINT_MAX		((1 << 7) - 1)
#define MSGPACK_FIXINT_MIN		-(1 << 5)
#define MSGPACK_FIXMAP_MAX_COUNT	15
#define MSGPACK_FIXARRAY_MAX_COUNT	15
#define MSGPACK_FIXSTR_MAX_LENGTH	31

#ifdef __KERNEL__
#include <linux/bug.h>
#include <linux/string.h>
#include <linux/types.h>

#include <lttng/msgpack.h>

#define INT8_MIN		(-128)
#define INT16_MIN		(-32767-1)
#define INT32_MIN		(-2147483647-1)
#define INT8_MAX		(127)
#define INT16_MAX		(32767)
#define INT32_MAX		(2147483647)
#define UINT8_MAX		(255)
#define UINT16_MAX		(65535)
#define UINT32_MAX		(4294967295U)

#define byteswap_host_to_be16(_tmp) cpu_to_be16(_tmp)
#define byteswap_host_to_be32(_tmp) cpu_to_be32(_tmp)
#define byteswap_host_to_be64(_tmp) cpu_to_be64(_tmp)

#define lttng_msgpack_assert(cond) WARN_ON(!(cond))

#else /* __KERNEL__ */

#include <lttng/ust-endian.h>
#include <stdio.h>
#include <string.h>

#include "msgpack.h"

#define byteswap_host_to_be16(_tmp) htobe16(_tmp)
#define byteswap_host_to_be32(_tmp) htobe32(_tmp)
#define byteswap_host_to_be64(_tmp) htobe64(_tmp)

#define lttng_msgpack_assert(cond) ({ \
	if (!(cond)) \
		fprintf(stderr, "Assertion failed. %s:%d\n", __FILE__, __LINE__); \
	})
#endif /* __KERNEL__ */

static inline int lttng_msgpack_append_buffer(
		struct lttng_msgpack_writer *writer,
		const uint8_t *buf,
		size_t length)
{
	int ret = 0;

	lttng_msgpack_assert(buf);

	/* Ensure we are not trying to write after the end of the buffer. */
	if (writer->write_pos + length > writer->end_write_pos) {
		ret = -1;
		goto end;
	}

	memcpy(writer->write_pos, buf, length);
	writer->write_pos += length;
end:
	return ret;
}

static inline int lttng_msgpack_append_u8(
		struct lttng_msgpack_writer *writer, uint8_t value)
{
	return lttng_msgpack_append_buffer(writer, &value, sizeof(value));
}

static inline int lttng_msgpack_append_u16(
		struct lttng_msgpack_writer *writer, uint16_t value)
{
	value = byteswap_host_to_be16(value);

	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
}

static inline int lttng_msgpack_append_u32(
		struct lttng_msgpack_writer *writer, uint32_t value)
{
	value = byteswap_host_to_be32(value);

	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
}

static inline int lttng_msgpack_append_u64(
		struct lttng_msgpack_writer *writer, uint64_t value)
{
	value = byteswap_host_to_be64(value);

	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
}

static inline int lttng_msgpack_append_f64(
		struct lttng_msgpack_writer *writer, double value)
{

	union {
		double d;
		uint64_t u;
	} u;

	u.d = value;

	return lttng_msgpack_append_u64(writer, u.u);
}

static inline int lttng_msgpack_append_i8(
		struct lttng_msgpack_writer *writer, int8_t value)
{
	return lttng_msgpack_append_u8(writer, (uint8_t) value);
}

static inline int lttng_msgpack_append_i16(
		struct lttng_msgpack_writer *writer, int16_t value)
{
	return lttng_msgpack_append_u16(writer, (uint16_t) value);
}

static inline int lttng_msgpack_append_i32(
		struct lttng_msgpack_writer *writer, int32_t value)
{
	return lttng_msgpack_append_u32(writer, (uint32_t) value);
}

static inline int lttng_msgpack_append_i64(
		struct lttng_msgpack_writer *writer, int64_t value)
{
	return lttng_msgpack_append_u64(writer, (uint64_t) value);
}

static inline int lttng_msgpack_encode_f64(
		struct lttng_msgpack_writer *writer, double value)
{
	int ret;

	ret = lttng_msgpack_append_u8(writer, MSGPACK_FLOAT64_ID);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_f64(writer, value);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_fixmap(
		struct lttng_msgpack_writer *writer, uint8_t count)
{
	int ret = 0;

	lttng_msgpack_assert(count <= MSGPACK_FIXMAP_MAX_COUNT);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXMAP_ID_MASK | count);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_map16(
		struct lttng_msgpack_writer *writer, uint16_t count)
{
	int ret;

	lttng_msgpack_assert(count > MSGPACK_FIXMAP_MAX_COUNT);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_MAP16_ID);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_u16(writer, count);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_fixarray(
		struct lttng_msgpack_writer *writer, uint8_t count)
{
	int ret = 0;

	lttng_msgpack_assert(count <= MSGPACK_FIXARRAY_MAX_COUNT);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXARRAY_ID_MASK | count);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_array16(
		struct lttng_msgpack_writer *writer, uint16_t count)
{
	int ret;

	lttng_msgpack_assert(count > MSGPACK_FIXARRAY_MAX_COUNT);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_ARRAY16_ID);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_u16(writer, count);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_fixstr(
		struct lttng_msgpack_writer *writer,
		const char *str,
		uint8_t len)
{
	int ret;

	lttng_msgpack_assert(len <= MSGPACK_FIXSTR_MAX_LENGTH);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXSTR_ID_MASK | len);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_buffer(writer, (uint8_t *) str, len);
	if (ret)
		goto end;

end:
	return ret;
}

static inline int lttng_msgpack_encode_str16(
		struct lttng_msgpack_writer *writer,
		const char *str,
		uint16_t len)
{
	int ret;

	lttng_msgpack_assert(len > MSGPACK_FIXSTR_MAX_LENGTH);

	ret = lttng_msgpack_append_u8(writer, MSGPACK_STR16_ID);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_u16(writer, len);
	if (ret)
		goto end;

	ret = lttng_msgpack_append_buffer(writer, (uint8_t *) str, len);
	if (ret)
		goto end;

end:
	return ret;
}

int lttng_msgpack_begin_map(struct lttng_msgpack_writer *writer, size_t count)
{
	int ret;

	if (count >= (1 << 16)) {
		ret = -1;
		goto end;
	}

	if (count <= MSGPACK_FIXMAP_MAX_COUNT)
		ret = lttng_msgpack_encode_fixmap(writer, count);
	else
		ret = lttng_msgpack_encode_map16(writer, count);

	writer->map_nesting++;
end:
	return ret;
}

int lttng_msgpack_end_map(struct lttng_msgpack_writer *writer)
{
	lttng_msgpack_assert(writer->map_nesting > 0);
	writer->map_nesting--;
	return 0;
}

int lttng_msgpack_begin_array(
		struct lttng_msgpack_writer *writer, size_t count)
{
	int ret;

	if (count >= (1 << 16)) {
		ret = -1;
		goto end;
	}

	if (count <= MSGPACK_FIXARRAY_MAX_COUNT)
		ret = lttng_msgpack_encode_fixarray(writer, count);
	else
		ret = lttng_msgpack_encode_array16(writer, count);

	writer->array_nesting++;
end:
	return ret;
}

int lttng_msgpack_end_array(struct lttng_msgpack_writer *writer)
{
	lttng_msgpack_assert(writer->array_nesting > 0);
	writer->array_nesting--;
	return 0;
}

int lttng_msgpack_write_str(struct lttng_msgpack_writer *writer,
		const char *str)
{
	int ret;
	size_t length = strlen(str);

	if (length >= (1 << 16)) {
		ret = -1;
		goto end;
	}

	if (length <= MSGPACK_FIXSTR_MAX_LENGTH)
		ret = lttng_msgpack_encode_fixstr(writer, str, length);
	else
		ret = lttng_msgpack_encode_str16(writer, str, length);

end:
	return ret;
}

int lttng_msgpack_write_nil(struct lttng_msgpack_writer *writer)
{
	return lttng_msgpack_append_u8(writer, MSGPACK_NIL_ID);
}

int lttng_msgpack_write_true(struct lttng_msgpack_writer *writer)
{
	return lttng_msgpack_append_u8(writer, MSGPACK_TRUE_ID);
}

int lttng_msgpack_write_false(struct lttng_msgpack_writer *writer)
{
	return lttng_msgpack_append_u8(writer, MSGPACK_FALSE_ID);
}

int lttng_msgpack_write_unsigned_integer(
		struct lttng_msgpack_writer *writer, uint64_t value)
{
	int ret = 0;

	if (value <= MSGPACK_FIXINT_MAX) {
		ret = lttng_msgpack_append_u8(writer, (uint8_t) value);
		if (ret)
			goto end;
	} else if (value <= UINT8_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT8_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_u8(writer, (uint8_t) value);
		if (ret)
			goto end;
	} else if (value <= UINT16_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT16_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_u16(writer, (uint16_t) value);
		if (ret)
			goto end;
	} else if (value <= UINT32_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT32_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_u32(writer, (uint32_t) value);
		if (ret)
			goto end;
	} else {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT64_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_u64(writer, value);
		if (ret)
			goto end;
	}

end:
	return ret;
}

int lttng_msgpack_write_signed_integer(struct lttng_msgpack_writer *writer, int64_t value)
{
	int ret;

	if (value >= MSGPACK_FIXINT_MIN && value <= MSGPACK_FIXINT_MAX){
		ret = lttng_msgpack_append_i8(writer, (int8_t) value);
		if (ret)
			goto end;
	} else if (value >= INT8_MIN && value <= INT8_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_INT8_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_i8(writer, (int8_t) value);
		if (ret)
			goto end;
	} else if (value >= INT16_MIN && value <= INT16_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_INT16_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_i16(writer, (int16_t) value);
		if (ret)
			goto end;
	} else if (value >= INT32_MIN && value <= INT32_MAX) {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_INT32_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_i32(writer, (int32_t) value);
		if (ret)
			goto end;
	} else {
		ret = lttng_msgpack_append_u8(writer, MSGPACK_INT64_ID);
		if (ret)
			goto end;

		ret = lttng_msgpack_append_i64(writer, value);
		if (ret)
			goto end;
	}

end:
	return ret;
}

int lttng_msgpack_write_double(struct lttng_msgpack_writer *writer, double value)
{
	return lttng_msgpack_encode_f64(writer, value);
}

void lttng_msgpack_writer_init(struct lttng_msgpack_writer *writer,
		uint8_t *buffer, size_t size)
{
	lttng_msgpack_assert(buffer);
	lttng_msgpack_assert(size >= 0);

	writer->buffer = buffer;
	writer->write_pos = buffer;
	writer->end_write_pos = buffer + size;

	writer->array_nesting = 0;
	writer->map_nesting = 0;
}

void lttng_msgpack_writer_fini(struct lttng_msgpack_writer *writer)
{
	memset(writer, 0, sizeof(*writer));
}
Commit	Line	Data
49705576	1	/*
c0c0989a	2	* SPDX-License-Identifier: LGPL-2.1-only
49705576 FD	3	*
49705576 FD	4	* Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com>
49705576 FD	5	*/
	6
	7	#define _GNU_SOURCE
	8	#define _LGPL_SOURCE
	9	#include <stddef.h>
	10
	11	#define MSGPACK_FIXSTR_ID_MASK 0xA0
	12	#define MSGPACK_FIXMAP_ID_MASK 0x80
	13	#define MSGPACK_FIXARRAY_ID_MASK 0x90
	14
	15	#define MSGPACK_NIL_ID 0xC0
	16	#define MSGPACK_FALSE_ID 0xC2
	17	#define MSGPACK_TRUE_ID 0xC3
	18	#define MSGPACK_MAP16_ID 0xDE
	19	#define MSGPACK_ARRAY16_ID 0xDC
	20
	21	#define MSGPACK_UINT8_ID 0xCC
	22	#define MSGPACK_UINT16_ID 0xCD
	23	#define MSGPACK_UINT32_ID 0xCE
	24	#define MSGPACK_UINT64_ID 0xCF
	25
	26	#define MSGPACK_INT8_ID 0xD0
	27	#define MSGPACK_INT16_ID 0xD1
	28	#define MSGPACK_INT32_ID 0xD2
	29	#define MSGPACK_INT64_ID 0xD3
	30
	31	#define MSGPACK_FLOAT64_ID 0xCB
	32	#define MSGPACK_STR16_ID 0xDA
	33
	34	#define MSGPACK_FIXINT_MAX ((1 << 7) - 1)
	35	#define MSGPACK_FIXINT_MIN -(1 << 5)
	36	#define MSGPACK_FIXMAP_MAX_COUNT 15
	37	#define MSGPACK_FIXARRAY_MAX_COUNT 15
	38	#define MSGPACK_FIXSTR_MAX_LENGTH 31
	39
	40	#ifdef __KERNEL__
	41	#include <linux/bug.h>
	42	#include <linux/string.h>
	43	#include <linux/types.h>
	44
	45	#include <lttng/msgpack.h>
	46
	47	#define INT8_MIN (-128)
	48	#define INT16_MIN (-32767-1)
	49	#define INT32_MIN (-2147483647-1)
	50	#define INT8_MAX (127)
	51	#define INT16_MAX (32767)
	52	#define INT32_MAX (2147483647)
	53	#define UINT8_MAX (255)
	54	#define UINT16_MAX (65535)
	55	#define UINT32_MAX (4294967295U)
	56
	57	#define byteswap_host_to_be16(_tmp) cpu_to_be16(_tmp)
	58	#define byteswap_host_to_be32(_tmp) cpu_to_be32(_tmp)
	59	#define byteswap_host_to_be64(_tmp) cpu_to_be64(_tmp)
	60
	61	#define lttng_msgpack_assert(cond) WARN_ON(!(cond))
	62
	63	#else /* __KERNEL__ */
	64
f03092d7	65	#include <lttng/ust-endian.h>
49705576 FD	66	#include <stdio.h>
	67	#include <string.h>
	68
	69	#include "msgpack.h"
	70
	71	#define byteswap_host_to_be16(_tmp) htobe16(_tmp)
	72	#define byteswap_host_to_be32(_tmp) htobe32(_tmp)
	73	#define byteswap_host_to_be64(_tmp) htobe64(_tmp)
	74
	75	#define lttng_msgpack_assert(cond) ({ \
	76	if (!(cond)) \
	77	fprintf(stderr, "Assertion failed. %s:%d\n", __FILE__, __LINE__); \
	78	})
	79	#endif /* __KERNEL__ */
	80
	81	static inline int lttng_msgpack_append_buffer(
	82	struct lttng_msgpack_writer *writer,
	83	const uint8_t *buf,
	84	size_t length)
	85	{
	86	int ret = 0;
	87
	88	lttng_msgpack_assert(buf);
	89
	90	/* Ensure we are not trying to write after the end of the buffer. */
	91	if (writer->write_pos + length > writer->end_write_pos) {
	92	ret = -1;
	93	goto end;
	94	}
	95
	96	memcpy(writer->write_pos, buf, length);
	97	writer->write_pos += length;
	98	end:
	99	return ret;
	100	}
	101
	102	static inline int lttng_msgpack_append_u8(
	103	struct lttng_msgpack_writer *writer, uint8_t value)
	104	{
	105	return lttng_msgpack_append_buffer(writer, &value, sizeof(value));
	106	}
	107
	108	static inline int lttng_msgpack_append_u16(
	109	struct lttng_msgpack_writer *writer, uint16_t value)
	110	{
	111	value = byteswap_host_to_be16(value);
	112
	113	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
	114	}
	115
	116	static inline int lttng_msgpack_append_u32(
	117	struct lttng_msgpack_writer *writer, uint32_t value)
	118	{
	119	value = byteswap_host_to_be32(value);
	120
	121	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
	122	}
	123
	124	static inline int lttng_msgpack_append_u64(
	125	struct lttng_msgpack_writer *writer, uint64_t value)
	126	{
	127	value = byteswap_host_to_be64(value);
	128
	129	return lttng_msgpack_append_buffer(writer, (uint8_t *) &value, sizeof(value));
130	}
131
132	static inline int lttng_msgpack_append_f64(
133	struct lttng_msgpack_writer *writer, double value)
134	{
135
136	union {
137	double d;
138	uint64_t u;
139	} u;
140
141	u.d = value;
142
143	return lttng_msgpack_append_u64(writer, u.u);
144	}
145
146	static inline int lttng_msgpack_append_i8(
147	struct lttng_msgpack_writer *writer, int8_t value)
148	{
149	return lttng_msgpack_append_u8(writer, (uint8_t) value);
150	}
151
152	static inline int lttng_msgpack_append_i16(
153	struct lttng_msgpack_writer *writer, int16_t value)
154	{
155	return lttng_msgpack_append_u16(writer, (uint16_t) value);
156	}
157
158	static inline int lttng_msgpack_append_i32(
159	struct lttng_msgpack_writer *writer, int32_t value)
160	{
161	return lttng_msgpack_append_u32(writer, (uint32_t) value);
162	}
163
164	static inline int lttng_msgpack_append_i64(
165	struct lttng_msgpack_writer *writer, int64_t value)
166	{
167	return lttng_msgpack_append_u64(writer, (uint64_t) value);
168	}
169
170	static inline int lttng_msgpack_encode_f64(
171	struct lttng_msgpack_writer *writer, double value)
172	{
173	int ret;
174
175	ret = lttng_msgpack_append_u8(writer, MSGPACK_FLOAT64_ID);
176	if (ret)
177	goto end;
178
179	ret = lttng_msgpack_append_f64(writer, value);
180	if (ret)
181	goto end;
182
183	end:
184	return ret;
185	}
186
187	static inline int lttng_msgpack_encode_fixmap(
188	struct lttng_msgpack_writer *writer, uint8_t count)
189	{
190	int ret = 0;
191
192	lttng_msgpack_assert(count <= MSGPACK_FIXMAP_MAX_COUNT);
193
194	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXMAP_ID_MASK \| count);
195	if (ret)
196	goto end;
197
198	end:
199	return ret;
200	}
201
202	static inline int lttng_msgpack_encode_map16(
203	struct lttng_msgpack_writer *writer, uint16_t count)
204	{
205	int ret;
206
207	lttng_msgpack_assert(count > MSGPACK_FIXMAP_MAX_COUNT);
208
209	ret = lttng_msgpack_append_u8(writer, MSGPACK_MAP16_ID);
210	if (ret)
211	goto end;
212
213	ret = lttng_msgpack_append_u16(writer, count);
214	if (ret)
215	goto end;
216
217	end:
218	return ret;
219	}
220
221	static inline int lttng_msgpack_encode_fixarray(
222	struct lttng_msgpack_writer *writer, uint8_t count)
223	{
224	int ret = 0;
225
226	lttng_msgpack_assert(count <= MSGPACK_FIXARRAY_MAX_COUNT);
227
228	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXARRAY_ID_MASK \| count);
229	if (ret)
230	goto end;
231
232	end:
233	return ret;
234	}
235
236	static inline int lttng_msgpack_encode_array16(
237	struct lttng_msgpack_writer *writer, uint16_t count)
238	{
239	int ret;
240
241	lttng_msgpack_assert(count > MSGPACK_FIXARRAY_MAX_COUNT);
242
243	ret = lttng_msgpack_append_u8(writer, MSGPACK_ARRAY16_ID);
244	if (ret)
245	goto end;
246
247	ret = lttng_msgpack_append_u16(writer, count);
248	if (ret)
249	goto end;
250
251	end:
252	return ret;
253	}
254
255	static inline int lttng_msgpack_encode_fixstr(
256	struct lttng_msgpack_writer *writer,
257	const char *str,
258	uint8_t len)
259	{
260	int ret;
261
262	lttng_msgpack_assert(len <= MSGPACK_FIXSTR_MAX_LENGTH);
263
264	ret = lttng_msgpack_append_u8(writer, MSGPACK_FIXSTR_ID_MASK \| len);
265	if (ret)
266	goto end;
267
268	ret = lttng_msgpack_append_buffer(writer, (uint8_t *) str, len);
269	if (ret)
270	goto end;
271
272	end:
273	return ret;
274	}
275
276	static inline int lttng_msgpack_encode_str16(
277	struct lttng_msgpack_writer *writer,
278	const char *str,
279	uint16_t len)
280	{
281	int ret;
282
283	lttng_msgpack_assert(len > MSGPACK_FIXSTR_MAX_LENGTH);
284
285	ret = lttng_msgpack_append_u8(writer, MSGPACK_STR16_ID);
286	if (ret)
287	goto end;
288
289	ret = lttng_msgpack_append_u16(writer, len);
290	if (ret)
291	goto end;
292
293	ret = lttng_msgpack_append_buffer(writer, (uint8_t *) str, len);
294	if (ret)
295	goto end;
296
297	end:
298	return ret;
299	}
300
301	int lttng_msgpack_begin_map(struct lttng_msgpack_writer *writer, size_t count)
302	{
303	int ret;
304
8b914423	305	if (count >= (1 << 16)) {
49705576 FD	306	ret = -1;
	307	goto end;
	308	}
	309
	310	if (count <= MSGPACK_FIXMAP_MAX_COUNT)
	311	ret = lttng_msgpack_encode_fixmap(writer, count);
	312	else
	313	ret = lttng_msgpack_encode_map16(writer, count);
	314
	315	writer->map_nesting++;
	316	end:
	317	return ret;
	318	}
	319
	320	int lttng_msgpack_end_map(struct lttng_msgpack_writer *writer)
	321	{
	322	lttng_msgpack_assert(writer->map_nesting > 0);
	323	writer->map_nesting--;
	324	return 0;
	325	}
	326
	327	int lttng_msgpack_begin_array(
	328	struct lttng_msgpack_writer *writer, size_t count)
	329	{
	330	int ret;
	331
8b914423	332	if (count >= (1 << 16)) {
49705576 FD	333	ret = -1;
	334	goto end;
	335	}
	336
	337	if (count <= MSGPACK_FIXARRAY_MAX_COUNT)
	338	ret = lttng_msgpack_encode_fixarray(writer, count);
	339	else
	340	ret = lttng_msgpack_encode_array16(writer, count);
	341
	342	writer->array_nesting++;
	343	end:
	344	return ret;
	345	}
	346
	347	int lttng_msgpack_end_array(struct lttng_msgpack_writer *writer)
	348	{
	349	lttng_msgpack_assert(writer->array_nesting > 0);
	350	writer->array_nesting--;
	351	return 0;
	352	}
	353
	354	int lttng_msgpack_write_str(struct lttng_msgpack_writer *writer,
	355	const char *str)
	356	{
	357	int ret;
	358	size_t length = strlen(str);
8b914423 MD	359
8b914423 MD	360	if (length >= (1 << 16)) {
49705576 FD	361	ret = -1;
	362	goto end;
	363	}
	364
	365	if (length <= MSGPACK_FIXSTR_MAX_LENGTH)
	366	ret = lttng_msgpack_encode_fixstr(writer, str, length);
	367	else
	368	ret = lttng_msgpack_encode_str16(writer, str, length);
	369
	370	end:
	371	return ret;
	372	}
	373
	374	int lttng_msgpack_write_nil(struct lttng_msgpack_writer *writer)
	375	{
	376	return lttng_msgpack_append_u8(writer, MSGPACK_NIL_ID);
	377	}
	378
	379	int lttng_msgpack_write_true(struct lttng_msgpack_writer *writer)
	380	{
	381	return lttng_msgpack_append_u8(writer, MSGPACK_TRUE_ID);
	382	}
	383
	384	int lttng_msgpack_write_false(struct lttng_msgpack_writer *writer)
	385	{
	386	return lttng_msgpack_append_u8(writer, MSGPACK_FALSE_ID);
	387	}
	388
	389	int lttng_msgpack_write_unsigned_integer(
	390	struct lttng_msgpack_writer *writer, uint64_t value)
	391	{
	392	int ret = 0;
	393
	394	if (value <= MSGPACK_FIXINT_MAX) {
	395	ret = lttng_msgpack_append_u8(writer, (uint8_t) value);
	396	if (ret)
	397	goto end;
	398	} else if (value <= UINT8_MAX) {
	399	ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT8_ID);
	400	if (ret)
	401	goto end;
	402
	403	ret = lttng_msgpack_append_u8(writer, (uint8_t) value);
	404	if (ret)
	405	goto end;
	406	} else if (value <= UINT16_MAX) {
	407	ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT16_ID);
	408	if (ret)
	409	goto end;
	410
	411	ret = lttng_msgpack_append_u16(writer, (uint16_t) value);
	412	if (ret)
	413	goto end;
	414	} else if (value <= UINT32_MAX) {
	415	ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT32_ID);
	416	if (ret)
	417	goto end;
	418
	419	ret = lttng_msgpack_append_u32(writer, (uint32_t) value);
	420	if (ret)
	421	goto end;
	422	} else {
	423	ret = lttng_msgpack_append_u8(writer, MSGPACK_UINT64_ID);
	424	if (ret)
425	goto end;
426
427	ret = lttng_msgpack_append_u64(writer, value);
428	if (ret)
429	goto end;
430	}
431
432	end:
433	return ret;
434	}
435
436	int lttng_msgpack_write_signed_integer(struct lttng_msgpack_writer *writer, int64_t value)
437	{
438	int ret;
439
440	if (value >= MSGPACK_FIXINT_MIN && value <= MSGPACK_FIXINT_MAX){
441	ret = lttng_msgpack_append_i8(writer, (int8_t) value);
442	if (ret)
443	goto end;
444	} else if (value >= INT8_MIN && value <= INT8_MAX) {
445	ret = lttng_msgpack_append_u8(writer, MSGPACK_INT8_ID);
446	if (ret)
447	goto end;
448
449	ret = lttng_msgpack_append_i8(writer, (int8_t) value);
450	if (ret)
451	goto end;
452	} else if (value >= INT16_MIN && value <= INT16_MAX) {
453	ret = lttng_msgpack_append_u8(writer, MSGPACK_INT16_ID);
454	if (ret)
455	goto end;
456
457	ret = lttng_msgpack_append_i16(writer, (int16_t) value);
458	if (ret)
459	goto end;
460	} else if (value >= INT32_MIN && value <= INT32_MAX) {
461	ret = lttng_msgpack_append_u8(writer, MSGPACK_INT32_ID);
462	if (ret)
463	goto end;
464
465	ret = lttng_msgpack_append_i32(writer, (int32_t) value);
466	if (ret)
467	goto end;
468	} else {
469	ret = lttng_msgpack_append_u8(writer, MSGPACK_INT64_ID);
470	if (ret)
471	goto end;
472
473	ret = lttng_msgpack_append_i64(writer, value);
474	if (ret)
475	goto end;
476	}
477
478	end:
479	return ret;
480	}
481
482	int lttng_msgpack_write_double(struct lttng_msgpack_writer *writer, double value)
483	{
484	return lttng_msgpack_encode_f64(writer, value);
485	}
486
487	void lttng_msgpack_writer_init(struct lttng_msgpack_writer *writer,
488	uint8_t *buffer, size_t size)
489	{
490	lttng_msgpack_assert(buffer);
491	lttng_msgpack_assert(size >= 0);
492
493	writer->buffer = buffer;
494	writer->write_pos = buffer;
495	writer->end_write_pos = buffer + size;
496
497	writer->array_nesting = 0;
498	writer->map_nesting = 0;
499	}
500
501	void lttng_msgpack_writer_fini(struct lttng_msgpack_writer *writer)
502	{
503	memset(writer, 0, sizeof(*writer));
504	}