X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=52b5263d89ae34c046be44c94766caf94bb1be9e;hp=91d6109e5383b77f8013d67aad18b374d4e131ba;hb=3204017e17704001c83085d94c2a8fc72e1aad16;hpb=fbc9f37df245d544a7705ba576297df791220b44

diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index 91d6109e5..52b5263d8 100644
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -18,6 +18,7 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <common/bytecode/bytecode.h>
 #include <common/common.h>
 #include <common/compat/errno.h>
 #include <common/compat/string.h>
@@ -45,7 +46,6 @@
 
 #include <common/filter/filter-ast.h>
 #include <common/filter/filter-parser.h>
-#include <common/filter/filter-bytecode.h>
 #include <common/filter/memstream.h>
 #include "lttng-ctl-helper.h"
 
@@ -76,21 +76,6 @@ int lttng_opt_quiet;
 int lttng_opt_verbose;
 int lttng_opt_mi;
 
-/*
- * Copy string from src to dst and enforce null terminated byte.
- */
-LTTNG_HIDDEN
-void lttng_ctl_copy_string(char *dst, const char *src, size_t len)
-{
-	if (src && dst) {
-		strncpy(dst, src, len);
-		/* Enforce the NULL terminated byte */
-		dst[len - 1] = '\0';
-	} else if (dst) {
-		dst[0] = '\0';
-	}
-}
-
 /*
  * Copy domain to lttcomm_session_msg domain.
  *
@@ -131,7 +116,8 @@ static int send_session_msg(struct lttcomm_session_msg *lsm)
 		goto end;
 	}
 
-	DBG("LSM cmd type : %d", lsm->cmd_type);
+	DBG("LSM cmd type: '%s' (%d)", lttcomm_sessiond_command_str(lsm->cmd_type),
+			lsm->cmd_type);
 
 	ret = lttcomm_send_creds_unix_sock(sessiond_socket, lsm,
 			sizeof(struct lttcomm_session_msg));
@@ -402,8 +388,13 @@ static int set_session_daemon_path(void)
 	}
 
 	if ((uid == 0) || in_tgroup) {
-		lttng_ctl_copy_string(sessiond_sock_path,
-				DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path));
+		const int ret = lttng_strncpy(sessiond_sock_path,
+				DEFAULT_GLOBAL_CLIENT_UNIX_SOCK,
+				sizeof(sessiond_sock_path));
+
+		if (ret) {
+			goto error;
+		}
 	}
 
 	if (uid != 0) {
@@ -662,7 +653,12 @@ int lttng_ctl_ask_sessiond_payload(struct lttng_payload_view *message,
 
 	/* Check error code if OK */
 	if (llm.ret_code != LTTNG_OK) {
-		ret = -llm.ret_code;
+		if (llm.ret_code < LTTNG_OK || llm.ret_code >= LTTNG_ERR_NR) {
+			/* Invalid error code received. */
+			ret = -LTTNG_ERR_UNK;
+		} else {
+			ret = -llm.ret_code;
+		}
 		goto end;
 	}
 
