path: root/client/src/muse_client.c

/*
 * muse-client
 *
 * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: YoungHun Kim <yh8004.kim@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "muse_client.h"
#include "muse_core_internal.h"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MUSED_CLIENT"

GMutex g_muse_client_mutex;
GHashTable *g_muse_client_table;
int g_muse_client_table_id;

const char *UDS_files[MUSE_CHANNEL_MAX] = {MUSE_SOCK_FILE0, MUSE_SOCK_FILE1};

#ifdef MUSE_USE_CLIENT_SIGHANDLER
/* signal handler */
struct sigaction muse_client_int_old_action;
struct sigaction muse_client_abrt_old_action;
struct sigaction muse_client_segv_old_action;
struct sigaction muse_client_term_old_action;
struct sigaction muse_client_sys_old_action;

static gboolean _muse_client_table_remove_func(gpointer key, gpointer value, gpointer user_data);
static void _muse_client_sigaction(int signo, siginfo_t *siginfo, void *context);
static void _muse_client_constructor(void) __attribute__((constructor));
#endif

static int _muse_client_new(muse_channel_e channel);
static void _muse_client_table_new(void);
static gpointer _muse_client_get_fd_ptr(int sock_fd);

#ifdef MUSE_USE_CLIENT_SIGHANDLER
static gboolean _muse_client_table_remove_func(gpointer key, gpointer value, gpointer user_data)
{
	int sock_fd = GPOINTER_TO_INT(key);

	LOGW("close muse connection fd %d", sock_fd);

	muse_core_connection_close(sock_fd);

	return TRUE;
}

static void _muse_client_sigaction(int signo, siginfo_t *siginfo, void *context)
{
	struct sigaction *old_action = NULL;
	pid_t my_pid = getpid();

	LOGE("Enter - signo [%d], pid [%d]", signo, my_pid);

	/* close all opened fds */
	g_mutex_lock(&g_muse_client_mutex);

	g_hash_table_foreach_remove(g_muse_client_table, _muse_client_table_remove_func, NULL);

	g_mutex_unlock(&g_muse_client_mutex);

	/* call old signal handler */
	switch (signo) {
	case SIGINT:
		old_action = &muse_client_int_old_action;
		break;
	case SIGABRT:
		old_action = &muse_client_abrt_old_action;
		break;
	case SIGSEGV:
		old_action = &muse_client_segv_old_action;
		break;
	case SIGTERM:
		old_action = &muse_client_term_old_action;
		break;
	case SIGSYS:
		old_action = &muse_client_sys_old_action;
		break;
	default:
		LOGE("unhandled signal %d", signo);
		return;
	}

	if (old_action->sa_sigaction)
		old_action->sa_sigaction(signo, siginfo, context);
	else
		sigaction(signo, old_action, NULL);

	LOGE("Leave");

	return;
}

static void _muse_client_constructor(void)
{
	struct sigaction muse_client_action;
	muse_client_action.sa_sigaction = _muse_client_sigaction;
	muse_client_action.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;

	LOGI("Enter");

	sigemptyset(&muse_client_action.sa_mask);

	sigaction(SIGINT, &muse_client_action, &muse_client_int_old_action);
	sigaction(SIGABRT, &muse_client_action, &muse_client_abrt_old_action);
	sigaction(SIGSEGV, &muse_client_action, &muse_client_segv_old_action);
	sigaction(SIGTERM, &muse_client_action, &muse_client_term_old_action);
	sigaction(SIGSYS, &muse_client_action, &muse_client_sys_old_action);

	LOGI("Leave");

	return;
}
#endif

