[lttng-tools.git] / src / common / tracker.c

/*
 * Copyright (C) 2019 - Jonathan Rajotte-Julien <jonathan.rajotte-julien@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library 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 this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <assert.h>
#include <common/defaults.h>
#include <common/error.h>
#include <common/macros.h>
#include <common/sessiond-comm/sessiond-comm.h>
#include <common/uri.h>
#include <lttng/tracker-internal.h>
#include <stdio.h>
#include <time.h>

struct lttng_tracker_id *lttng_tracker_id_create(void)
{
	struct lttng_tracker_id *id;

	id = zmalloc(sizeof(*id));
	if (!id) {
		goto error;
	}

	id->type = LTTNG_ID_UNKNOWN;
	id->string = NULL;
	id->value = -1;
	return id;
error:
	lttng_tracker_id_destroy(id);
	return NULL;
}

enum lttng_tracker_id_status lttng_tracker_id_set_value(
		struct lttng_tracker_id *id, int value)
{
	assert(id);

	if (value < 0) {
		return LTTNG_TRACKER_ID_STATUS_INVALID;
	}

	id->type = LTTNG_ID_VALUE;
	id->value = value;
	return LTTNG_TRACKER_ID_STATUS_OK;
}

enum lttng_tracker_id_status lttng_tracker_id_set_string(
		struct lttng_tracker_id *id, const char *value)
{
	assert(id);
	assert(value);

	id->type = LTTNG_ID_STRING;
	id->string = strdup(value);
	if (id->string == NULL) {
		/* No memory left */
		goto error;
	}

	return LTTNG_TRACKER_ID_STATUS_OK;
error:
	return LTTNG_TRACKER_ID_STATUS_INVALID;
}

enum lttng_tracker_id_status lttng_tracker_id_set_all(
		struct lttng_tracker_id *id)
{
	assert(id);

	id->type = LTTNG_ID_ALL;

	return LTTNG_TRACKER_ID_STATUS_OK;
}

static void lttng_tracker_id_reset(struct lttng_tracker_id *id)
{
	if (id == NULL) {
		return;
	}

	if (id->string != NULL) {
		free(id->string);
		id->string = NULL;
	}

	id->type = LTTNG_ID_UNKNOWN;
	id->value = -1;
}

void lttng_tracker_id_destroy(struct lttng_tracker_id *id)
{
	if (id == NULL) {
		return;
	}

	lttng_tracker_id_reset(id);

	free(id);
}

enum lttng_tracker_id_type lttng_tracker_id_get_type(
		const struct lttng_tracker_id *id)
{
	assert(id);
	return id->type;
}

enum lttng_tracker_id_status lttng_tracker_id_get_value(
		const struct lttng_tracker_id *id, int *value)
{
	assert(id);
	if (id->type == LTTNG_ID_UNKNOWN) {
		return LTTNG_TRACKER_ID_STATUS_UNSET;
	}

	if (id->type != LTTNG_ID_VALUE) {
		return LTTNG_TRACKER_ID_STATUS_INVALID;
	}

	*value = id->value;
	return LTTNG_TRACKER_ID_STATUS_OK;
}

bool lttng_tracker_id_is_equal(const struct lttng_tracker_id *left,
		const struct lttng_tracker_id *right)
{
	if (left->type != right->type) {
		return 0;
	}

	switch (left->type) {
	case LTTNG_ID_ALL:
		return 1;
	case LTTNG_ID_VALUE:
		if (left->value != right->value) {
			return 0;
		}
		break;
	case LTTNG_ID_STRING:
		if (strcmp(left->string, right->string) != 0) {
			return 0;
		}
		break;
	default:
		/*
		 * Normally this should return true, but comparing unset tracker
		 * id is "invalid".
		 */
		return 0;
	}
	return 1;
}

int lttng_tracker_id_copy(struct lttng_tracker_id *dest,
		const struct lttng_tracker_id *orig)
{
	int ret = 0;
	enum lttng_tracker_id_status status;

	assert(dest);
	assert(orig);

	switch (orig->type) {
	case LTTNG_ID_ALL:
		status = lttng_tracker_id_set_all(dest);
		break;
	case LTTNG_ID_VALUE:
		status = lttng_tracker_id_set_value(dest, orig->value);
		break;
	case LTTNG_ID_STRING:
		status = lttng_tracker_id_set_string(dest, orig->string);
		break;
	default:
		status = LTTNG_TRACKER_ID_STATUS_OK;
		break;
	}

	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
		ret = -1;
		goto error;
	}
