Fix: liblttng-ctl: unreported truncations when copying strings
authorJérémie Galarneau <jeremie.galarneau@efficios.com>
Tue, 12 Jan 2021 22:41:54 +0000 (17:41 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Wed, 13 Jan 2021 13:43:15 +0000 (08:43 -0500)
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: Icca5f4c2490c6796b451999d7694db8597bae719

src/lib/lttng-ctl/channel.c
src/lib/lttng-ctl/load.c
src/lib/lttng-ctl/lttng-ctl-health.c
src/lib/lttng-ctl/lttng-ctl-helper.h
src/lib/lttng-ctl/lttng-ctl.c
src/lib/lttng-ctl/rotate.c
src/lib/lttng-ctl/save.c
src/lib/lttng-ctl/snapshot.c
src/lib/lttng-ctl/tracker.c

index a4e910e1d93db1b02b35f75824ddfb7f714cf5a1..868e8aa68b7eb85b1dd6f206d1fb38511cfd05e0 100644 (file)
@@ -164,9 +164,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;
index 28e1dbac6d2969eaa69b60e6c39260bb4f53d7f4..db9bfe0bf18bca0eaf3c6f2277bed6dda2f601d8 100644 (file)
@@ -230,8 +230,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:
index 9ae3d4174969e666f13ad56cfe8240e3a147d237..dc1516db5d0c7336371e10f0408927eef34a949e 100644 (file)
@@ -94,7 +94,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,
@@ -143,10 +143,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;
        }
 
        /*
@@ -218,20 +218,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)
index d1c5aa865174b16b752a0d24ab19dc1323cec699..b96ed56e4285da6fffcbd1664b704cb654d91c61 100644 (file)
@@ -20,7 +20,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);
 
index a295667fea7855e594645e99b5c24520ea5976ec..38df4cb7b11c1234c5b33f8b92d1731ea541585f 100644 (file)
@@ -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.
  *
@@ -402,8 +387,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) {
@@ -714,6 +704,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 +714,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 +727,9 @@ struct lttng_handle *lttng_create_handle(const char *session_name,
 
 end:
        return handle;
+error:
+       free(handle);
+       return NULL;
 }
 
 /*
@@ -751,22 +748,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 +786,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 +818,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 +907,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 +1116,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;
 
@@ -1312,12 +1343,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 +1355,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 +1482,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 +1567,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 +1618,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 +1636,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 +1648,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;
 }
 
 /*
@@ -2083,6 +2144,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 +2154,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 +2186,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 +2233,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 +2306,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 +2893,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 +2922,7 @@ int lttng_set_consumer_url(struct lttng_handle *handle,
                        sizeof(struct lttng_uri) * size, NULL);
 
        free(uris);
+error:
        return ret;
 }
 
@@ -2871,8 +2973,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 +3016,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 +3058,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) {
index 2dbaa46a3eaf9d955b3d50f030c0504421aa3260..1002e230b64e504b55583e1770aa49b42d38a88c 100644 (file)
@@ -219,8 +219,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) {
@@ -282,8 +285,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) {
@@ -366,10 +371,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) {
index 90ab941878581160f5a119390221f84f0502b1c0..7afac450d2913d077c3ea23b43e8f712f1843f0e 100644 (file)
@@ -134,8 +134,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:
index 2d7725c96b96394247fc8a642be782aa06e6331e..f7b4741ca12b415aaed23973bff497e85dd8e370 100644 (file)
@@ -29,26 +29,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;
 }
 
 /*
@@ -59,21 +66,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;
 }
 
 /*
@@ -98,8 +114,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) {
@@ -179,17 +199,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
@@ -202,8 +228,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;
 }
 
 /*
@@ -294,34 +321,61 @@ 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;
 }
 
 int lttng_snapshot_output_set_local_path(const char *path,
index 4f720ead80a5f1e8e72aea72c17833f680848c6b..4eae95fc566630014a634da616e772235ffb1093 100644 (file)
@@ -96,7 +96,7 @@ lttng_process_attr_tracker_handle_get_tracking_policy(
                enum lttng_tracking_policy *policy)
 {
        void *reply = NULL;
-       int reply_ret;
+       int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
                        LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
        struct lttcomm_session_msg lsm = {
@@ -108,8 +108,13 @@ lttng_process_attr_tracker_handle_get_tracking_policy(
                goto end;
        }
 
-       lttng_ctl_copy_string(lsm.session.name, tracker->session_name,
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
                        sizeof(lsm.session.name));
+       if (copy_ret) {
+               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
+               goto end;
+       }
+
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =
                        (int32_t) tracker->process_attr;
@@ -138,7 +143,7 @@ lttng_process_attr_tracker_handle_set_tracking_policy(
                const struct lttng_process_attr_tracker_handle *tracker,
                enum lttng_tracking_policy policy)
 {
-       int reply_ret;
+       int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
                        LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
        struct lttcomm_session_msg lsm = {
@@ -150,8 +155,13 @@ lttng_process_attr_tracker_handle_set_tracking_policy(
                goto end;
        }
 
-       lttng_ctl_copy_string(lsm.session.name, tracker->session_name,
-                       sizeof(lsm.session.name));
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
+                                sizeof(lsm.session.name));
+       if (copy_ret) {
+               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
+               goto end;
+       }
+
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_set_tracking_policy.process_attr =
                        (int32_t) tracker->process_attr;
@@ -192,8 +202,13 @@ end:
                        goto end;                                                                                    \
                }                                                                                                    \
                                                                                                                      \
-               lttng_ctl_copy_string(lsm.session.name, tracker->session_name,                                       \
+               ret = lttng_strncpy(lsm.session.name, tracker->session_name,                                         \
                                sizeof(lsm.session.name));                                                           \
+               if (ret) {                                                                                           \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
+                       goto end;                                                                                    \
+               }                                                                                                    \
+                                                                                                                     \
                lsm.domain.type = tracker->domain;                                                                   \
                lsm.u.process_attr_tracker_add_remove_include_value                                                  \
                                .process_attr =                                                                      \
@@ -251,8 +266,13 @@ end:
                        goto end;                                                                                    \
                }                                                                                                    \
                                                                                                                      \
-               lttng_ctl_copy_string(lsm.session.name, tracker->session_name,                                       \
+               ret = lttng_strncpy(lsm.session.name, tracker->session_name,                                         \
                                sizeof(lsm.session.name));                                                           \
+               if (ret) {                                                                                           \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
+                       goto end;                                                                                    \
+               }                                                                                                    \
+                                                                                                                     \
                lsm.domain.type = tracker->domain;                                                                   \
                lsm.u.process_attr_tracker_add_remove_include_value                                                  \
                                .process_attr =                                                                      \
@@ -348,7 +368,7 @@ lttng_process_attr_tracker_handle_get_inclusion_set(
                const struct lttng_process_attr_values **values)
 {
        void *reply = NULL;
-       int reply_ret;
+       int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
                        LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
        struct lttcomm_session_msg lsm = {
@@ -365,8 +385,13 @@ lttng_process_attr_tracker_handle_get_inclusion_set(
        lttng_process_attr_values_destroy(tracker->inclusion_set);
        tracker->inclusion_set = NULL;
 
-       lttng_ctl_copy_string(lsm.session.name, tracker->session_name,
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
                        sizeof(lsm.session.name));
+       if (copy_ret) {
+               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
+               goto end;
+       }
+
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =
                        (int32_t) tracker->process_attr;
This page took 0.068887 seconds and 4 git commands to generate.