path: root/src/connectivity.c

/*
 * Copyright (c) 2015 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * 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 <stdlib.h>
#include <glib.h>

#include <tizen.h>
#include <service_app.h>
#include <iotcon.h>
#include <Eina.h>

#include "log.h"
#include "connectivity.h"

#define DOOR_RESOURCE_URI_PREFIX "/door"
#define DOOR_RESOURCE_TYPE "org.tizen.door"

struct _connectivity_observe_resource_cb_s {
	connectivity_observe_resource_cb cb;
	void *user_data;
};
typedef struct _connectivity_observe_resource_cb_s connectivity_observe_resource_cb_s;

struct _connectivity_resource_s {
	char *device_id;
	char *host_address;
	char *device_name;
	char *uri_path;
	iotcon_presence_h presence;
	iotcon_remote_resource_h resource;
	connectivity_observe_resource_cb_s *cb_info;
};

static struct {
	Eina_List *list;
} connectivity_info = {
	.list = NULL,
};

static void _response_query_cb(iotcon_remote_resource_h resource, iotcon_error_e err,
		iotcon_request_type_e request_type, iotcon_response_h response, void *user_data);

static void _observe_cb(iotcon_remote_resource_h resource, iotcon_error_e err, int sequence_number, iotcon_response_h response, void *user_data)
{
	int ret = -1;
	bool opened = false;
	iotcon_attributes_h attributes = NULL;
	iotcon_representation_h repr = NULL;
	iotcon_response_result_e response_result;
	connectivity_resource_s *resource_info = user_data;

	ret_if(!resource_info);
	ret_if(!resource_info->cb_info);
	ret_if(!resource_info->cb_info->cb);
	ret_if(IOTCON_ERROR_NONE != err);

	ret = iotcon_response_get_result(response, &response_result);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_response_get_result() Fail(%d)", ret);
		return;
	}

	if (IOTCON_RESPONSE_OK != response_result) {
		_E("_on_response_observe Response error(%d)", response_result);
		return;
	}

	ret = iotcon_response_get_representation(response, &repr);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_representation_get_attributes(repr, &attributes);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_attributes_get_bool(attributes, "opened", &opened);
	ret_if(IOTCON_ERROR_NONE != ret);

	resource_info->cb_info->cb(resource_info, (void *)(int) opened, resource_info->cb_info->user_data);
}

static void _response_delete_query(iotcon_remote_resource_h resource, iotcon_response_h response, void *user_data)
{
	int ret = -1;
	iotcon_response_result_e response_result;

	ret = iotcon_response_get_result(response, &response_result);
	ret_if(IOTCON_ERROR_NONE != ret);

	if (IOTCON_RESPONSE_OK != response_result
			&& IOTCON_RESPONSE_RESOURCE_DELETED != response_result) {
		_E("_response_delete_query Response error(%d)", response_result);
		return;
	}

	_I("DELETE request was successful");
	/* FIXME : need to free resources? */
	iotcon_remote_resource_destroy(resource);
}

static void _response_post_query(iotcon_remote_resource_h resource, iotcon_response_h response, void *user_data)
{
	int ret = -1;
	char *host = NULL, *created_uri_path = NULL;
	iotcon_connectivity_type_e connectivity_type;
	iotcon_response_result_e response_result;
	iotcon_attributes_h recv_attributes = NULL;
	iotcon_resource_types_h types = NULL;
	iotcon_resource_interfaces_h ifaces = NULL;
	iotcon_remote_resource_h new_door_resource = NULL;
	iotcon_representation_h recv_repr = NULL;

	ret = iotcon_response_get_result(response, &response_result);
	ret_if(IOTCON_ERROR_NONE != ret);

	if (IOTCON_RESPONSE_RESOURCE_CREATED != response_result) {
		_E("_response_post_query Response error(%d)", response_result);
		return;
	}

	_I("POST request was successful");

	ret = iotcon_response_get_representation(response, &recv_repr);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_representation_get_attributes(recv_repr, &recv_attributes);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_attributes_get_str(recv_attributes, "createduripath", &created_uri_path);
	ret_if(IOTCON_ERROR_NONE != ret);

	_D("New resource created : %s", created_uri_path);

	ret = iotcon_remote_resource_get_host_address(resource, &host);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_get_host_address() Fail(%d)", ret);
		return;
	}

	ret = iotcon_remote_resource_get_connectivity_type(resource, &connectivity_type);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_get_connectivity_type() Fail(%d)", ret);
		return;
	}

	ret = iotcon_remote_resource_get_types(resource, &types);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_get_types() Fail(%d)", ret);
		return;
	}

	ret = iotcon_remote_resource_get_interfaces(resource, &ifaces);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_get_interfaces() Fail(%d)", ret);
		return;
	}

	ret = iotcon_remote_resource_create(host, connectivity_type, created_uri_path,
			IOTCON_RESOURCE_SECURE, types, ifaces, &new_door_resource);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_create() Fail(%d)", ret);
		return;
	}

	ret = iotcon_remote_resource_delete(new_door_resource, _response_query_cb, NULL);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_remote_resource_delete() Fail(%d)", ret);
		iotcon_remote_resource_destroy(new_door_resource);
		return;
	}
}