error:
	return ret;
}

struct lttng_tracker_id *lttng_tracker_id_duplicate(
		const struct lttng_tracker_id *orig)
{
	int ret;
	struct lttng_tracker_id *copy = NULL;

	copy = lttng_tracker_id_create();
	if (copy == NULL) {
		goto error;
	}

	ret = lttng_tracker_id_copy(copy, orig);
	if (ret) {
		goto error;
	}

	return copy;
error:
	lttng_tracker_id_destroy(copy);
	return NULL;
}

enum lttng_tracker_id_status lttng_tracker_id_get_string(
		const struct lttng_tracker_id *id, const char **value)
{
	assert(id);
	if (id->type == LTTNG_ID_UNKNOWN) {
		*value = NULL;
		return LTTNG_TRACKER_ID_STATUS_UNSET;
	}

	if (id->type != LTTNG_ID_STRING) {
		*value = NULL;
		return LTTNG_TRACKER_ID_STATUS_INVALID;
	}

	*value = id->string;
	return LTTNG_TRACKER_ID_STATUS_OK;
}

struct lttng_tracker_ids *lttng_tracker_ids_create(unsigned int count)
{
	struct lttng_tracker_ids *ids = NULL;

	ids = zmalloc(sizeof(*ids));
	if (!ids) {
		goto error;
	}

	ids->id_array = zmalloc(sizeof(struct lttng_tracker_id) * count);
	if (!ids->id_array) {
		goto error;
	}

	ids->count = count;

	return ids;
error:
	free(ids);
	return NULL;
}

LTTNG_HIDDEN
struct lttng_tracker_id *lttng_tracker_ids_get_pointer_of_index(
		const struct lttng_tracker_ids *ids, unsigned int index)
{
	assert(ids);
	if (index >= ids->count) {
		return NULL;
	}

	return &ids->id_array[index];
}

const struct lttng_tracker_id *lttng_tracker_ids_get_at_index(
		const struct lttng_tracker_ids *ids, unsigned int index)
{
	assert(ids);
	return lttng_tracker_ids_get_pointer_of_index(ids, index);
}

enum lttng_tracker_id_status lttng_tracker_ids_get_count(const struct lttng_tracker_ids *ids, unsigned int *count)
{

	enum lttng_tracker_id_status status = LTTNG_TRACKER_ID_STATUS_OK;

	if (!ids || !count) {
		status = LTTNG_TRACKER_ID_STATUS_INVALID;
		goto end;
	}

	*count = ids->count;
end:
	return status;
}

void lttng_tracker_ids_destroy(struct lttng_tracker_ids *ids)
{
	if (!ids) {
		return;
	}

	for (int i = 0; i < ids->count; i++) {
		lttng_tracker_id_reset(&ids->id_array[i]);
	}
	free(ids->id_array);
	free(ids);
}

int lttng_tracker_ids_serialize(const struct lttng_tracker_ids *ids,
		struct lttng_dynamic_buffer *buffer)
{
	int ret;
	int value;
	const char *string;
	unsigned int count;
	enum lttng_tracker_id_status status;
	const struct lttng_tracker_id *id;

	status = lttng_tracker_ids_get_count(ids, &count);
	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
		ret = LTTNG_ERR_INVALID;
		goto error;
	}

	for (unsigned int i = 0; i < count; i++) {
		struct lttcomm_tracker_id_header id_hdr;
		size_t var_data_len = 0;

		id = lttng_tracker_ids_get_at_index(ids, i);
		if (!id) {
			ret = -LTTNG_ERR_INVALID;
			goto error;
		}

		memset(&id_hdr, 0, sizeof(id_hdr));
		id_hdr.type = lttng_tracker_id_get_type(id);
		switch (id_hdr.type) {
		case LTTNG_ID_ALL:
			break;
		case LTTNG_ID_VALUE:
			status = lttng_tracker_id_get_value(id, &value);
			id_hdr.u.value = value;
			if (status != LTTNG_TRACKER_ID_STATUS_OK) {
				ret = -LTTNG_ERR_INVALID;
				goto error;
			}
			break;
		case LTTNG_ID_STRING:
			status = lttng_tracker_id_get_string(
					id, &string);
			if (status != LTTNG_TRACKER_ID_STATUS_OK) {
				ret = -LTTNG_ERR_INVALID;
				goto error;
			}

			id_hdr.u.var_data_len = var_data_len =
					strlen(string) + 1;
			break;
		default:
			ret = -LTTNG_ERR_INVALID;
			goto error;
		}
		ret = lttng_dynamic_buffer_append(
				buffer, &id_hdr, sizeof(id_hdr));
		if (ret) {
			ret = -LTTNG_ERR_NOMEM;
			goto error;
		}
		ret = lttng_dynamic_buffer_append(
				buffer, string, var_data_len);
		if (ret) {
			ret = -LTTNG_ERR_NOMEM;
			goto error;
		}
	}
