goto end;
}
- DBG("File descriptor pool size argument (%u) adjusted to %u to accomodate transient fd uses",
+ DBG("File descriptor pool size argument (%u) adjusted to %u to accommodates transient fd uses",
lttng_opt_fd_pool_size,
lttng_opt_fd_pool_size - DEFAULT_RELAYD_FD_POOL_SIZE_RESERVE);
lttng_opt_fd_pool_size -= DEFAULT_RELAYD_FD_POOL_SIZE_RESERVE;
int c, ret = 0, option_index = 0, retval = 0;
int orig_optopt = optopt, orig_optind = optind;
char *default_address, *optstring;
- const char *config_path = NULL;
+ char *config_path = NULL;
optstring = utils_generate_optstring(long_options,
sizeof(long_options) / sizeof(struct option));
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-f, --config");
} else {
+ free(config_path);
config_path = utils_expand_path(optarg);
if (!config_path) {
ERR("Failed to resolve path: %s", optarg);
}
exit:
+ free(config_path);
free(optstring);
return retval;
}
}
ret = fd_tracker_util_poll_create(the_fd_tracker,
- name, events, 1, LTTNG_CLOEXEC);
+ name, events, 1, LTTNG_CLOEXEC);
if (ret) {
PERROR("Failed to create \"%s\" poll file descriptor", name);
goto error;
struct lttcomm_sock **socks = data;
struct lttcomm_sock *in_sock = socks[0];
- socks[1] = in_sock->ops->accept(in_sock);
+ socks[1] = in_sock->ops->accept(in_sock);
if (!socks[1]) {
ret = -1;
goto end;
struct lttcomm_sock *socks[2] = { listening_sock, NULL };
struct lttcomm_sock *new_sock = NULL;
- ret = fd_tracker_open_unsuspendable_fd(
+ ret = fd_tracker_open_unsuspendable_fd(
the_fd_tracker, &out_fd,
(const char **) &name,
1, accept_sock, &socks);
newsock = accept_relayd_sock(data_sock,
"Data socket to relayd");
} else {
- assert(pollfd == control_sock->fd);
+ LTTNG_ASSERT(pollfd == control_sock->fd);
type = RELAY_CONTROL;
newsock = accept_relayd_sock(control_sock,
"Control socket to relayd");
ret = -1;
goto send_reply;
}
- assert(!conn->session);
+ LTTNG_ASSERT(!conn->session);
conn->session = session;
DBG("Created session %" PRIu64, session->id);
} else if (conn->minor >= 4 && conn->minor < 11) {
char *group_by_session_path_name;
- assert(session->session_name[0] != '\0');
+ LTTNG_ASSERT(session->session_name[0] != '\0');
group_by_session_path_name =
backward_compat_group_by_session(
path_name,
- session->session_name);
+ session->session_name,
+ session->creation_time.value);
if (!group_by_session_path_name) {
ERR("Failed to apply group by session to stream of session %" PRIu64,
session->id);
packet_view = lttng_buffer_view_from_view(payload,
sizeof(metadata_payload_header), metadata_payload_size);
- if (!packet_view.data) {
+ if (!lttng_buffer_view_is_valid(&packet_view)) {
ERR("Invalid metadata packet length announced by header");
ret = -1;
goto end_put;
struct lttcomm_relayd_generic_reply reply;
struct relay_stream *stream;
- assert(recv_hdr);
- assert(conn);
+ LTTNG_ASSERT(recv_hdr);
+ LTTNG_ASSERT(conn);
DBG("Init streams for data pending");
struct relay_stream *stream;
size_t msg_len;
- assert(conn);
+ LTTNG_ASSERT(conn);
DBG("Relay receiving index");
ssize_t send_ret;
struct lttcomm_relayd_generic_reply reply;
- assert(conn);
+ LTTNG_ASSERT(conn);
DBG("Relay receiving streams_sent");
struct lttcomm_relayd_create_trace_chunk *msg;
struct lttcomm_relayd_generic_reply reply = {};
struct lttng_buffer_view header_view;
- struct lttng_buffer_view chunk_name_view;
struct lttng_trace_chunk *chunk = NULL, *published_chunk = NULL;
enum lttng_error_code reply_code = LTTNG_OK;
enum lttng_trace_chunk_status chunk_status;
}
header_view = lttng_buffer_view_from_view(payload, 0, sizeof(*msg));
- if (!header_view.data) {
+ if (!lttng_buffer_view_is_valid(&header_view)) {
ERR("Failed to receive payload of chunk creation command");
ret = -1;
goto end_no_reply;
if (msg->override_name_length) {
const char *name;
+ const struct lttng_buffer_view chunk_name_view =
+ lttng_buffer_view_from_view(payload,
+ sizeof(*msg),
+ msg->override_name_length);
+
+ if (!lttng_buffer_view_is_valid(&chunk_name_view)) {
+ ERR("Invalid payload of chunk creation command (protocol error): buffer too short for expected name length");
+ ret = -1;
+ reply_code = LTTNG_ERR_INVALID;
+ goto end;
+ }
- chunk_name_view = lttng_buffer_view_from_view(payload,
- sizeof(*msg),
- msg->override_name_length);
name = chunk_name_view.data;
- if (!name || name[msg->override_name_length - 1]) {
- ERR("Failed to receive payload of chunk creation command");
+ if (name[msg->override_name_length - 1]) {
+ ERR("Invalid payload of chunk creation command (protocol error): name is not null-terminated");
ret = -1;
reply_code = LTTNG_ERR_INVALID;
goto end;
goto end;
}
- assert(conn->session->output_directory);
+ LTTNG_ASSERT(conn->session->output_directory);
chunk_status = lttng_trace_chunk_set_as_owner(chunk,
conn->session->output_directory);
if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
}
header_view = lttng_buffer_view_from_view(payload, 0, sizeof(*msg));
- if (!header_view.data) {
+ if (!lttng_buffer_view_is_valid(&header_view)) {
ERR("Failed to receive payload of chunk close command");
ret = -1;
goto end_no_reply;
bool chunk_exists;
if (!session || !conn->version_check_done) {
- ERR("Trying to close a trace chunk before version check");
+ ERR("Trying to check for the existance of a trace chunk before version check");
ret = -1;
goto end_no_reply;
}
if (session->major == 2 && session->minor < 11) {
- ERR("Chunk close command is unsupported before 2.11");
+ ERR("Chunk exists command is unsupported before 2.11");
ret = -1;
goto end_no_reply;
}
header_view = lttng_buffer_view_from_view(payload, 0, sizeof(*msg));
- if (!header_view.data) {
- ERR("Failed to receive payload of chunk close command");
+ if (!lttng_buffer_view_is_valid(&header_view)) {
+ ERR("Failed to receive payload of chunk exists command");
ret = -1;
goto end_no_reply;
}
uint64_t result_flags = 0;
header_view = lttng_buffer_view_from_view(payload, 0, sizeof(*msg));
- if (!header_view.data) {
+ if (!lttng_buffer_view_is_valid(&header_view)) {
ERR("Failed to receive payload of chunk close command");
ret = -1;
goto end_no_reply;
goto end;
}
- assert(ret > 0);
- assert(ret <= state->left_to_receive);
+ LTTNG_ASSERT(ret > 0);
+ LTTNG_ASSERT(ret <= state->left_to_receive);
state->left_to_receive -= ret;
state->received += ret;
struct ctrl_connection_state_receive_header *state =
&conn->protocol.ctrl.state.receive_header;
- assert(state->left_to_receive != 0);
+ LTTNG_ASSERT(state->left_to_receive != 0);
ret = conn->sock->ops->recvmsg(conn->sock,
reception_buffer->data + state->received,
goto end;
}
- assert(ret > 0);
- assert(ret <= state->left_to_receive);
+ LTTNG_ASSERT(ret > 0);
+ LTTNG_ASSERT(ret <= state->left_to_receive);
state->left_to_receive -= ret;
state->received += ret;
struct lttcomm_relayd_data_hdr header;
struct relay_stream *stream;
- assert(state->left_to_receive != 0);
+ LTTNG_ASSERT(state->left_to_receive != 0);
ret = conn->sock->ops->recvmsg(conn->sock,
state->header_reception_buffer + state->received,
goto end;
}
- assert(ret > 0);
- assert(ret <= state->left_to_receive);
+ LTTNG_ASSERT(ret > 0);
+ LTTNG_ASSERT(ret <= state->left_to_receive);
state->left_to_receive -= ret;
state->received += ret;
packet_chunk = lttng_buffer_view_init(data_buffer,
0, recv_size);
- assert(packet_chunk.data);
+ LTTNG_ASSERT(packet_chunk.data);
ret = stream_write(stream, &packet_chunk, 0);
if (ret) {
ctrl_conn = connection_get_by_sock(relay_connections_ht, pollfd);
/* If not found, there is a synchronization issue. */
- assert(ctrl_conn);
+ LTTNG_ASSERT(ctrl_conn);
if (ctrl_conn->type == RELAY_DATA) {
if (revents & LPOLLIN) {
}
goto put_ctrl_connection;
}
- assert(ctrl_conn->type == RELAY_CONTROL);
+ LTTNG_ASSERT(ctrl_conn->type == RELAY_CONTROL);
if (revents & LPOLLIN) {
enum relay_connection_status status;
if (data_conn->type == RELAY_CONTROL) {
goto put_data_connection;
}
- assert(data_conn->type == RELAY_DATA);
+ LTTNG_ASSERT(data_conn->type == RELAY_DATA);
if (revents & LPOLLIN) {
enum relay_connection_status status;
projects / lttng-tools.git / blobdiff