static void _response_put_query(iotcon_remote_resource_h resource, iotcon_response_h response, void *user_data)
{
	int ret = -1;
	iotcon_response_result_e response_result;
	iotcon_representation_h send_repr = NULL;

	ret = iotcon_response_get_result(response, &response_result);
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_response_get_result() Fail(%d)", ret);
		return;
	}

	if (IOTCON_RESPONSE_RESOURCE_CHANGED != response_result) {
		_E("_response_put_query Response error(%d)", response_result);
		return;
	}

	_I("PUT request was successful");

	ret = iotcon_representation_create(&send_repr);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_remote_resource_post(resource, send_repr, NULL, _response_query_cb, NULL);
	goto_if(IOTCON_ERROR_NONE != ret, out);

out:
	iotcon_representation_destroy(send_repr);
}

static void _response_get_query(iotcon_remote_resource_h resource, iotcon_response_h response, void *user_data)
{
	bool opened = true;
	char *resource_host = NULL;
	int ret = -1;
	iotcon_response_result_e response_result;
	iotcon_representation_h send_repr = NULL;
	iotcon_representation_h recv_repr = NULL;
	iotcon_attributes_h send_attributes = NULL;
	iotcon_attributes_h recv_attributes = NULL;

	ret = iotcon_response_get_result(response, &response_result);
	ret_if(IOTCON_ERROR_NONE != ret);

	if (IOTCON_RESPONSE_OK != response_result) {
		_E("_response_get_query response error(%d)", response_result);
		return;
	}

	iotcon_remote_resource_get_host_address(resource, &resource_host);
	_I("Resource host : %s", resource_host);

	ret = iotcon_response_get_representation(response, &recv_repr);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_representation_get_attributes(recv_repr, &recv_attributes);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_attributes_get_bool(recv_attributes, "opened", &opened);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_representation_create(&send_repr);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_attributes_create(&send_attributes);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_attributes_add_bool(send_attributes, "opened", !opened);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_representation_set_attributes(send_repr, send_attributes);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_remote_resource_put(resource, send_repr, NULL, _response_query_cb, NULL);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	iotcon_attributes_destroy(send_attributes);
	iotcon_representation_destroy(send_repr);

	return;

error:
	if (send_attributes) iotcon_attributes_destroy(send_attributes);
	if (send_repr) iotcon_representation_destroy(send_repr);

}

static void _presence_cb(iotcon_presence_h presence, iotcon_error_e err,
		iotcon_presence_response_h response, void *user_data)
{
	int ret = -1;
	char *host_address = NULL;
	char *resource_type = NULL;
	iotcon_presence_result_e result;
	iotcon_presence_trigger_e trigger;
	iotcon_connectivity_type_e connectivity_type;

	ret_if(IOTCON_ERROR_NONE != err);

	ret = iotcon_presence_response_get_result(response, &result);
	ret_if(IOTCON_ERROR_NONE != ret);

	_I("Presence callback's result : %d", result);

	if (IOTCON_PRESENCE_OK == result) {
		ret = iotcon_presence_response_get_trigger(response, &trigger);
		ret_if(IOTCON_ERROR_NONE != ret);
		_I("trigger : %d", trigger);
	}

	ret = iotcon_presence_response_get_host_address(response, &host_address);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_presence_response_get_connectivity_type(response, &connectivity_type);
	ret_if(IOTCON_ERROR_NONE != ret);

	ret = iotcon_presence_response_get_resource_type(response, &resource_type);
	ret_if(IOTCON_ERROR_NONE != ret);

	_I("Host address : %s", host_address);
	_I("Resource type : %s", resource_type);
}

static void _response_query_cb(iotcon_remote_resource_h resource,
		iotcon_error_e err,
		iotcon_request_type_e request_type,
		iotcon_response_h response,
		void *user_data)
{
	ret_if(IOTCON_ERROR_NONE != err);

	_I("Request type[%d]", request_type);

	switch (request_type) {
	case IOTCON_REQUEST_GET:
		_response_get_query(resource, response, user_data);
		break;
	case IOTCON_REQUEST_PUT:
		_response_put_query(resource, response, user_data);
		break;
	case IOTCON_REQUEST_POST:
		_response_post_query(resource, response, user_data);
		break;
	case IOTCON_REQUEST_DELETE:
		_response_delete_query(resource, response, user_data);
		break;
	default:
		_E("Invalid request type (%d)", request_type);
	}
}