error:
	return ret;
}
Commit	Line	Data
2d97a006 JR	1	/*
	2	* Copyright (C) 2019 - Jonathan Rajotte-Julien <jonathan.rajotte-julien@efficios.com>
	3	*
	4	* This library is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This library is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
	11	* for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this library; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	#include <assert.h>
	19	#include <common/defaults.h>
	20	#include <common/error.h>
	21	#include <common/macros.h>
	22	#include <common/sessiond-comm/sessiond-comm.h>
	23	#include <common/uri.h>
	24	#include <lttng/tracker-internal.h>
	25	#include <stdio.h>
	26	#include <time.h>
	27
	28	struct lttng_tracker_id *lttng_tracker_id_create(void)
	29	{
	30	struct lttng_tracker_id *id;
	31
	32	id = zmalloc(sizeof(*id));
	33	if (!id) {
	34	goto error;
	35	}
	36
	37	id->type = LTTNG_ID_UNKNOWN;
	38	id->string = NULL;
	39	id->value = -1;
	40	return id;
	41	error:
	42	lttng_tracker_id_destroy(id);
	43	return NULL;
	44	}
	45
	46	enum lttng_tracker_id_status lttng_tracker_id_set_value(
	47	struct lttng_tracker_id *id, int value)
	48	{
	49	assert(id);
	50
	51	if (value < 0) {
	52	return LTTNG_TRACKER_ID_STATUS_INVALID;
	53	}
	54
	55	id->type = LTTNG_ID_VALUE;
	56	id->value = value;
	57	return LTTNG_TRACKER_ID_STATUS_OK;
	58	}
	59
	60	enum lttng_tracker_id_status lttng_tracker_id_set_string(
	61	struct lttng_tracker_id id, const char value)
	62	{
	63	assert(id);
	64	assert(value);
65
66	id->type = LTTNG_ID_STRING;
67	id->string = strdup(value);
68	if (id->string == NULL) {
69	/* No memory left */
70	goto error;
71	}
72
73	return LTTNG_TRACKER_ID_STATUS_OK;
74	error:
75	return LTTNG_TRACKER_ID_STATUS_INVALID;
76	}
77
78	enum lttng_tracker_id_status lttng_tracker_id_set_all(
79	struct lttng_tracker_id *id)
80	{
81	assert(id);
82
83	id->type = LTTNG_ID_ALL;
84
85	return LTTNG_TRACKER_ID_STATUS_OK;
86	}
87
a7a533cd	88	static void lttng_tracker_id_reset(struct lttng_tracker_id *id)
2d97a006 JR	89	{
	90	if (id == NULL) {
	91	return;
	92	}
	93
	94	if (id->string != NULL) {
	95	free(id->string);
a7a533cd	96	id->string = NULL;
2d97a006 JR	97	}
2d97a006 JR	98
a7a533cd JR	99	id->type = LTTNG_ID_UNKNOWN;
a7a533cd JR	100	id->value = -1;
2d97a006 JR	101	}
2d97a006 JR	102
a7a533cd	103	void lttng_tracker_id_destroy(struct lttng_tracker_id *id)
2d97a006	104	{
a7a533cd	105	if (id == NULL) {
2d97a006 JR	106	return;
	107	}
	108
a7a533cd JR	109	lttng_tracker_id_reset(id);
	110
	111	free(id);
2d97a006 JR	112	}
	113
	114	enum lttng_tracker_id_type lttng_tracker_id_get_type(
	115	const struct lttng_tracker_id *id)
	116	{
	117	assert(id);
	118	return id->type;
	119	}
	120
	121	enum lttng_tracker_id_status lttng_tracker_id_get_value(
	122	const struct lttng_tracker_id id, int value)
	123	{
	124	assert(id);
	125	if (id->type == LTTNG_ID_UNKNOWN) {
	126	return LTTNG_TRACKER_ID_STATUS_UNSET;
	127	}
	128
	129	if (id->type != LTTNG_ID_VALUE) {
	130	return LTTNG_TRACKER_ID_STATUS_INVALID;
	131	}
	132
	133	*value = id->value;
	134	return LTTNG_TRACKER_ID_STATUS_OK;
	135	}
	136
	137	bool lttng_tracker_id_is_equal(const struct lttng_tracker_id *left,
	138	const struct lttng_tracker_id *right)
	139	{
	140	if (left->type != right->type) {
	141	return 0;
	142	}
	143
	144	switch (left->type) {
	145	case LTTNG_ID_ALL:
	146	return 1;
	147	case LTTNG_ID_VALUE:
	148	if (left->value != right->value) {
	149	return 0;
	150	}
	151	break;
	152	case LTTNG_ID_STRING:
	153	if (strcmp(left->string, right->string) != 0) {
	154	return 0;
	155	}
	156	break;
	157	default:
	158	/*
	159	* Normally this should return true, but comparing unset tracker
	160	* id is "invalid".
	161	*/
	162	return 0;
	163	}
	164	return 1;
	165	}
	166
