path: root/src/monitor/request-handler.c

/*
 * PASS (Power Aware System Service)
 *
 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
 *
 * 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.
 */

/**
 * @file	request-handler.c
 * @brief	TBD
 * @ingroup	TBD
 */

#include <glib.h>

#include <util/common.h>
#include <util/devices.h>
#include <util/log.h>
#include <util/thread.h>
#include <monitor/request.h>
#include <monitor/monitor.h>

#include <libsyscommon/resource-manager.h>
#include <libsyscommon/resource-type.h>
#include <libsyscommon/resource-device.h>

#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <assert.h>
#include <fcntl.h>

#include <systemd/sd-daemon.h>

#define PENDING_MAX 3
#define REQUEST_SERVER_PORT 10001

struct request_client {
	int socket_fd;
	int nr_resources;
	struct thread *worker;
	GHashTable *resource_table;
};

struct resource_instance {
	int id;
	struct syscommon_resman_resource *res;

	int64_t ts_start;
	int64_t ts_end;
};

static int g_resource_id;
static bool g_request_server_run;
static struct thread *g_server_thread;

static void
register_resource_to_client(struct request_client *client, struct resource_instance *res_inst)
{
	g_hash_table_insert(client->resource_table,
					GINT_TO_POINTER(res_inst->id),
					(gpointer)res_inst);
}

static void
unregister_resource_from_client(struct request_client *client, int resource_id)
{
	g_hash_table_remove(client->resource_table, GINT_TO_POINTER(resource_id));
}

static struct resource_instance *
get_resource_instance_by_id(struct request_client *client, int resource_id)
{
	return g_hash_table_lookup(client->resource_table, GINT_TO_POINTER(resource_id));
}

static struct syscommon_resman_resource *
get_resource_by_id(struct request_client *client, int resource_id)
{
	struct resource_instance *res_inst = get_resource_instance_by_id(client, resource_id);

	res_inst = get_resource_instance_by_id(client, resource_id);
	if (!res_inst)
		return NULL;

	return res_inst->res;
}

static int clear_sign_bit(unsigned int val)
{
	return (int)((val << 1) >> 1);
}

static int handle_request_create_resource(struct request_client *client, char *args)
{
	struct resource_instance *res_inst;
	int resource_type, ret;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	res_inst = calloc(1, sizeof(struct resource_instance));
	if (!res_inst)
		return -ENOMEM;

	/**
	 * Format of REQUEST_CREATE_RESOURCE args:
	 *  - <RESOURCE_TYPE>
	 */
	resource_type = atoi(args);

	ret = syscommon_resman_create_resource(&res_inst->res, resource_type);
	if (ret < 0) {
		_E("failed to create resource, res:type(%d)\n", resource_type);
		free(res_inst);
		return ret;
	}

	res_inst->id = clear_sign_bit(
			(unsigned int)__sync_fetch_and_add(&g_resource_id, 1));

	register_resource_to_client(client, res_inst);

	return res_inst->id;
}

static int handle_request_delete_resource(struct request_client *client, char *args)
{
	int resource_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_DELETE_RESOURCE args:
	 *  - <RESOURCE_ID>
	 */
	resource_id = atoi(args);

	unregister_resource_from_client(client, resource_id);

	return 0;
}

inline __attribute__((always_inline)) int64_t get_time_now(void)
{
	struct timeval tv;

	gettimeofday(&tv, NULL);
	return (int64_t)tv.tv_sec * 1000000 + (int64_t)tv.tv_usec;
}

static int handle_request_update_resource(struct request_client *client, char *args)
{
	struct resource_instance *res_inst;
	struct syscommon_resman_resource *res;
	int resource_id;
	int ret;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_UPDATE_RESOURCE args:
	 *  - <RESOURCE_ID>
	 */
	resource_id = atoi(args);

	res_inst = get_resource_instance_by_id(client, resource_id);
	if (!res_inst) {
		_E("failed to get resource instance, res:id(%d)\n", resource_id);
		return -EINVAL;
	}

	res = res_inst->res;

	res_inst->ts_start = get_time_now();
	ret = syscommon_resman_update_resource_attrs(res);
	res_inst->ts_end = get_time_now();
	if (ret < 0) {
		res_inst->ts_start = res_inst->ts_end = 0;
		_E("failed to update resource attributes, res:name(%s)id(%d)\n",
				syscommon_resman_get_resource_name(res), resource_id);
		return ret;
	}

	return 0;
}