/* return values : -1 error, 0 not exist, 1 exist */
static int _exist_device_id_in_list(iotcon_remote_resource_h resource)
{
	Eina_List *l = NULL, *ln = NULL;
	connectivity_resource_s *temp = NULL;
	char *device_id = NULL;
	int ret = -1;

	retv_if(!resource, -1);

	ret = iotcon_remote_resource_get_device_id(resource, &device_id);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	EINA_LIST_FOREACH_SAFE(connectivity_info.list, l, ln, temp) {
		continue_if(!temp->device_id);
		if (!strncmp(temp->device_id, device_id, strlen(device_id))) {
			_D("\"%s\" already found. skip !", device_id);
			return 1;
		}
	}

	_I("Resource[%s] is not in the list", device_id);

	return 0;
}

static int _add_resource_info_into_list(connectivity_resource_s *info)
{
	retv_if(!info, -1);
	connectivity_info.list = eina_list_append(connectivity_info.list, info);
	return 0;
}

#if 0
static connectivity_resource_s *_pop_device_id_from_list(const char *device_id)
{
	Eina_List *l = NULL, *ln = NULL;
	connectivity_resource_s *temp = NULL;
	connectivity_resource_s *info = NULL;

	retv_if(!device_id, NULL);

	EINA_LIST_FOREACH_SAFE(connectivity_info.list, l, ln, temp) {
		continue_if(!temp->device_id);
		if (!strncmp(temp->device_id, device_id, strlen(device_id))) {
			connectivity_info.list = eina_list_remove(connectivity_info.list, temp);
			info = temp;
			break;
		}
	}

	return info;
}
#endif

static bool _get_res_iface_cb(const char *string, void *user_data)
{
	char *resource_uri_path = user_data;
	_I("[%s] resource interface : %s", resource_uri_path, string);
	return IOTCON_FUNC_CONTINUE;
}

static bool _get_res_type_cb(const char *string, void *user_data)
{
	char *resource_uri_path = user_data;
	_I("[%s] resource type : %s", resource_uri_path, string);
	return IOTCON_FUNC_CONTINUE;
}

static int _retrieve_resource_info(iotcon_remote_resource_h resource, connectivity_resource_s *info)
{
	int ret = -1;
	char *device_id = NULL;
	char *host_address = NULL;
	char *device_name = NULL;
	char *uri_path = NULL;
	iotcon_resource_interfaces_h resource_interfaces;
	iotcon_resource_types_h resource_types;
	iotcon_connectivity_type_e connectivity_type;

	retv_if(!info, -1);

	ret = iotcon_remote_resource_get_device_id(resource, &device_id);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_host_address(resource, &host_address);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_device_name(resource, &device_name);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_uri_path(resource, &uri_path);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_connectivity_type(resource, &connectivity_type);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_interfaces(resource, &resource_interfaces);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_resource_interfaces_foreach(resource_interfaces, _get_res_iface_cb, uri_path);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_types(resource, &resource_types);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_resource_types_foreach(resource_types, _get_res_type_cb, uri_path);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_clone(resource, &info->resource);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	_I("Resource Addr[%s/%s] is in Device[%s]", host_address, uri_path, device_name);

	info->device_id = strdup(device_id);
	goto_if(!info->device_id, error);

	info->host_address = strdup(host_address);
	goto_if(!info->host_address, error);

	info->device_name = strdup(device_name);
	goto_if(!info->device_name, error);

	info->uri_path = strdup(uri_path);
	goto_if(!info->uri_path, error);

	return 0;

error:
	if (info->resource) {
		iotcon_remote_resource_destroy(info->resource);
		info->resource = NULL;
	}
	if (info->uri_path) {
	   	free(info->uri_path);
		info->uri_path = NULL;
	}
	if (info->device_name) {
		free(info->device_name);
		info->device_name = NULL;
	}
	if (info->host_address) {
		free(info->host_address);
		info->host_address = NULL;
	}
	if (info->device_id) {
		free(info->device_id);
		info->device_id = NULL;
	}

	return -1;
}

static void _free_resource_info(connectivity_resource_s *info)
{
	ret_if(!info);

	if (info->presence)
		iotcon_remove_presence_cb(info->presence);

	if (info->resource)
		iotcon_remote_resource_destroy(info->resource);

	if (info->uri_path)
	   	free(info->uri_path);

	if (info->device_name)
		free(info->device_name);

	if (info->host_address)
		free(info->host_address);

	if (info->device_id)
		free(info->device_id);

	free(info);
}

static void _free_resource_info_list(void)
{
	connectivity_resource_s *info = NULL;

	EINA_LIST_FREE(connectivity_info.list, info) {
		_free_resource_info(info);
	}
}