a7a533cd	167	int lttng_tracker_id_copy(struct lttng_tracker_id *dest,
2d97a006 JR	168	const struct lttng_tracker_id *orig)
2d97a006 JR	169	{
a7a533cd	170	int ret = 0;
2d97a006 JR	171	enum lttng_tracker_id_status status;
2d97a006 JR	172
a7a533cd JR	173	assert(dest);
a7a533cd JR	174	assert(orig);
2d97a006 JR	175
	176	switch (orig->type) {
	177	case LTTNG_ID_ALL:
a7a533cd	178	status = lttng_tracker_id_set_all(dest);
2d97a006 JR	179	break;
2d97a006 JR	180	case LTTNG_ID_VALUE:
a7a533cd	181	status = lttng_tracker_id_set_value(dest, orig->value);
2d97a006 JR	182	break;
2d97a006 JR	183	case LTTNG_ID_STRING:
a7a533cd	184	status = lttng_tracker_id_set_string(dest, orig->string);
2d97a006 JR	185	break;
	186	default:
	187	status = LTTNG_TRACKER_ID_STATUS_OK;
	188	break;
	189	}
	190
	191	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
a7a533cd JR	192	ret = -1;
	193	goto error;
	194	}
	195	error:
	196	return ret;
	197	}
	198
	199	struct lttng_tracker_id *lttng_tracker_id_duplicate(
	200	const struct lttng_tracker_id *orig)
	201	{
	202	int ret;
	203	struct lttng_tracker_id *copy = NULL;
	204
	205	copy = lttng_tracker_id_create();
	206	if (copy == NULL) {
	207	goto error;
	208	}
	209
	210	ret = lttng_tracker_id_copy(copy, orig);
	211	if (ret) {
2d97a006 JR	212	goto error;
	213	}
	214
	215	return copy;
	216	error:
	217	lttng_tracker_id_destroy(copy);
	218	return NULL;
	219	}
	220
	221	enum lttng_tracker_id_status lttng_tracker_id_get_string(
	222	const struct lttng_tracker_id id, const char *value)
	223	{
	224	assert(id);
	225	if (id->type == LTTNG_ID_UNKNOWN) {
	226	*value = NULL;
	227	return LTTNG_TRACKER_ID_STATUS_UNSET;
	228	}
	229
	230	if (id->type != LTTNG_ID_STRING) {
	231	*value = NULL;
	232	return LTTNG_TRACKER_ID_STATUS_INVALID;
	233	}
	234
	235	*value = id->string;
	236	return LTTNG_TRACKER_ID_STATUS_OK;
	237	}