static int syscommon_resman_get_resource_count(int resource_type)
{
	const struct syscommon_resman_resource_driver *driver;
	int count = syscommon_resman_get_resource_device_count(resource_type);

	if (count > 0)
		return count;

	driver = syscommon_resman_find_resource_driver(resource_type);
	if (!driver)
		return -EINVAL;

	if (driver->flag & SYSCOMMON_RESMAN_RESOURCE_DRIVER_FLAG_COUNT_ONLY_ONE)
		return 1;
	else if (driver->flag & SYSCOMMON_RESMAN_RESOURCE_DRIVER_FLAG_UNCOUNTABLE)
		return -EINVAL;

	return 0;
}

static int handle_request_get_resource_count(struct request_client *client, char *args, int *value)
{
	int resource_type;
	int ret;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_RESOURCE_COUNT args:
	 *  - <RESOURCE_TYPE>
	 */
	resource_type = atoi(args);

	ret = syscommon_resman_get_resource_count(resource_type);
	if (ret < 0) {
		_E("failed to get resource device count, res:type(%d)\n", resource_type);
		return ret;
	}
	*value = ret;

	return 0;
}

static void update_resource(gpointer key, gpointer value, gpointer user_data)
{
	struct resource_instance *res_inst = value;
	struct syscommon_resman_resource *res = res_inst->res;
	int ret;

	ret = syscommon_resman_update_resource_attrs(res);
	if (ret < 0)
		_E("failed to update resource attributes (name:%s,id:%d)\n",
				syscommon_resman_get_resource_name(res), res_inst->id);
}


static int handle_request_update_resource_all(struct request_client *client, char *args)
{
	if (!client) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_UPDATE_RESOURCE args:
	 *  - NULL
	 */
	if (client->resource_table)
		g_hash_table_foreach(client->resource_table, (GHFunc)update_resource, NULL);

	return 0;
}

static int handle_request_set_resource_attr(struct request_client *client, char *args, int request_type)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t interest_masks;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_SET_RESOURCE_ATTR and REQUEST_UNSET_RESOURCE_ATTR args:
	 *  - <RESOURCE_ID:INTEREST_MASK>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &interest_masks) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
					client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
					client->socket_fd, resource_id);
		return -EINVAL;
	}

	switch (request_type) {
	case REQUEST_SET_RESOURCE_ATTR:
		ret = syscommon_resman_set_resource_attr_interest(res, interest_masks);
		if (ret < 0)
			_E("failed to set attribute interest, client(%d) | res:name(%s)id(%d)\n",
					client->socket_fd,
					syscommon_resman_get_resource_name(res), resource_id);
		break;
	case REQUEST_UNSET_RESOURCE_ATTR:
		ret = syscommon_resman_unset_resource_attr_interest(res, interest_masks);
		if (ret < 0)
			_E("failed to unset attribute interest, client(%d) | res:name(%s)id(%d)\n",
					client->socket_fd,
					syscommon_resman_get_resource_name(res), resource_id);
		break;
	case REQUEST_IS_RESOURCE_ATTR_SET:
		ret = (int)syscommon_resman_is_resource_attr_interested(res, interest_masks);
		break;
	default:
		return -EINVAL;
	}

	return ret;
}

static int handle_request_set_resource_flag(struct request_client *client, char *args)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t flag_mask;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_SET_RESOURCE_ATTR and REQUEST_UNSET_RESOURCE_ATTR args:
	 *  - <RESOURCE_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &flag_mask) < 2) {
		_E("failed to get resource and flag mask, client(%d)\n",
					client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
					client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_set_resource_flag(res, flag_mask);
	if (ret < 0) {
		_E("failed to set flag to %"PRIu64", client(%d) | res:name(%s)id(%d)\n",
					flag_mask, client->socket_fd,
					syscommon_resman_get_resource_name(res), resource_id);
		return ret;
	}

	return 0;
}

static int handle_request_is_resource_attr_supported(struct request_client *client, char *args, bool *supported)
{
	struct resource *res;
	int resource_id;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_IS_RESOURCE_ATTR_SUPPORTED args:
	 *  - <RESOURCE_ID:RESOURCE_ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64"", &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
					client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
					client->socket_fd, resource_id);
		return -EINVAL;
	}

	return syscommon_resman_is_resource_attr_supported(res, attr_id, supported);
}