static int _register_presence(iotcon_remote_resource_h resource, connectivity_resource_s *info)
{
	int ret = -1;
	char *resource_host = NULL;
	iotcon_connectivity_type_e connectivity_type;

	ret = iotcon_remote_resource_get_host_address(resource, &resource_host);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_remote_resource_get_connectivity_type(resource, &connectivity_type);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	/* FIXME : We need to remove presence_cb when not needed */
	ret = iotcon_add_presence_cb(resource_host,
			connectivity_type,
			DOOR_RESOURCE_TYPE,
			_presence_cb,
			NULL,
			&info->presence);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	return 0;
}

#if 0
static void _unregister_presence(connectivity_resource_s *info)
{
	ret_if(!info);
	iotcon_remove_presence_cb(info->presence);
	info->presence = NULL;
}
#endif

static int _register_observe(connectivity_resource_s *info)
{
	int ret = -1;

	/* resource is cloned data */
	ret = iotcon_remote_resource_observe_register(info->resource,
			IOTCON_OBSERVE_IGNORE_OUT_OF_ORDER,
			NULL,
			_observe_cb,
			info);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	return 0;
}

#if 0
static void _unregister_observe(connectivity_resource_s *info)
{
	ret_if(!info);
	iotcon_remote_resource_observe_deregister(info->resource);
}
#endif

static int _request_query(connectivity_resource_s *info)
{
	int ret = -1;
	iotcon_query_h query = NULL;

	ret = iotcon_query_create(&query);
	retv_if(IOTCON_ERROR_NONE != ret, -1);

	ret = iotcon_query_add(query, "query_key", "query_value");
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_remote_resource_get(info->resource, query, _response_query_cb, NULL);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	iotcon_query_destroy(query);
	return 0;

error:
	iotcon_query_destroy(query);
	return -1;
}

static bool _found_resource_cb(iotcon_remote_resource_h resource, iotcon_error_e result, void *user_data)
{
	int ret = -1;
	connectivity_resource_s *info = NULL;

	/* We should know where we get wrong results */
	/* Can attackers send wrong messages to stop this? */
	retv_if(IOTCON_ERROR_NONE != result, IOTCON_FUNC_STOP);
	if (!resource) return IOTCON_FUNC_CONTINUE;

	_I("Resource is found");

	ret = _exist_device_id_in_list(resource);
	retv_if(-1 == ret, IOTCON_FUNC_CONTINUE);
	if (1 == ret) return IOTCON_FUNC_CONTINUE;

	info = calloc(1, sizeof(connectivity_resource_s));
	retv_if(!info, -1);
	info->cb_info = user_data;

	ret = _retrieve_resource_info(resource, info);
	goto_if(-1 == ret, error);

	/* FIXME : We have to develop these routines more for meaningful usecases */
	/* We can think several scenarios like intentionally closing servers. */
	ret = _register_presence(resource, info);
	goto_if(-1 == ret, error);

	if (-1 == _register_observe(info)) {
		_E("Cannot observe [%s:%s:%s:%s]", info->device_id, info->host_address, info->device_name, info->uri_path);
	}

	if (-1 == _request_query(info)) {
		_E("Cannot request query");
	}

	ret = _add_resource_info_into_list(info);
	goto_if(-1 == ret, error);

	return IOTCON_FUNC_CONTINUE;

error:
	if (info) _free_resource_info(info);
	return IOTCON_FUNC_CONTINUE;
}

int connectivity_init(void)
{
	int ret = -1;

	ret = iotcon_initialize("/usr/apps/org.tizen.position-finder-client/res/iotcon-test-svr-db-client.dat");
	if (IOTCON_ERROR_NONE != ret) {
		_E("iotcon_initialize() Fail(%d)", ret);
		return -1;
	}

	return 0;
}

int connectivity_fini(void)
{
	/* deinitialize iotcon */
	_free_resource_info_list();
	iotcon_deinitialize();
	return 0;
}

int connectivity_observe_resource(connectivity_observe_resource_cb cb, void *user_data)
{
	int ret = -1;
	iotcon_query_h query = NULL;
	connectivity_observe_resource_cb_s *cb_info = NULL;

	cb_info = calloc(1, sizeof(connectivity_observe_resource_cb_s));
	retv_if(!cb_info, -1);
	cb_info->cb = cb;
	cb_info->user_data = user_data;

	ret = iotcon_query_create(&query);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_query_set_resource_type(query, DOOR_RESOURCE_TYPE);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	ret = iotcon_find_resource(IOTCON_MULTICAST_ADDRESS,
			IOTCON_CONNECTIVITY_IP | IOTCON_CONNECTIVITY_PREFER_UDP,
			query,
			_found_resource_cb,
			cb_info);
	goto_if(IOTCON_ERROR_NONE != ret, error);

	iotcon_query_destroy(query);
	return 0;

error:
	iotcon_query_destroy(query);
	if (cb_info) free(cb_info);
	return -1;
}