/*
* Send lttcomm_session_msg to the session daemon.
*
* On success, returns the number of bytes sent (>=0)
* On error, returns -1
*/
static int send_session_msg(struct lttcomm_session_msg *lsm)
{
int ret;
if (!connected) {
ret = -LTTNG_ERR_NO_SESSIOND;
goto end;
}
DBG("LSM cmd type : %d", lsm->cmd_type);
ret = lttcomm_send_creds_unix_sock(sessiond_socket, lsm,
sizeof(struct lttcomm_session_msg));
if (ret < 0) {
ret = -LTTNG_ERR_FATAL;
}
end:
return ret;
}
static
int handshake(struct lttng_notification_channel *channel)
{
ssize_t ret;
enum lttng_notification_channel_status status =
LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
struct lttng_notification_channel_command_handshake handshake = {
.major = LTTNG_NOTIFICATION_CHANNEL_VERSION_MAJOR,
.minor = LTTNG_NOTIFICATION_CHANNEL_VERSION_MINOR,
};
struct lttng_notification_channel_message msg_header = {
.type = LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_HANDSHAKE,
.size = sizeof(handshake),
};
char send_buffer[sizeof(msg_header) + sizeof(handshake)];
memcpy(send_buffer, &msg_header, sizeof(msg_header));
memcpy(send_buffer + sizeof(msg_header), &handshake, sizeof(handshake));
pthread_mutex_lock(&channel->lock);
ret = lttcomm_send_creds_unix_sock(channel->socket, send_buffer,
sizeof(send_buffer));
if (ret < 0) {
goto end_unlock;
}
/* Receive handshake info from the sessiond. */
ret = receive_command_reply(channel, &status);
if (ret < 0) {
goto end_unlock;
}
if (!channel->version.set) {
ret = -1;
goto end_unlock;
}
if (channel->version.major != LTTNG_NOTIFICATION_CHANNEL_VERSION_MAJOR) {
ret = -1;
goto end_unlock;
}
end_unlock:
pthread_mutex_unlock(&channel->lock);
return ret;
}
static
enum lttng_notification_channel_status send_condition_command(
struct lttng_notification_channel *channel,
enum lttng_notification_channel_message_type type,
const struct lttng_condition *condition)
{
int socket;
ssize_t command_size, ret;
enum lttng_notification_channel_status status =
LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
char *command_buffer = NULL;
struct lttng_notification_channel_message cmd_message = {
.type = type,
};
if (!channel) {
status = LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID;
goto end;
}
assert(type == LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_SUBSCRIBE ||
type == LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_UNSUBSCRIBE);
pthread_mutex_lock(&channel->lock);
socket = channel->socket;
if (!lttng_condition_validate(condition)) {
status = LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID;
goto end_unlock;
}
ret = lttng_condition_serialize(condition, NULL);
if (ret < 0) {
status = LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID;
goto end_unlock;
}
assert(ret < UINT32_MAX);
cmd_message.size = (uint32_t) ret;
command_size = ret + sizeof(
struct lttng_notification_channel_message);
command_buffer = zmalloc(command_size);
if (!command_buffer) {
goto end_unlock;
}
memcpy(command_buffer, &cmd_message, sizeof(cmd_message));
ret = lttng_condition_serialize(condition,
command_buffer + sizeof(cmd_message));
if (ret < 0) {
goto end_unlock;
}
ret = lttcomm_send_unix_sock(socket, command_buffer, command_size);
if (ret < 0) {
status = LTTNG_NOTIFICATION_CHANNEL_STATUS_ERROR;
goto end_unlock;
}
ret = receive_command_reply(channel, &status);
if (ret < 0) {
status = LTTNG_NOTIFICATION_CHANNEL_STATUS_ERROR;
goto end_unlock;
}
end_unlock:
pthread_mutex_unlock(&channel->lock);
end:
free(command_buffer);
return status;
}