static int handle_request_set_resource_ctrl(struct request_client *client, char *args)
{
	struct syscommon_resman_resource *res;
	int resource_id, value, ret;
	u_int64_t ctrl_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_SET_RESOURCE_CTRL args:
	 *  - <RESOURCE_ID:CONTROL_ID:CONTROL_VALUE>
	 */
	if (sscanf(args, "%d$%"PRIu64"$%d", &resource_id, &ctrl_id, &value) < 3) {
		_E("failed to get resource and control id, client(%d)\n",
					client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
					client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_set_resource_control(res, ctrl_id, (void *)(intptr_t)value);
	if (ret < 0) {
		_E("failed to set resource control, client(%d) | res:name(%s)id(%d) | ctrl:name(%s)id(%"PRId64")val(%d)\n",
					client->socket_fd,
					syscommon_resman_get_resource_name(res), resource_id,
					syscommon_resman_get_resource_control_name(res, ctrl_id), ctrl_id, value);
		return ret;
	}

	return 0;
}

static int
handle_request_get_json(struct request_client *client, char *args,
				 int request_type, char **json_string)
{
	struct syscommon_resman_resource *res;
	u_int64_t attr_id;
	int resource_id;

	if (!client) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_RESOURCE_JSON args:
	 *  - <RESOURCE_ID>
	 * Format of REQUEST_GET_VALUE_JSON args:
	 *  - <RESOURCE_ID>:<ATTR_ID>
	 * Format of REQUEST_GET_RESOURCE_LIST_JSON args:
	 *  - NO ARGUMENTS
	 */
	switch (request_type) {
	case REQUEST_GET_RESOURCE_JSON:
		resource_id = atoi(args);
		break;
	case REQUEST_GET_VALUE_JSON:
		if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2)
			return -EINVAL;
		break;
	case REQUEST_GET_RESOURCE_LIST_JSON:
		goto skip_res;
	default:
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, res:id(%d)\n", resource_id);
		return -EINVAL;
	}

skip_res:
	switch (request_type) {
	case REQUEST_GET_RESOURCE_JSON:
		return syscommon_resman_get_resource_attrs_json(res, json_string);
	case REQUEST_GET_VALUE_JSON:
		return syscommon_resman_get_resource_attr_json(res, attr_id, json_string);
	case REQUEST_GET_RESOURCE_LIST_JSON:
		return syscommon_resman_get_resource_list_json(json_string);
	default:
		return -EINVAL;
	}
}

static int handle_request_get_value_int(struct request_client *client, char *args, int32_t *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_INT args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
					client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
					client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_int(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get int value, client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int handle_request_get_value_int64(struct request_client *client, char *args, int64_t *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_INT64 args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_int64(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get int64 value, client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int
handle_request_get_value_uint(struct request_client *client, char *args, u_int32_t *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_UINT args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_uint(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get uint value, client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int
handle_request_get_value_uint64(struct request_client *client, char *args, u_int64_t *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_UINT64 args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_uint64(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get uint64 value, client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int handle_request_get_value_double(struct request_client *client, char *args, double *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_DOUBLE args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_double(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get double value,  client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int handle_request_get_value_string(struct request_client *client, char *args, char *value)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_INT args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_string(res, attr_id, value);
	if (ret < 0) {
		_E("failed to get string value, client(%d) | res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int
handle_request_get_value_array(struct request_client *client, char *args, struct syscommon_resman_array_value **arr)
{
	struct syscommon_resman_resource *res;
	int resource_id, ret;
	u_int64_t attr_id;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_VALUE_ARRAY args:
	 *  - <RESOURCE_ID:ATTR_ID>
	 */
	if (sscanf(args, "%d$%"PRIu64, &resource_id, &attr_id) < 2) {
		_E("failed to get resource and attribute id, client(%d)\n",
				client->socket_fd);
		return -EINVAL;
	}

	res = get_resource_by_id(client, resource_id);
	if (!res) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_attr_array(res, attr_id, arr);
	if (ret < 0) {
		_E("failed to get array value, client(%d) | (res:name(%s)id(%d) | attr:name(%s)id(%"PRId64")\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res), resource_id,
				syscommon_resman_get_resource_attr_name(res, attr_id), attr_id);
		return ret;
	}

	return 0;
}

static int syscommon_resman_get_resource_ts(struct resource_instance *inst, int64_t *ts_start, int64_t *ts_end)
{
	if (!inst)
		return -EINVAL;

	*ts_start = inst->ts_start;
	*ts_end = inst->ts_end;

	return 0;
}

static int
handle_request_get_resource_ts(struct request_client *client, char *args,
			       int64_t *start, int64_t *end)
{
	struct resource_instance *res_inst;
	int resource_id, ret;

	if (!client || !args) {
		_E("Invalid parameter\n");
		return -ENOENT;
	}

	/**
	 * Format of REQUEST_GET_RESOURCE_TS args:
	 *  - <RESOURCE_ID>
	 */
	resource_id = atoi(args);

	res_inst = get_resource_by_id(client, resource_id);
	if (!res_inst) {
		_E("failed to get resource, client(%d) | res:id(%d)\n",
				client->socket_fd, resource_id);
		return -EINVAL;
	}

	ret = syscommon_resman_get_resource_ts(res_inst, start, end);
	if (ret < 0) {
		_E("failed to get timestamp value, client(%d) | res:name(%s)id(%d)\n",
				client->socket_fd,
				syscommon_resman_get_resource_name(res_inst->res), resource_id);
		return ret;
	}

	return 0;
}

static int split_request_type_and_args(char *buffer, char **args)
{
	char *request_type_str;

	request_type_str = strsep(&buffer, "$");

	*args = buffer;

	return atoi(request_type_str);
}

#define ADD_RESPONSE(__buf__, __remain__, __format__, ...)	{ \
	int __len__ = snprintf(__buf__, __remain__, __format__, __VA_ARGS__); \
	__buf__ += __len__;  \
	__remain__ -= __len__; \
	if (__remain__ < 0) \
		_E("failed to add response"); \
} \

static int handle_request(struct request_client *client, char *request)
{
	char *response, *response_entry, *args;
	int request_type, buffer_len, ret;
	char err_buf[BUFF_MAX];

	request_type = split_request_type_and_args(request, &args);

	switch (request_type) {
	case REQUEST_GET_RESOURCE_JSON:
	case REQUEST_GET_VALUE_JSON:
	case REQUEST_GET_VALUE_ARRAY:
	case REQUEST_GET_RESOURCE_LIST_JSON:
		buffer_len = HUGE_BUFF_MAX + 1;
		break;
	default:
		buffer_len = GENERIC_BUFF_MAX + 1;
	}

	response_entry = response = malloc(buffer_len);
	if (!response_entry)
		return -ENOMEM;

	/**
	 * Format of response
	 *  - <REQUEST_TYPE[:REQUEST_RESULT_PAYLOAD]:REQUEST_RESULT_VALUE>
	 */
	ADD_RESPONSE(response, buffer_len, "%d$", request_type);

	switch (request_type) {
	case REQUEST_CREATE_RESOURCE:
		ret = handle_request_create_resource(client, args);
		break;
	case REQUEST_DELETE_RESOURCE:
		ret = handle_request_delete_resource(client, args);
		break;
	case REQUEST_UPDATE_RESOURCE:
		ret = handle_request_update_resource(client, args);
		break;
	case REQUEST_SET_RESOURCE_FLAG:
		ret = handle_request_set_resource_flag(client, args);
		break;
	case REQUEST_GET_RESOURCE_COUNT:
		{
			int32_t value;

			ret = handle_request_get_resource_count(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%d$", value);
		}
		break;
	case REQUEST_UPDATE_RESOURCE_ALL:
		ret = handle_request_update_resource_all(client, args);
		break;
	case REQUEST_SET_RESOURCE_CTRL:
		ret = handle_request_set_resource_ctrl(client, args);
		break;
	case REQUEST_SET_RESOURCE_ATTR:
	case REQUEST_UNSET_RESOURCE_ATTR:
	case REQUEST_IS_RESOURCE_ATTR_SET:
		ret = handle_request_set_resource_attr(client, args, request_type);
		break;
	case REQUEST_IS_RESOURCE_ATTR_SUPPORTED:
		{
			bool supported;

			ret = handle_request_is_resource_attr_supported(client, args, &supported);

			ADD_RESPONSE(response, buffer_len, "%u$", (u_int32_t)supported);
		}
		break;
	case REQUEST_GET_RESOURCE_JSON:
	case REQUEST_GET_VALUE_JSON:
	case REQUEST_GET_RESOURCE_LIST_JSON:
		{
			char *json_string;

			ret = handle_request_get_json(client, args, request_type, &json_string);

			ADD_RESPONSE(response, buffer_len, "%s$", json_string);

			free(json_string);
		}
		break;
	case REQUEST_GET_VALUE_INT:
		{
			int32_t value;

			ret = handle_request_get_value_int(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%d$", value);
		}
		break;
	case REQUEST_GET_VALUE_INT64:
		{
			int64_t value;

			ret = handle_request_get_value_int64(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%"PRId64"$", value);
		}
		break;
	case REQUEST_GET_VALUE_UINT:
		{
			u_int32_t value;

			ret = handle_request_get_value_uint(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%u$", value);
		}
		break;
	case REQUEST_GET_VALUE_UINT64:
		{
			u_int64_t value;

			ret = handle_request_get_value_uint64(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%"PRIu64"$", value);
		}
		break;
	case REQUEST_GET_VALUE_DOUBLE:
		{
			double value;

			ret = handle_request_get_value_double(client, args, &value);

			ADD_RESPONSE(response, buffer_len, "%lf$", value);
		}
		break;
	case REQUEST_GET_VALUE_STRING:
		{
			char value[BUFF_MAX];

			ret = handle_request_get_value_string(client, args, value);

			ADD_RESPONSE(response, buffer_len, "%s$", value);
		}
		break;
	case REQUEST_GET_VALUE_ARRAY:
		{
			struct syscommon_resman_array_value *array;
			int i;

			ret = handle_request_get_value_array(client, args, &array);

			if (array->length == 0) {
				ADD_RESPONSE(response, buffer_len, "%d|%d|$",
						array->type, array->length);
				break;
			}

			ADD_RESPONSE(response, buffer_len, "%d|%d|", array->type, array->length);

			switch (array->type) {
			case SYSCOMMON_RESMAN_DATA_TYPE_INT:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%d,",
							((int32_t *)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%d$",
						((int32_t *)array->data)[i]);
				break;
			case SYSCOMMON_RESMAN_DATA_TYPE_INT64:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%"PRId64",",
							((int64_t *)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%"PRId64"$",
						((int64_t *)array->data)[i]);
				break;
			case SYSCOMMON_RESMAN_DATA_TYPE_UINT:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%u,",
							((u_int32_t *)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%u$",
						((u_int32_t *)array->data)[i]);
				break;
			case SYSCOMMON_RESMAN_DATA_TYPE_UINT64:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%"PRIu64",",
							((u_int64_t *)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%"PRIu64"$",
						((u_int64_t *)array->data)[i]);
				break;
			case SYSCOMMON_RESMAN_DATA_TYPE_DOUBLE:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%lf,",
							((double *)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%lf$",
						((double *)array->data)[i]);
				break;
			case SYSCOMMON_RESMAN_DATA_TYPE_STRING:
				for (i = 0; i < array->length - 1; i++)
					ADD_RESPONSE(response, buffer_len, "%s,",
							((char **)array->data)[i]);
				ADD_RESPONSE(response, buffer_len, "%s$",
						((char **)array->data)[i]);
				break;
			default:
				_E("Not supported data type");
			}
		}
		break;
	case REQUEST_GET_RESOURCE_TS:
		{
			int64_t start, end;

			ret = handle_request_get_resource_ts(client, args, &start, &end);

			ADD_RESPONSE(response, buffer_len, "%"PRId64"$%"PRId64"$", start, end);
		}
		break;
	default:
		_E("Invliad request type: %d", request_type);
		ret = -EINVAL;
		break;
	}
	ADD_RESPONSE(response, buffer_len, "%d", ret);

	if (send(client->socket_fd, response_entry, strlen(response_entry), 0) < 0) {
		strerror_r(errno, err_buf, BUFF_MAX);
		_E("Failed to send respones, errno: %d, error: %s", errno, err_buf);
	}

	free(response_entry);

	return 0;
}

static GList *g_request_client_head;
static GMutex g_server_lock;

static void add_client_to_list(struct request_client *client)
{
	if (!client)
		return;

	g_mutex_lock(&g_server_lock);
	g_request_client_head =
			g_list_append(g_request_client_head, (gpointer)client);
	g_mutex_unlock(&g_server_lock);
}

static void remove_client_from_list(struct request_client *client)
{
	if (!client)
		return;

	g_mutex_lock(&g_server_lock);
	g_request_client_head =
			g_list_remove(g_request_client_head, (gpointer)client);
	g_mutex_unlock(&g_server_lock);
}

static void destroy_request_client(struct request_client *client)
{
	remove_client_from_list(client);
	free(client);
}

static int request_handler_func(void *data, void **result)
{
	char request[GENERIC_BUFF_MAX + 1];
	struct request_client *client = (struct request_client *)data;
	int len, ret;
	char err_buf[BUFF_MAX];

	_D("Client-%d is connected", client->socket_fd);

	while (1) {
		len = recv(client->socket_fd, request, GENERIC_BUFF_MAX, 0);
		if (len == 0)
			break;

		if (len < 0) {
			strerror_r(errno, err_buf, BUFF_MAX);
			_E("Error occurs while receiving request: errno: %d, error: %s",
					errno, err_buf);
			break;
		}

		request[len] = '\0';
		ret = handle_request(client, request);
		if (ret < 0)
			break;
	}

	_D("Client-%d is disconnected", client->socket_fd);
	g_hash_table_destroy(client->resource_table);
	close(client->socket_fd);
	destroy_request_client(client);

	return THREAD_RETURN_DONE;
}

static void delete_resource_instance(struct resource_instance *res_inst)
{
	if (!res_inst)
		return;

	syscommon_resman_delete_resource(res_inst->res);

	free(res_inst);
}

static int create_request_client(int socket_fd)
{
	struct request_client *client;

	client = malloc(sizeof(struct request_client));
	if (!client) {
		_E("Failed to allocate memory of request_client");
		return -ENOMEM;
	}

	client->socket_fd = socket_fd;
	client->resource_table =
		g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL,
				      (GDestroyNotify)delete_resource_instance);

	create_daemon_thread(&client->worker, request_handler_func, client);

	add_client_to_list(client);

	return 0;
}

static int init_unix_socket(int *sock, struct sockaddr_un *address, int *addrlen)
{
	const char *server_unix_socket_path = "/run/.pass-resource-monitor.socket";
	int opt = true;
	int n = sd_listen_fds(0);
	int fd;
	int file_mode;

	if (!sock || !address || !addrlen)
		return -EINVAL;

	bzero(address, sizeof(*address));
	address->sun_family = AF_UNIX;
	strncpy(address->sun_path, server_unix_socket_path, sizeof(address->sun_path));
	address->sun_path[sizeof(address->sun_path) - 1] = '\0';

	/* use the existing systemd unix socket */
	if (n > 0) {
		for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
			if (sd_is_socket_unix(fd, SOCK_STREAM, 1, server_unix_socket_path, 0) > 0) {
				*sock = fd;
				*addrlen = sizeof(*address);
				return 0;
			}
		}
	}

	/* make a new unix socket */
	*sock = socket(AF_UNIX, SOCK_STREAM, 0);
	if (*sock < 0) {
		_E("Failed to initialize socket");
		goto error_out;
	}

	if (setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR,
			(char *)&opt, sizeof(opt)) < 0) {
		_E("Failed to setsockopt");
		goto error_out_close;
	}

	if (!access(server_unix_socket_path, F_OK))
		unlink(server_unix_socket_path);

	if (bind(*sock, (struct sockaddr *)address, sizeof(*address)) < 0) {
		_E("Failed to bind");
		goto error_out_close;
	}

	file_mode = (S_IRWXU | S_IRWXG | S_IRWXO);
	if (chmod(server_unix_socket_path, file_mode) < 0) {
		_E("Failed to change the file mode of %s", server_unix_socket_path);
		goto error_out_close;
	}

	if (listen(*sock, PENDING_MAX) < 0) {
		_E("Failed to begin listenning");
		goto error_out_close;
	}

	*addrlen = sizeof(*address);

	return 0;

error_out_close:
	close(*sock);
error_out:
	bzero(address, sizeof(*address));

	return -EIO;
}

int init_ip_socket(int *sock, struct sockaddr_in *address, int *addrlen)
{
	int opt = true;

	if (!sock || !address || !addrlen)
		return -EINVAL;

	*sock = socket(AF_INET, SOCK_STREAM, 0);
	if (*sock < 0) {
		_E("Failed to initialize TCP/IP socket");
		goto error_out;
	}

	if (setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR,
			(char *)&opt, sizeof(opt)) < 0) {
		_E("Failed to setsockopt for TCP/IP socket");
		goto error_out_close;
	}

	bzero(address, sizeof(*address));
	address->sin_family = AF_INET;
	address->sin_addr.s_addr = INADDR_ANY;
	address->sin_port = htons(REQUEST_SERVER_PORT);

	if (bind(*sock, (struct sockaddr *)address, sizeof(*address)) < 0) {
		_E("Failed to bind for TCP/IP socket");
		goto error_out_close;
	}

	if (listen(*sock, PENDING_MAX) < 0) {
		_E("Failed to begin listenning for TCP/IP socket");
		goto error_out_close;
	}

	*addrlen = sizeof(*address);

	return 0;

error_out_close:
	close(*sock);
error_out:
	return -EIO;
}

static void init_resource_id(void)
{
	int val;
	struct timeval tv;

	/*
	 * Initial g_resource_id is set by a combination of
	 * tv_sec and tv_usec values of gettimeofday().
	 * It ensures that PASS assigns a unique resource id
	 * for each create_resource request.
	 *
	 * Even PASS is restarted, a newly initialized value
	 * of g_resource_id reflects the current value of
	 * gettimeofday(). Thus, the uniqueness in resource
	 * id is kept unless the number of created resources
	 * crosses the time consumed (in msecs) before
	 * restarted.
	 */
	gettimeofday(&tv, NULL);
	val = tv.tv_sec * 1000 + tv.tv_usec / 1000;
	g_resource_id = clear_sign_bit(val);
}

static int request_server_func(void *ctx, void **result)
{
	struct sockaddr_un unix_address;
	struct sockaddr_in ip_address;
	struct timeval wait;
	int server_unix_socket;
	int server_ip_socket = 0;
	int unix_addrlen;
	int ip_addrlen;
	int ret;
	fd_set fds;

	if (!g_request_server_run)
		return THREAD_RETURN_DONE;

	init_resource_id();

	/* 0. initialize server socket */
	ret = init_unix_socket(&server_unix_socket, &unix_address, &unix_addrlen);
	if (ret < 0)
		goto error_out;

	while (g_request_server_run) {
		FD_ZERO(&fds);
		FD_SET(server_unix_socket, &fds);
		if (server_ip_socket)
			FD_SET(server_ip_socket, &fds);

		wait.tv_sec = 1;
		wait.tv_usec = 0;

		ret = select(FD_SETSIZE, &fds, NULL, NULL, &wait);
		if (ret < 0) {
			_E("failed to select");
			goto error_out_close;
		}

		if (FD_ISSET(server_unix_socket, &fds)) {
			int new_socket = accept(server_unix_socket, (struct sockaddr *)&unix_address,
					(socklen_t *)&unix_addrlen);

			if (new_socket < 0) {
				_E("Failed to accept");
				goto error_out_close;
			}

			create_request_client(new_socket);
		}

		if (server_ip_socket && FD_ISSET(server_ip_socket, &fds)) {
			int new_socket = accept(server_ip_socket, (struct sockaddr *)&ip_address,
					(socklen_t *)&ip_addrlen);

			if (new_socket < 0) {
				_E("Failed to accept");
				goto error_out_close;
			}

			create_request_client(new_socket);
		}

		if (!server_ip_socket && (monitor_get_debug_mode() == TRUE)) {
			/*
			 * FIXME:
			 * server_ip_socket activation can be deferred since it
			 * will be done after timeout of select is expired. So,
			 * when the timeout is extended, this activation should be
			 * done by other ways in order to prevent unacceptable
			 * delays.
			 */
			ret = init_ip_socket(&server_ip_socket, &ip_address, &ip_addrlen);
			if (ret < 0)
				goto error_out_close_server_unix_socket;
		} else if (server_ip_socket && (monitor_get_debug_mode() == FALSE)) {
			close(server_ip_socket);
			server_ip_socket = 0;
		}
	}

	close(server_unix_socket);
	if (server_ip_socket)
		close(server_ip_socket);

	return THREAD_RETURN_DONE;

error_out_close:
	if (server_ip_socket)
		close(server_ip_socket);
error_out_close_server_unix_socket:
	close(server_unix_socket);
error_out:

	return THREAD_RETURN_ERROR;
}

int request_server_init(void)
{
	g_request_server_run = true;
	if (create_daemon_thread(&g_server_thread, request_server_func, NULL))
		_E("Failed to create request_server_thread ");

	return 0;
}

void request_server_exit(void)
{
	g_request_server_run = false;
	destroy_thread(g_server_thread);
}