Fix: liblttng-ctl: unreported truncations when copying strings

gcc 10.2 reports a large number of string truncation warning in
liblttng-ctl. Replace the uses of lttng_ctl_copy_string() util by
lttng_strncpy() (handling the null source case when applicable) and
report the truncations when they occur.

Example gcc warning:
  lttng-ctl.c:86:3: warning: ‘strncpy’ output may be truncated copying 254 bytes from a string of length 254 [-Wstringop-truncation]

Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: I673720963c9ba456e7d900b1a845e72646eda97c

diff --git a/src/lib/lttng-ctl/channel.c b/src/lib/lttng-ctl/channel.c
index bcecc65fbbb281d6466b6805c88f28ca1cac448e..d6f52e517d85883ae5cf6b0e5f28db671b60b9ff 100644 (file)
--- a/src/lib/lttng-ctl/channel.c
+++ b/src/lib/lttng-ctl/channel.c
@@ -161,9 +161,14 @@ struct lttng_notification_channel *lttng_notification_channel_create(
        }
 
        if (is_root || is_in_tracing_group) {
-               lttng_ctl_copy_string(sock_path,
+               ret = lttng_strncpy(sock_path,
                                DEFAULT_GLOBAL_NOTIFICATION_CHANNEL_UNIX_SOCK,
                                LTTNG_PATH_MAX);
+               if (ret) {
+                       ret = -LTTNG_ERR_INVALID;
+                       goto error;
+               }
+
                ret = lttcomm_connect_unix_sock(sock_path);
                if (ret >= 0) {
                        fd = ret;

diff --git a/src/lib/lttng-ctl/load.c b/src/lib/lttng-ctl/load.c
index 0f9ccfa0e86143800a7be426f0574df1d6ba8274..d55e3b0b4107b12c0cb5e84ef9e0e6aacb22354d 100644 (file)
--- a/src/lib/lttng-ctl/load.c
+++ b/src/lib/lttng-ctl/load.c
@@ -240,8 +240,12 @@ int lttng_load_session_attr_set_input_url(
        }
 
        /* Copy string plus the NULL terminated byte. */
-       lttng_ctl_copy_string(attr->input_url, uris[0].dst.path,
+       ret = lttng_strncpy(attr->input_url, uris[0].dst.path,
                        sizeof(attr->input_url));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto error;
+       }
 
 end:
 error:

diff --git a/src/lib/lttng-ctl/lttng-ctl-health.c b/src/lib/lttng-ctl/lttng-ctl-health.c
index 811c6d935184115af4388921df4507c2c05ae5c0..c20522bd6b458ac446da3093c79ace48a6f286e6 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl-health.c
+++ b/src/lib/lttng-ctl/lttng-ctl-health.c
@@ -103,7 +103,7 @@ const char **thread_name[NR_HEALTH_COMPONENT] = {
 /*
  * Set health socket path.
  *
- * Returns 0 on success or -ENOMEM.
+ * Returns 0 on success or a negative errno.
  */
 static
 int set_health_socket_path(struct lttng_health *lh,
@@ -152,10 +152,10 @@ int set_health_socket_path(struct lttng_health *lh,
        uid = getuid();
 
        if (uid == 0 || tracing_group) {
-               lttng_ctl_copy_string(lh->health_sock_path,
+               ret = lttng_strncpy(lh->health_sock_path,
                                global_str,
                                sizeof(lh->health_sock_path));
-               return 0;
+               return ret == 0 ? 0 : -EINVAL;
        }
 
        /*
@@ -227,20 +227,30 @@ struct lttng_health *
 
 struct lttng_health *lttng_health_create_relayd(const char *path)
 {
-       struct lttng_health *lh;
+       int ret;
+       struct lttng_health *lh = NULL;
 
        if (!path) {
-               return NULL;
+               goto error;
        }
 
        lh = lttng_health_create(HEALTH_COMPONENT_RELAYD,
                        NR_HEALTH_RELAYD_TYPES);
        if (!lh) {
-               return NULL;
+               goto error;
        }
-       lttng_ctl_copy_string(lh->health_sock_path, path,
-               sizeof(lh->health_sock_path));
+
+       ret = lttng_strncpy(lh->health_sock_path, path ?: "",
+                           sizeof(lh->health_sock_path));
+       if (ret) {
+               goto error;
+       }
+
        return lh;
+
+error:
+       free(lh);
+       return NULL;
 }
 
 void lttng_health_destroy(struct lttng_health *lh)

diff --git a/src/lib/lttng-ctl/lttng-ctl-helper.h b/src/lib/lttng-ctl/lttng-ctl-helper.h
index 4341ee6b5f3f5daf0e0bb0ae4ac4b46be2c125f5..345ca143ed9b08a1b7ee13b5ab0c4227d7303479 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl-helper.h
+++ b/src/lib/lttng-ctl/lttng-ctl-helper.h
@@ -30,7 +30,6 @@
  */
 
 /* Copy helper functions. */
-void lttng_ctl_copy_string(char *dst, const char *src, size_t len);
 void lttng_ctl_copy_lttng_domain(struct lttng_domain *dst,
                struct lttng_domain *src);
 

diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c
index 79644ceed79ae55c7c543de9d0a2af8e680f08bd..ad4974a1395cd4d284a3c56b3ac10bf4178c0381 100644 (file)
--- a/src/lib/lttng-ctl/lttng-ctl.c
+++ b/src/lib/lttng-ctl/lttng-ctl.c
@@ -94,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.
  *
@@ -392,8 +377,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) {
@@ -613,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));
@@ -622,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) {
@@ -632,6 +626,9 @@ struct lttng_handle *lttng_create_handle(const char *session_name,
 
 end:
        return handle;
+error:
+       free(handle);
+       return NULL;
 }
 
 /*
@@ -650,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));
+       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;
 }
 
 /*
@@ -675,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;
 }
 
 /*
@@ -699,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) {
@@ -783,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;
        }
 
        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;
@@ -1117,25 +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);
        }
 
        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;
 
@@ -1314,12 +1345,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;
@@ -1327,8 +1357,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;
 
        /*
@@ -1445,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)
@@ -1522,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;
 
@@ -1572,10 +1616,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;
 }
 
 /*
@@ -1584,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. */
@@ -1595,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;
+       }
 
        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;
 }
 
 /*
@@ -1612,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. */
@@ -1626,10 +1688,16 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
 
        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;
 }
 
 /*
@@ -1638,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. */
@@ -1652,10 +1721,16 @@ int lttng_untrack_pid(struct lttng_handle *handle, int pid)
 
        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;
 }
 
 /*
@@ -2133,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) {
@@ -2142,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;
 }
 
 /*
@@ -2163,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;
 }
 
 /*
@@ -2203,8 +2297,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);
 
@@ -2262,10 +2360,20 @@ 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));
+       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,
@@ -2784,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));
+       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;
@@ -2806,6 +2921,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
                        sizeof(struct lttng_uri) * size, NULL);
 
        free(uris);
+error:
        return ret;
 }
 
@@ -2852,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) {
@@ -2899,8 +3019,11 @@ 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));
+       if (ret) {
+               return -LTTNG_ERR_INVALID;
+       }
        COPY_DOMAIN_PACKED(lsm.domain, handle->domain);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) &pids);
@@ -2940,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) {
@@ -2978,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) {

diff --git a/src/lib/lttng-ctl/rotate.c b/src/lib/lttng-ctl/rotate.c
index bd02a940c22a34b70b15234a1f4dd61c7f2cd5c7..bd048aa2e07ec1a568a6fb100b324e5e469e9fc6 100644 (file)
--- a/src/lib/lttng-ctl/rotate.c
+++ b/src/lib/lttng-ctl/rotate.c
@@ -229,8 +229,11 @@ int lttng_rotate_session(const char *session_name,
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_ROTATE_SESSION;
-       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));
+       /* Source length already validated. */
+       assert(ret == 0);
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) &rotate_return);
        if (ret <= 0) {
@@ -292,8 +295,10 @@ enum lttng_rotation_status lttng_rotation_update_schedule(
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_ROTATION_SET_SCHEDULE;
-       lttng_ctl_copy_string(lsm.session.name, session_name,
+       ret = lttng_strncpy(lsm.session.name, session_name,
                        sizeof(lsm.session.name));
+       /* Source length already validated. */
+       assert(ret == 0);
 
        lsm.u.rotation_set_schedule.type = (uint32_t) schedule->type;
        switch (schedule->type) {
@@ -376,10 +381,19 @@ int get_schedules(const char *session_name,
        struct lttng_rotation_schedules *schedules = NULL;
        struct lttng_rotation_schedule *periodic = NULL, *size = NULL;
 
+       if (!session_name) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_SESSION_LIST_ROTATION_SCHEDULES;
-       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 **) &schedules_comm);
        if (ret < 0) {

diff --git a/src/lib/lttng-ctl/save.c b/src/lib/lttng-ctl/save.c
index 8302226644f89f708394e78f6a51ddf2eba061c2..dfd4eb3f87de9598ae4f34dfba34ba50d9460994 100644 (file)
--- a/src/lib/lttng-ctl/save.c
+++ b/src/lib/lttng-ctl/save.c
@@ -144,8 +144,12 @@ int lttng_save_session_attr_set_output_url(
        }
 
        /* Copy string plus the NULL terminated byte. */
-       lttng_ctl_copy_string(attr->configuration_url, uris[0].dst.path,
-                       sizeof(attr->configuration_url));
+       ret = lttng_strncpy(attr->configuration_url, uris[0].dst.path,
+                           sizeof(attr->configuration_url));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto error;
+       }
 
 end:
 error:

diff --git a/src/lib/lttng-ctl/snapshot.c b/src/lib/lttng-ctl/snapshot.c
index b30c4706e7db2a5d6901b1dd586a245d1e912ddb..dd36aacc44375c4f44b77d94feedb1e7ce9b98ed 100644 (file)
--- a/src/lib/lttng-ctl/snapshot.c
+++ b/src/lib/lttng-ctl/snapshot.c
@@ -39,26 +39,33 @@ int lttng_snapshot_add_output(const char *session_name,
        struct lttcomm_lttng_output_id *reply;
 
        if (!session_name || !output) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_SNAPSHOT_ADD_OUTPUT;
 
-       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;
+       }
+
        memcpy(&lsm.u.snapshot_output.output, output,
                        sizeof(lsm.u.snapshot_output.output));
 
        ret = lttng_ctl_ask_sessiond(&lsm, (void **) &reply);
        if (ret < 0) {
-               return ret;
+               goto end;
        }
 
        output->id = reply->id;
        free(reply);
-
-       return 0;
+       ret = 0;
+end:
+       return ret;
 }
 
 /*
@@ -69,21 +76,30 @@ int lttng_snapshot_add_output(const char *session_name,
 int lttng_snapshot_del_output(const char *session_name,
                struct lttng_snapshot_output *output)
 {
+       int ret;
        struct lttcomm_session_msg lsm;
 
        if (!session_name || !output) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_SNAPSHOT_DEL_OUTPUT;
 
-       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;
+       }
+
        memcpy(&lsm.u.snapshot_output.output, output,
                        sizeof(lsm.u.snapshot_output.output));
 
-       return lttng_ctl_ask_sessiond(&lsm, NULL);
+       ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+       return ret;
 }
 
 /*
@@ -108,8 +124,12 @@ int lttng_snapshot_list_output(const char *session_name,
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_SNAPSHOT_LIST_OUTPUT;
 
-       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;
+       }
 
        new_list = zmalloc(sizeof(*new_list));
        if (!new_list) {
@@ -189,17 +209,23 @@ void lttng_snapshot_output_list_destroy(struct lttng_snapshot_output_list *list)
 int lttng_snapshot_record(const char *session_name,
                struct lttng_snapshot_output *output, int wait)
 {
+       int ret;
        struct lttcomm_session_msg lsm;
 
        if (!session_name) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
        memset(&lsm, 0, sizeof(lsm));
        lsm.cmd_type = LTTNG_SNAPSHOT_RECORD;
 
-       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;
+       }
 
        /*
         * Not having an output object will use the default one of the session that
@@ -212,8 +238,9 @@ int lttng_snapshot_record(const char *session_name,
        }
 
        /* The wait param is ignored. */
-
-       return lttng_ctl_ask_sessiond(&lsm, NULL);
+       ret = lttng_ctl_ask_sessiond(&lsm, NULL);
+end:
+       return ret;
 }
 
 /*
@@ -304,32 +331,59 @@ int lttng_snapshot_output_set_size(uint64_t size,
 int lttng_snapshot_output_set_name(const char *name,
                struct lttng_snapshot_output *output)
 {
+       int ret;
+
        if (!output || !name) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
-       lttng_ctl_copy_string(output->name, name, sizeof(output->name));
-       return 0;
+       ret = lttng_strncpy(output->name, name, sizeof(output->name));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
+end:
+       return ret;
 }
 
 int lttng_snapshot_output_set_ctrl_url(const char *url,
                struct lttng_snapshot_output *output)
 {
+       int ret;
+
        if (!output || !url) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
-       lttng_ctl_copy_string(output->ctrl_url, url, sizeof(output->ctrl_url));
-       return 0;
+       ret = lttng_strncpy(output->ctrl_url, url, sizeof(output->ctrl_url));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
+end:
+       return ret;
 }
 
 int lttng_snapshot_output_set_data_url(const char *url,
                struct lttng_snapshot_output *output)
 {
+       int ret;
+
        if (!output || !url) {
-               return -LTTNG_ERR_INVALID;
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
        }
 
-       lttng_ctl_copy_string(output->data_url, url, sizeof(output->data_url));
-       return 0;
+       ret = lttng_strncpy(output->data_url, url, sizeof(output->data_url));
+       if (ret) {
+               ret = -LTTNG_ERR_INVALID;
+               goto end;
+       }
+
+end:
+       return ret;
 }