projects / lttng-tools.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix: lttng-ctl: erroneous check if user is part of the tracing group
[lttng-tools.git] / src / lib / lttng-ctl / lttng-ctl.c
diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index ff39b88416e4d4410cd5af453a6e92baf4226a10..2765b32cf1e5a403e975fb645e3d9dcb690ce461 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -67,6 +67,13 @@ do {                                                         \
 } while (0)
 #endif
 
+#define COPY_DOMAIN_PACKED(dst, src)                           \
+do {                                                           \
+       struct lttng_domain _tmp_domain;                        \
+                                                               \
+       lttng_ctl_copy_lttng_domain(&_tmp_domain, &src);        \
+       dst = _tmp_domain;                                      \
+} while (0)
 
 /* Socket to session daemon for communication */
 static int sessiond_socket = -1;
@@ -87,21 +94,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.
  *
@@ -384,9 +376,14 @@ static int set_session_daemon_path(void)
                in_tgroup = lttng_check_tracing_group();
        }
 
-       if ((uid == 0) || in_tgroup) {
-               lttng_ctl_copy_string(sessiond_sock_path,
-                               DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, sizeof(sessiond_sock_path));
+       if ((uid == 0) || in_tgroup == 1) {
+               const int ret = lttng_strncpy(sessiond_sock_path,
+                               DEFAULT_GLOBAL_CLIENT_UNIX_SOCK,
+                               sizeof(sessiond_sock_path));
+
+               if (ret) {
+                       goto error;
+               }
        }
 
        if (uid != 0) {
@@ -606,6 +603,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));
@@ -615,8 +613,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) {
@@ -625,6 +626,9 @@ struct lttng_handle *lttng_create_handle(const char *session_name,
 
 end:
        return handle;
+error:
+       free(handle);
+       return NULL;
 }
 
 /*
@@ -643,22 +647,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));
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
 
-       lttng_ctl_copy_string(lsm.u.reg.path, socket_path,
-                       sizeof(lsm.u.reg.path));
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
-       return lttng_ctl_ask_sessiond(&lsm, NULL);
+       ret = lttng_strncpy(lsm.u.reg.path, socket_path,
+                           sizeof(lsm.u.reg.path));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
+       ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+       return ret;
 }
 
 /*
@@ -668,19 +685,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;
 }
 
 /*
@@ -692,14 +717,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) {
@@ -776,17 +806,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;
        }
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-       lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
+       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;
@@ -1110,26 +1143,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);
        }
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-       /* FIXME: copying non-packed struct to packed struct. */
+       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;
 
@@ -1308,22 +1345,25 @@ 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;
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
-       /* FIXME: copying non-packed struct to packed struct. */
+       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;
 
        /*
@@ -1440,13 +1480,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)
@@ -1517,6 +1565,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;
 
@@ -1565,12 +1614,18 @@ int lttng_enable_channel(struct lttng_handle *handle,
        }
 
        lsm.cmd_type = LTTNG_ENABLE_CHANNEL;
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       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;
 }
 
 /*
@@ -1579,6 +1634,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. */
@@ -1590,15 +1646,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;
+       }
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       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;
 }
 
 /*
@@ -1607,6 +1673,7 @@ int lttng_disable_channel(struct lttng_handle *handle, const char *name)
  */
 int lttng_track_pid(struct lttng_handle *handle, int pid)
 {
+       int ret;
        struct lttcomm_session_msg lsm;
 
        /* NULL arguments are forbidden. No default values. */
@@ -1619,12 +1686,18 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
        lsm.cmd_type = LTTNG_TRACK_PID;
        lsm.u.pid_tracker.pid = pid;
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       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;
+       }
 
-       return lttng_ctl_ask_sessiond(&lsm, NULL);
+       ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+       return ret;
 }
 
 /*
@@ -1633,6 +1706,7 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
  */
 int lttng_untrack_pid(struct lttng_handle *handle, int pid)
 {
+       int ret;
        struct lttcomm_session_msg lsm;
 
        /* NULL arguments are forbidden. No default values. */
@@ -1645,12 +1719,18 @@ int lttng_untrack_pid(struct lttng_handle *handle, int pid)
        lsm.cmd_type = LTTNG_UNTRACK_PID;
        lsm.u.pid_tracker.pid = pid;
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       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;
 }
 
 /*
@@ -1671,7 +1751,7 @@ int lttng_list_tracepoints(struct lttng_handle *handle,
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_TRACEPOINTS;
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
        if (ret < 0) {
@@ -1699,7 +1779,7 @@ int lttng_list_tracepoint_fields(struct lttng_handle *handle,
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_TRACEPOINT_FIELDS;
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) fields);
        if (ret < 0) {
@@ -2048,7 +2128,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;
 }
 
 /*
@@ -2128,6 +2208,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) {
@@ -2137,12 +2218,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;
 }
 
 /*
@@ -2158,21 +2250,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;
 }
 
 /*
@@ -2198,10 +2297,14 @@ 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;
+       }
 
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void**) channels);
        if (ret < 0) {
@@ -2257,11 +2360,21 @@ int lttng_list_events(struct lttng_handle *handle,
 
        memset(&lsm, 0, sizeof(lsm));
        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));
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond_fds_varlen(&lsm, NULL, 0, NULL, 0,
                (void **) &reception_buffer, (void **) &cmd_header,
@@ -2779,20 +2892,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));
-       lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+       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;
@@ -2801,6 +2921,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
                        sizeof(struct lttng_uri) * size, NULL);
 
        free(uris);
+error:
        return ret;
 }
 
@@ -2847,8 +2968,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) {
@@ -2857,6 +2982,10 @@ int lttng_data_pending(const char *session_name)
                /* Unexpected payload size */
                ret = -LTTNG_ERR_INVALID;
                goto end;
+       } else if (!pending) {
+               /* Internal error. */
+               ret = -LTTNG_ERR_UNK;
+               goto end;
        }
 
        ret = (int) *pending;
@@ -2890,9 +3019,12 @@ int lttng_list_tracker_pids(struct lttng_handle *handle,
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_LIST_TRACKER_PIDS;
-       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_lttng_domain(&lsm.domain, &handle->domain);
+       if (ret) {
+               return -LTTNG_ERR_INVALID;
+       }
+       COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pids);
        if (ret < 0) {
@@ -2931,8 +3063,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) {
@@ -2969,8 +3105,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) {
LTTng 2.0 tools and control repository
This page took 0.037082 seconds and 4 git commands to generate.