@@ -714,6 +710,7 @@ end:
 struct lttng_handle *lttng_create_handle(const char *session_name,
 		struct lttng_domain *domain)
 {
+	int ret;
 	struct lttng_handle *handle = NULL;
 
 	handle = zmalloc(sizeof(struct lttng_handle));
@@ -723,8 +720,11 @@ struct lttng_handle *lttng_create_handle(const char *session_name,
 	}
 
 	/* Copy session name */
-	lttng_ctl_copy_string(handle->session_name, session_name,
-			sizeof(handle->session_name));
+	ret = lttng_strncpy(handle->session_name, session_name ? : "",
+			    sizeof(handle->session_name));
+	if (ret) {
+		goto error;
+	}
 
 	/* Copy lttng domain or leave initialized to 0. */
 	if (domain) {
@@ -733,6 +733,9 @@ struct lttng_handle *lttng_create_handle(const char *session_name,
 
 end:
 	return handle;
+error:
+	free(handle);
+	return NULL;
 }
 
 /*
@@ -751,22 +754,35 @@ void lttng_destroy_handle(struct lttng_handle *handle)
 int lttng_register_consumer(struct lttng_handle *handle,
 		const char *socket_path)
 {
+	int ret;
 	struct lttcomm_session_msg lsm;
 
 	if (handle == NULL || socket_path == NULL) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_REGISTER_CONSUMER;
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
+
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
-	lttng_ctl_copy_string(lsm.u.reg.path, socket_path,
-			sizeof(lsm.u.reg.path));
+	ret = lttng_strncpy(lsm.u.reg.path, socket_path,
+			    sizeof(lsm.u.reg.path));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
+	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+	return ret;
 }
 
 /*
@@ -776,19 +792,27 @@ int lttng_register_consumer(struct lttng_handle *handle,
  */
 int lttng_start_tracing(const char *session_name)
 {
+	int ret;
 	struct lttcomm_session_msg lsm;
 
 	if (session_name == NULL) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_START_TRACE;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
-			sizeof(lsm.session.name));
+	ret = lttng_strncpy(lsm.session.name, session_name,
+			    sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
+	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+	return ret;
 }
 
 /*
@@ -800,14 +824,19 @@ static int _lttng_stop_tracing(const char *session_name, int wait)
 	struct lttcomm_session_msg lsm;
 
 	if (session_name == NULL) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_STOP_TRACE;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
-			sizeof(lsm.session.name));
+	ret = lttng_strncpy(lsm.session.name, session_name,
+			    sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
 
 	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
 	if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
@@ -884,17 +913,20 @@ int lttng_add_context(struct lttng_handle *handle,
 	lsm.cmd_type = LTTNG_ADD_CONTEXT;
 
 	/* If no channel name, send empty string. */
-	if (channel_name == NULL) {
-		lttng_ctl_copy_string(lsm.u.context.channel_name, "",
-				sizeof(lsm.u.context.channel_name));
-	} else {
-		lttng_ctl_copy_string(lsm.u.context.channel_name, channel_name,
-				sizeof(lsm.u.context.channel_name));
+	ret = lttng_strncpy(lsm.u.context.channel_name, channel_name ?: "",
+			sizeof(lsm.u.context.channel_name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
 	}
 
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
 		size_t provider_len, ctx_len;
@@ -1090,25 +1122,30 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
 	memset(&lsm, 0, sizeof(lsm));
 
 	/* If no channel name, send empty string. */
-	if (channel_name == NULL) {
-		lttng_ctl_copy_string(lsm.u.enable.channel_name, "",
-				sizeof(lsm.u.enable.channel_name));
-	} else {
-		lttng_ctl_copy_string(lsm.u.enable.channel_name, channel_name,
-				sizeof(lsm.u.enable.channel_name));
+	ret = lttng_strncpy(lsm.u.enable.channel_name, channel_name ?: "",
+			sizeof(lsm.u.enable.channel_name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	lsm.cmd_type = LTTNG_ENABLE_EVENT;
 	if (ev->name[0] == '\0') {
-		/* Enable all events */
-		lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name));
+		/* Enable all events. */
+		ret = lttng_strncpy(ev->name, "*", sizeof(ev->name));
+		assert(ret == 0);
 	}
 
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 	memcpy(&lsm.u.enable.event, ev, sizeof(lsm.u.enable.event));
 
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
+
 	lsm.u.enable.exclusion_count = exclusion_count;
 	lsm.u.enable.bytecode_len = 0;
 
@@ -1233,15 +1270,15 @@ int lttng_enable_event_with_exclusions(struct lttng_handle *handle,
 
 		assert(fd_count == 0 || fd_count == 1);
 		if (fd_count == 1) {
-			struct fd_handle *handle =
+			struct fd_handle *h =
 					lttng_payload_view_pop_fd_handle(&view);
 
-			if (!handle) {
+			if (!h) {
 				goto mem_error;
 			}
 
-			fd_to_send = fd_handle_get_fd(handle);
-			fd_handle_put(handle);
+			fd_to_send = fd_handle_get_fd(h);
+			fd_handle_put(h);
 		}
 
 		ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm,
@@ -1312,12 +1349,11 @@ int lttng_disable_event_ext(struct lttng_handle *handle,
 	memset(&lsm, 0, sizeof(lsm));
 
 	/* If no channel name, send empty string. */
-	if (channel_name == NULL) {
-		lttng_ctl_copy_string(lsm.u.disable.channel_name, "",
-				sizeof(lsm.u.disable.channel_name));
-	} else {
-		lttng_ctl_copy_string(lsm.u.disable.channel_name, channel_name,
-				sizeof(lsm.u.disable.channel_name));
+	ret = lttng_strncpy(lsm.u.disable.channel_name, channel_name ?: "",
+			sizeof(lsm.u.disable.channel_name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	lsm.cmd_type = LTTNG_DISABLE_EVENT;
@@ -1325,8 +1361,13 @@ int lttng_disable_event_ext(struct lttng_handle *handle,
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 	memcpy(&lsm.u.disable.event, ev, sizeof(lsm.u.disable.event));
 
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
+
 	lsm.u.disable.bytecode_len = 0;
 
 	/*
@@ -1447,13 +1488,21 @@ ask_sessiond:
 int lttng_disable_event(struct lttng_handle *handle, const char *name,
 		const char *channel_name)
 {
+	int ret;
 	struct lttng_event ev;
 
 	memset(&ev, 0, sizeof(ev));
 	ev.loglevel = -1;
 	ev.type = LTTNG_EVENT_ALL;
-	lttng_ctl_copy_string(ev.name, name, sizeof(ev.name));
-	return lttng_disable_event_ext(handle, &ev, channel_name, NULL);
+	ret = lttng_strncpy(ev.name, name ?: "", sizeof(ev.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
+
+	ret = lttng_disable_event_ext(handle, &ev, channel_name, NULL);
+end:
+	return ret;
 }
 
 struct lttng_channel *lttng_channel_create(struct lttng_domain *domain)
@@ -1524,6 +1573,7 @@ void lttng_channel_destroy(struct lttng_channel *channel)
 int lttng_enable_channel(struct lttng_handle *handle,
 		struct lttng_channel *in_chan)
 {
+	int ret;
 	struct lttcomm_session_msg lsm;
 	size_t total_buffer_size_needed_per_cpu = 0;
 
@@ -1574,10 +1624,16 @@ int lttng_enable_channel(struct lttng_handle *handle,
 	lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
-			sizeof(lsm.session.name));
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
+				    sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
+	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+	return ret;
 }
 
 /*
@@ -1586,6 +1642,7 @@ int lttng_enable_channel(struct lttng_handle *handle,
  */
 int lttng_disable_channel(struct lttng_handle *handle, const char *name)
 {
+	int ret;
 	struct lttcomm_session_msg lsm;
 
 	/* Safety check. Both are mandatory. */
@@ -1597,15 +1654,25 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name)
 
 	lsm.cmd_type = LTTNG_DISABLE_CHANNEL;
 
-	lttng_ctl_copy_string(lsm.u.disable.channel_name, name,
+	ret = lttng_strncpy(lsm.u.disable.channel_name, name,
 			sizeof(lsm.u.disable.channel_name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
-			sizeof(lsm.session.name));
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
+			    sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
+	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+	return ret;
 }
 
 /*
@@ -2003,7 +2070,7 @@ int lttng_destroy_session_no_wait(const char *session_name)
 	enum lttng_error_code ret_code;
 
 	ret_code = lttng_destroy_session_ext(session_name, NULL);
-	return ret_code == LTTNG_OK ? ret_code : -ret_code;
+	return ret_code == LTTNG_OK ? 0 : -ret_code;
 }
 
 /*
@@ -2083,6 +2150,7 @@ end:
 int lttng_set_session_shm_path(const char *session_name,
 		const char *shm_path)
 {
+	int ret;
 	struct lttcomm_session_msg lsm;
 
 	if (session_name == NULL) {
@@ -2092,12 +2160,23 @@ int lttng_set_session_shm_path(const char *session_name,
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_SET_SESSION_SHM_PATH;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
+	ret = lttng_strncpy(lsm.session.name, session_name,
 			sizeof(lsm.session.name));
-	lttng_ctl_copy_string(lsm.u.set_shm_path.shm_path, shm_path,
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
+
+	ret = lttng_strncpy(lsm.u.set_shm_path.shm_path, shm_path ?: "",
 			sizeof(lsm.u.set_shm_path.shm_path));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
-	return lttng_ctl_ask_sessiond(&lsm, NULL);
+	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+	return ret;
 }
 
 /*
@@ -2113,21 +2192,28 @@ int lttng_list_domains(const char *session_name,
 	struct lttcomm_session_msg lsm;
 
 	if (session_name == NULL) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_LIST_DOMAINS;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
+	ret = lttng_strncpy(lsm.session.name, session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
 
 	ret = lttng_ctl_ask_sessiond(&lsm, (void**) domains);
 	if (ret < 0) {
-		return ret;
+		goto error;
 	}
 
 	return ret / sizeof(struct lttng_domain);
+error:
+	return ret;
 }
 
 /*
@@ -2153,8 +2239,12 @@ int lttng_list_channels(struct lttng_handle *handle,
 
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_LIST_CHANNELS;
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
@@ -2222,10 +2312,20 @@ int lttng_list_events(struct lttng_handle *handle,
 	lttng_payload_init(&payload_copy);
 
 	lsm.cmd_type = LTTNG_LIST_EVENTS;
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
-	lttng_ctl_copy_string(lsm.u.list.channel_name, channel_name,
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
+
+	ret = lttng_strncpy(lsm.u.list.channel_name, channel_name,
 			sizeof(lsm.u.list.channel_name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
+
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	ret = lttng_ctl_ask_sessiond_payload(&lsm_view, &payload);
@@ -2799,20 +2899,27 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
 	struct lttng_uri *uris = NULL;
 
 	if (handle == NULL || (control_url == NULL && data_url == NULL)) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	memset(&lsm, 0, sizeof(lsm));
 
 	lsm.cmd_type = LTTNG_SET_CONSUMER_URI;
 
-	lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+	ret = lttng_strncpy(lsm.session.name, handle->session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
+	}
+
 	COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
 	size = uri_parse_str_urls(control_url, data_url, &uris);
 	if (size < 0) {
-		return -LTTNG_ERR_INVALID;
+		ret = -LTTNG_ERR_INVALID;
+		goto error;
 	}
 
 	lsm.u.uri.size = size;
@@ -2821,6 +2928,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
 			sizeof(struct lttng_uri) * size, NULL);
 
 	free(uris);
+error:
 	return ret;
 }
 
@@ -2871,8 +2979,12 @@ int lttng_data_pending(const char *session_name)
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_DATA_PENDING;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
+	ret = lttng_strncpy(lsm.session.name, session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pending);
 	if (ret < 0) {
@@ -2910,8 +3022,12 @@ int lttng_regenerate_metadata(const char *session_name)
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_REGENERATE_METADATA;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
+	ret = lttng_strncpy(lsm.session.name, session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
 	if (ret < 0) {
@@ -2948,8 +3064,12 @@ int lttng_regenerate_statedump(const char *session_name)
 	memset(&lsm, 0, sizeof(lsm));
 	lsm.cmd_type = LTTNG_REGENERATE_STATEDUMP;
 
-	lttng_ctl_copy_string(lsm.session.name, session_name,
+	ret = lttng_strncpy(lsm.session.name, session_name,
 			sizeof(lsm.session.name));
+	if (ret) {
+		ret = -LTTNG_ERR_INVALID;
+		goto end;
+	}
 
 	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
 	if (ret < 0) {
@@ -2971,6 +3091,7 @@ int lttng_register_trigger(struct lttng_trigger *trigger)
 	struct lttng_payload message;
 	struct lttng_payload reply;
 	struct lttng_trigger *reply_trigger = NULL;
+	enum lttng_domain_type domain_type;
 	const struct lttng_credentials user_creds = {
 		.uid = LTTNG_OPTIONAL_INIT_VALUE(geteuid()),
 		.gid = LTTNG_OPTIONAL_INIT_UNSET,
@@ -3015,24 +3136,29 @@ int lttng_register_trigger(struct lttng_trigger *trigger)
 		goto end;
 	}
 
+	domain_type = lttng_trigger_get_underlying_domain_type_restriction(
+			trigger);
+
+	lsm.domain.type = domain_type;
+
 	ret = lttng_dynamic_buffer_append(&message.buffer, &lsm, sizeof(lsm));
 	if (ret) {
 		ret = -LTTNG_ERR_NOMEM;
 		goto end;
 	}
 
-	/*
-	 * This is needed to populate the trigger object size for the command
-	 * header.
-	*/
-	message_lsm = (struct lttcomm_session_msg *) message.buffer.data;
-
 	ret = lttng_trigger_serialize(trigger, &message);
 	if (ret < 0) {
 		ret = -LTTNG_ERR_UNK;
 		goto end;
 	}
 
+	/*
+	 * This is needed to populate the trigger object size for the command
+	 * header.
+	 */
+	message_lsm = (struct lttcomm_session_msg *) message.buffer.data;
+
 	message_lsm->u.trigger.length = (uint32_t) message.buffer.size - sizeof(lsm);
 
 	{
@@ -3075,13 +3201,14 @@ end:
 	return ret;
 }
 
-int lttng_unregister_trigger(struct lttng_trigger *trigger)
+int lttng_unregister_trigger(const struct lttng_trigger *trigger)
 {
 	int ret;
 	struct lttcomm_session_msg lsm;
 	struct lttcomm_session_msg *message_lsm;
 	struct lttng_payload message;
 	struct lttng_payload reply;
+	struct lttng_trigger *copy = NULL;
 	const struct lttng_credentials user_creds = {
 		.uid = LTTNG_OPTIONAL_INIT_VALUE(geteuid()),
 		.gid = LTTNG_OPTIONAL_INIT_UNSET,
@@ -3095,9 +3222,15 @@ int lttng_unregister_trigger(struct lttng_trigger *trigger)
 		goto end;
 	}
 
-	if (!trigger->creds.uid.is_set) {
-		/* Use the client's credentials as the trigger credentials. */
-		lttng_trigger_set_credentials(trigger, &user_creds);
+	copy = lttng_trigger_copy(trigger);
+	if (!copy) {
+		ret = -LTTNG_ERR_UNK;
+		goto end;
+	}
+
+	if (!copy->creds.uid.is_set) {
+		/* Use the client credentials as the trigger credentials */
+		lttng_trigger_set_credentials(copy, &user_creds);
 	} else {
 		/*
 		 * Validate that either the current trigger credentials and the
@@ -3110,8 +3243,7 @@ int lttng_unregister_trigger(struct lttng_trigger *trigger)
 		 * "safety" checks.
 		 */
 		const struct lttng_credentials *trigger_creds =
-				lttng_trigger_get_credentials(trigger);
-
+				lttng_trigger_get_credentials(copy);
 		if (!lttng_credentials_is_equal_uid(trigger_creds, &user_creds)) {
 			if (lttng_credentials_get_uid(&user_creds) != 0) {
 				ret = -LTTNG_ERR_EPERM;
@@ -3120,7 +3252,7 @@ int lttng_unregister_trigger(struct lttng_trigger *trigger)
 		}
 	}
 
-	if (!lttng_trigger_validate(trigger)) {
+	if (!lttng_trigger_validate(copy)) {
 		ret = -LTTNG_ERR_INVALID_TRIGGER;
 		goto end;
 	}
@@ -3140,7 +3272,7 @@ int lttng_unregister_trigger(struct lttng_trigger *trigger)
 	*/
 	message_lsm = (struct lttcomm_session_msg *) message.buffer.data;
 
-	ret = lttng_trigger_serialize(trigger, &message);
+	ret = lttng_trigger_serialize(copy, &message);
 	if (ret < 0) {
 		ret = -LTTNG_ERR_UNK;
 		goto end;
@@ -3168,6 +3300,7 @@ int lttng_unregister_trigger(struct lttng_trigger *trigger)
 
 	ret = 0;
 end:
+	lttng_trigger_destroy(copy);
 	lttng_payload_reset(&message);
 	lttng_payload_reset(&reply);
 	return ret;