static int _muse_client_new(muse_channel_e channel)
{
	struct sockaddr_un address;
	int len, ret = MUSE_ERR;
	int sockfd;
	char err_msg[MUSE_MAX_MSG_LEN] = {'\0',};

	LOGI("Enter");
	g_return_val_if_fail(channel < MUSE_CHANNEL_MAX, MM_ERROR_INVALID_ARGUMENT);

	/*Create socket*/
	if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
		strerror_r(errno, err_msg, MUSE_MAX_MSG_LEN);
		LOGE("[socket failure] sock: %s", err_msg);
		return ret;
	}
	LOGI("sockfd: %d", sockfd);

	if (fcntl(sockfd, F_SETFD, FD_CLOEXEC) < 0) {
		strerror_r(errno, err_msg, MUSE_MAX_MSG_LEN);
		LOGE("unable to set on ctrls socket fd %d: %s", sockfd, err_msg);
		close(sockfd);
		return ret;
	}
	LOGD("fcntl");

	memset(&address, 0, sizeof(address));
	address.sun_family = AF_UNIX;
	strncpy(address.sun_path, UDS_files[channel], sizeof(address.sun_path));
	len = sizeof(address);

	if (muse_core_set_nonblocking(sockfd, false) != MM_ERROR_NONE)
		LOGE("Error - fd (%d) set blocking", sockfd);

	if ((ret = connect(sockfd, (struct sockaddr *)&address, len)) < 0) {
		strerror_r(errno, err_msg, MUSE_MAX_MSG_LEN);
		LOGE("[Critical Error] connect failure : %s", err_msg);
		close(sockfd);
		return ret;
	}

	g_mutex_lock(&g_muse_client_mutex);

	g_hash_table_insert(g_muse_client_table, GINT_TO_POINTER(sockfd), GINT_TO_POINTER(g_muse_client_table_id++));

	g_mutex_unlock(&g_muse_client_mutex);

	LOGI("Leave");
	return sockfd;
}

static void _muse_client_table_new(void)
{
	g_mutex_lock(&g_muse_client_mutex);

	if (!g_muse_client_table) {
		g_muse_client_table_id = 1;
		g_muse_client_table = g_hash_table_new(g_direct_hash, g_direct_equal);
		LOGD("client table : %p", g_muse_client_table);
	}

	g_mutex_unlock(&g_muse_client_mutex);
}

static gpointer _muse_client_get_fd_ptr(int sock_fd)
{
	g_return_val_if_fail(g_muse_client_table, NULL);

	return g_hash_table_lookup(g_muse_client_table, GINT_TO_POINTER(sock_fd));
}

int muse_client_new(void)
{
	_muse_client_table_new();
	return _muse_client_new(MUSE_CHANNEL_MSG);
}

int muse_client_new_data_ch(void)
{
	return _muse_client_new(MUSE_CHANNEL_DATA);
}

int muse_client_close(int sock_fd)
{
	int ret = MM_ERROR_NONE;

	ret = muse_core_connection_close(sock_fd);
	if (ret != MM_ERROR_NONE) {
		LOGE("close connection failed 0x%x", ret);
		return ret;
	}

	/* remove fd from table */
	g_mutex_lock(&g_muse_client_mutex);

	if (g_hash_table_remove(g_muse_client_table, GINT_TO_POINTER(sock_fd)))
		LOGD("success : remove fd %d from table", sock_fd);
	else
		LOGW("fail : remove fd %d from table[%p]", sock_fd, g_muse_client_table);

	g_mutex_unlock(&g_muse_client_mutex);

	return MM_ERROR_NONE;
}

int muse_client_ipc_push_data(int sock_fd, const char *data, int size, uint64_t data_id)
{
	char err_msg[MUSE_MAX_MSG_LEN] = {'\0',};
	muse_recv_data_head_t header;
	int sended_len = 0;

	g_return_val_if_fail(data, MM_ERROR_INVALID_ARGUMENT);

	header.marker = MUSE_DATA_HEAD;
	header.size = size;
	header.id = data_id;

	LOGD("[%d] header.marker : %x header.size : %d header.id : %"G_GUINT64_FORMAT"",
					sock_fd, header.marker, header.size, header.id);

	if ((sended_len = send(sock_fd, &header, sizeof(muse_recv_data_head_t), 0)) < 0) {
		strerror_r(errno, err_msg, MUSE_MAX_MSG_LEN);
		LOGE("[%d] fail to send msg (%s) %d", sock_fd, err_msg, errno);
	}

	if ((sended_len += send(sock_fd, data, size, 0)) < 0) {
		strerror_r(errno, err_msg, MUSE_MAX_MSG_LEN);
		LOGE("[%d] fail to send msg (%s) %d", sock_fd, err_msg, errno);
	}

	return sended_len;
}

int muse_client_get_fd_id_value(int sock_fd)
{
	gpointer sock_id_ptr = _muse_client_get_fd_ptr(sock_fd);

	g_return_val_if_fail(sock_id_ptr, MUSE_ERR);

	return GPOINTER_TO_INT(sock_id_ptr);
}

bool muse_client_check_fd_id_value(int sock_fd, int sock_id)
{
	gpointer sock_id_ptr = _muse_client_get_fd_ptr(sock_fd);

	g_return_val_if_fail(sock_id_ptr, false);

	if (sock_id == GPOINTER_TO_INT(sock_id_ptr))
		return true;
	else
		return false;
}