a7a533cd JR	238
	239	struct lttng_tracker_ids *lttng_tracker_ids_create(unsigned int count)
	240	{
	241	struct lttng_tracker_ids *ids = NULL;
	242
	243	ids = zmalloc(sizeof(*ids));
	244	if (!ids) {
	245	goto error;
	246	}
	247
	248	ids->id_array = zmalloc(sizeof(struct lttng_tracker_id) * count);
	249	if (!ids->id_array) {
	250	goto error;
	251	}
	252
	253	ids->count = count;
	254
	255	return ids;
	256	error:
	257	free(ids);
	258	return NULL;
	259	}
	260
	261	LTTNG_HIDDEN
	262	struct lttng_tracker_id *lttng_tracker_ids_get_pointer_of_index(
	263	const struct lttng_tracker_ids *ids, unsigned int index)
	264	{
	265	assert(ids);
	266	if (index >= ids->count) {
	267	return NULL;
	268	}
	269
	270	return &ids->id_array[index];
	271	}
	272
	273	const struct lttng_tracker_id *lttng_tracker_ids_get_at_index(
	274	const struct lttng_tracker_ids *ids, unsigned int index)
	275	{
	276	assert(ids);
	277	return lttng_tracker_ids_get_pointer_of_index(ids, index);
	278	}
	279
79408a2b	280	enum lttng_tracker_id_status lttng_tracker_ids_get_count(const struct lttng_tracker_ids ids, unsigned int count)
a7a533cd	281	{
e283e4a0	282
79408a2b	283	enum lttng_tracker_id_status status = LTTNG_TRACKER_ID_STATUS_OK;
e283e4a0 JR	284
e283e4a0 JR	285	if (!ids \|\| !count) {
79408a2b	286	status = LTTNG_TRACKER_ID_STATUS_INVALID;
e283e4a0 JR	287	goto end;
	288	}
	289
	290	*count = ids->count;
	291	end:
	292	return status;
a7a533cd JR	293	}
	294
	295	void lttng_tracker_ids_destroy(struct lttng_tracker_ids *ids)
	296	{
	297	if (!ids) {
	298	return;
	299	}
	300
	301	for (int i = 0; i < ids->count; i++) {
	302	lttng_tracker_id_reset(&ids->id_array[i]);
	303	}
	304	free(ids->id_array);
	305	free(ids);
	306	}
f19f5c96 JR	307
	308	int lttng_tracker_ids_serialize(const struct lttng_tracker_ids *ids,
	309	struct lttng_dynamic_buffer *buffer)
	310	{
	311	int ret;
	312	int value;
	313	const char *string;
	314	unsigned int count;
	315	enum lttng_tracker_id_status status;
	316	const struct lttng_tracker_id *id;
	317
	318	status = lttng_tracker_ids_get_count(ids, &count);
	319	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
	320	ret = LTTNG_ERR_INVALID;
	321	goto error;
	322	}
	323
	324	for (unsigned int i = 0; i < count; i++) {
	325	struct lttcomm_tracker_id_header id_hdr;
	326	size_t var_data_len = 0;
	327
	328	id = lttng_tracker_ids_get_at_index(ids, i);
	329	if (!id) {
	330	ret = -LTTNG_ERR_INVALID;
	331	goto error;
	332	}
	333
	334	memset(&id_hdr, 0, sizeof(id_hdr));
	335	id_hdr.type = lttng_tracker_id_get_type(id);
	336	switch (id_hdr.type) {
	337	case LTTNG_ID_ALL:
	338	break;
	339	case LTTNG_ID_VALUE:
	340	status = lttng_tracker_id_get_value(id, &value);
	341	id_hdr.u.value = value;
	342	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
	343	ret = -LTTNG_ERR_INVALID;
	344	goto error;
	345	}
	346	break;
	347	case LTTNG_ID_STRING:
	348	status = lttng_tracker_id_get_string(
	349	id, &string);
	350	if (status != LTTNG_TRACKER_ID_STATUS_OK) {
	351	ret = -LTTNG_ERR_INVALID;
	352	goto error;
	353	}
	354
	355	id_hdr.u.var_data_len = var_data_len =
	356	strlen(string) + 1;
	357	break;
	358	default:
	359	ret = -LTTNG_ERR_INVALID;
	360	goto error;
	361	}
	362	ret = lttng_dynamic_buffer_append(
	363	buffer, &id_hdr, sizeof(id_hdr));
	364	if (ret) {
	365	ret = -LTTNG_ERR_NOMEM;
	366	goto error;
	367	}
	368	ret = lttng_dynamic_buffer_append(
	369	buffer, string, var_data_len);
	370	if (ret) {
371	ret = -LTTNG_ERR_NOMEM;
372	goto error;
373	}
374	}
375	error:
376	return ret;
377	}