From 81e3fc9ca45a1b6c21708594e6df8edd6991b85a Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Thu, 6 Apr 2017 19:16:45 +0900 Subject: [PATCH 01/16] sensord: add testcase for internal apis - there are just only basic testcases. - [TBD] more test cases will be added. Change-Id: I28e44c0001ef77ce6349e0b03bc6b17bf7dea429 Signed-off-by: kibak.yoon --- src/sensorctl/testcase/unit_client.cpp | 154 +++++++++++++++++++++++++++++++++ 1 file changed, 154 insertions(+) create mode 100644 src/sensorctl/testcase/unit_client.cpp diff --git a/src/sensorctl/testcase/unit_client.cpp b/src/sensorctl/testcase/unit_client.cpp new file mode 100644 index 0000000..1034573 --- /dev/null +++ b/src/sensorctl/testcase/unit_client.cpp @@ -0,0 +1,154 @@ +/* + * sensorctl + * + * Copyright (c) 2017 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. + * + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include "log.h" +#include "mainloop.h" +#include "test_bench.h" + +TESTCASE(sensor_api_get_default_sensor, get_sensor_p_1) +{ + int err; + sensor_t sensor; + + err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor); + ASSERT_EQ(err, 0); + + return true; +} + +TESTCASE(sensor_api_get_sensors, get_sensor_p_2) +{ + int err; + int count; + sensor_t *sensors; + + err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count); + ASSERT_EQ(err, 0); + ASSERT_GT(count, 0); + + free(sensors); + + return true; +} + +TESTCASE(sensor_api_connect, connect_p_1) +{ + int err; + int handle; + sensor_t sensor; + + err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor); + ASSERT_EQ(err, 0); + + handle = sensord_connect(sensor); + ASSERT_GT(handle, 0); + + err = sensord_disconnect(handle); + ASSERT_EQ(err, 1); + + return true; +} + +static bool called = false; + +static void basic_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data) +{ + if (test_option::full_log == false) { + while (true) {} + } + _I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]); +} + +TESTCASE(sensor_api_all, all_p_1) +{ + int err; + bool ret; + int handle; + sensor_t sensor; + sensor_t *list; + int count; + + called = false; + + err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor); + ASSERT_EQ(err, 0); + + err = sensord_get_sensors(ALL_SENSOR, &list, &count); + ASSERT_EQ(err, 0); + + handle = sensord_connect(sensor); + ASSERT_EQ(err, 0); + + ret = sensord_register_event(handle, 1, 100, 100, basic_cb, NULL); + ASSERT_TRUE(ret); + + ret = sensord_start(handle, 0); + ASSERT_TRUE(ret); + + ret = sensord_change_event_interval(handle, 0, 100); + ASSERT_TRUE(ret); + + ret = sensord_change_event_max_batch_latency(handle, 0, 100); + ASSERT_TRUE(ret); + + mainloop::run(); + + ret = sensord_stop(handle); + ASSERT_TRUE(ret); + + ret = sensord_unregister_event(handle, 1); + ASSERT_TRUE(ret); + + ret = sensord_disconnect(handle); + ASSERT_TRUE(ret); + + free(list); + + return true; +} + +TESTCASE(sensor_api_provider, provider_base_p_1) +{ + bool ret; + int handle; + + handle = sensord_external_connect("TEST", NULL, NULL); + ASSERT_GE(handle, 0); + + for (int k = 0; k < 1000; ++k) { + float data[3] = { 1, 2, 3 }; + ret = sensord_external_post(handle, 1, data, 3); + ASSERT_TRUE(ret); + sleep(1); + } + + ret = sensord_external_disconnect(handle); + ASSERT_TRUE(ret); + + return true; +} -- 2.7.4 From 56d7c3a6a1e081dde58ebee6e318a164e9c588ef Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 00:32:56 +0900 Subject: [PATCH 02/16] sensord: check URI to find the matched sensor Change-Id: Ib6d0364fd7036c295129872b7db79f0bd8f40685 Signed-off-by: kibak.yoon --- src/client/sensor_manager.cpp | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/client/sensor_manager.cpp b/src/client/sensor_manager.cpp index 9a93cb5..74ed6c7 100644 --- a/src/client/sensor_manager.cpp +++ b/src/client/sensor_manager.cpp @@ -272,8 +272,12 @@ sensor_info *sensor_manager::get_info(const char *uri) return &m_infos[0]; for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { - if ((*it).get_uri() == uri) - return &*it; + std::size_t found = (*it).get_uri().rfind(uri); + + if (found == std::string::npos) + continue; + + return &*it; } return NULL; @@ -288,8 +292,12 @@ std::vector sensor_manager::get_infos(const char *uri) all = true; for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { - if (all || (*it).get_type_uri() == uri) - infos.push_back(&*it); + std::size_t found = (*it).get_uri().rfind(uri); + + if (!all && found == std::string::npos) + continue; + + infos.push_back(&*it); } return infos; -- 2.7.4 From 7427c10733193b8cfd163353c25b9d7e36d1bd27 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 7 Apr 2017 17:18:00 +0900 Subject: [PATCH 03/16] sensord: remove sensor_permission_t from sensor_info - it just only needs privilege string. Change-Id: I82b25ae10075167781ed21baf62fe868a7b48450 Signed-off-by: kibak.yoon --- src/shared/sensor_info.cpp | 34 +++++++++++++--------------------- src/shared/sensor_info.h | 8 ++++---- 2 files changed, 17 insertions(+), 25 deletions(-) diff --git a/src/shared/sensor_info.cpp b/src/shared/sensor_info.cpp index 808c07f..7ff31f4 100644 --- a/src/shared/sensor_info.cpp +++ b/src/shared/sensor_info.cpp @@ -40,7 +40,7 @@ sensor_info::sensor_info() , m_min_interval(0) , m_max_batch_count(0) , m_wakeup_supported(false) -, m_permission(SENSOR_PERMISSION_STANDARD) /* TODO: change it to string */ +, m_privilege("") { } @@ -56,7 +56,7 @@ sensor_info::sensor_info(const sensor_info &info) , m_min_interval(info.m_min_interval) , m_max_batch_count(info.m_max_batch_count) , m_wakeup_supported(info.m_wakeup_supported) -, m_permission(SENSOR_PERMISSION_STANDARD) +, m_privilege(info.m_privilege) { } @@ -78,7 +78,8 @@ sensor_info::sensor_info(const sensor_info_t &info) set_min_interval(info.min_interval); set_max_batch_count(info.max_batch_count); set_wakeup_supported(info.wakeup_supported); - set_permission(SENSOR_PERMISSION_STANDARD); + /* TODO: sensor_info_t should have privilege string */ + set_privilege(""); } sensor_info::sensor_info(const sensor_info2_t &info) @@ -97,13 +98,7 @@ sensor_info::sensor_info(const sensor_info2_t &info) set_min_interval(info.min_interval); set_max_batch_count(info.max_batch_count); set_wakeup_supported(info.wakeup_supported); - - /* TODO : store string just itself */ - std::string privilege = info.privilege; - if (privilege == "http://tizen.org/privilege/healthinfo") - set_permission(SENSOR_PERMISSION_HEALTH_INFO); - else - set_permission(SENSOR_PERMISSION_STANDARD); + set_privilege(info.privilege); } sensor_type_t sensor_info::get_type(void) @@ -161,9 +156,9 @@ bool sensor_info::is_wakeup_supported(void) return m_wakeup_supported; } -sensor_permission_t sensor_info::get_permission(void) +std::string &sensor_info::get_privilege(void) { - return m_permission; + return m_privilege; } void sensor_info::set_type(sensor_type_t type) @@ -221,9 +216,9 @@ void sensor_info::set_wakeup_supported(bool supported) m_wakeup_supported = supported; } -void sensor_info::set_permission(sensor_permission_t permission) +void sensor_info::set_privilege(const char *privilege) { - m_permission = permission; + m_privilege = privilege; } void sensor_info::serialize(raw_data_t &data) @@ -239,12 +234,11 @@ void sensor_info::serialize(raw_data_t &data) put(data, m_min_interval); put(data, m_max_batch_count); put(data, m_wakeup_supported); - put(data, (int)m_permission); + put(data, m_privilege); } void sensor_info::deserialize(const char *data, int data_len) { - int permission; int type; raw_data_t raw_data(&data[0], &data[data_len]); @@ -262,9 +256,7 @@ void sensor_info::deserialize(const char *data, int data_len) it = get(it, m_min_interval); it = get(it, m_max_batch_count); it = get(it, m_wakeup_supported); - - it = get(it, permission); - m_permission = (sensor_permission_t)permission; + it = get(it, m_privilege); } void sensor_info::show(void) @@ -279,7 +271,7 @@ void sensor_info::show(void) _I("Min_interval = %d", m_min_interval); _I("Max_batch_count = %d", m_max_batch_count); _I("Wakeup_supported = %d", m_wakeup_supported); - _I("Privilege = %d", (int)m_permission); + _I("Privilege = %s", m_privilege.c_str()); } void sensor_info::clear(void) @@ -295,7 +287,7 @@ void sensor_info::clear(void) m_min_interval = 0; m_max_batch_count = 0; m_wakeup_supported = false; - m_permission = SENSOR_PERMISSION_STANDARD; + m_privilege.clear(); } void sensor_info::put(raw_data_t &data, int value) diff --git a/src/shared/sensor_info.h b/src/shared/sensor_info.h index 93ae3aa..2611948 100644 --- a/src/shared/sensor_info.h +++ b/src/shared/sensor_info.h @@ -44,14 +44,14 @@ public: std::string &get_type_uri(void); std::string &get_uri(void); std::string &get_model(void); - std::string & get_vendor(void); + std::string &get_vendor(void); float get_min_range(void); float get_max_range(void); float get_resolution(void); int get_min_interval(void); int get_max_batch_count(void); bool is_wakeup_supported(void); - sensor_permission_t get_permission(void); + std::string &get_privilege(void); /* TODO: it would be better to get_type() returns type(URI) */ void set_type(sensor_type_t type); @@ -65,7 +65,7 @@ public: void set_min_interval(int min_interval); void set_max_batch_count(int max_batch_count); void set_wakeup_supported(bool supported); - void set_permission(sensor_permission_t permission); + void set_privilege(const char *privilege); void clear(void); @@ -85,7 +85,7 @@ private: int m_min_interval; int m_max_batch_count; bool m_wakeup_supported; - sensor_permission_t m_permission; + std::string m_privilege; /* TODO: use template */ void put(raw_data_t &data, int value); -- 2.7.4 From ed2ea0fea55c8291d0a4df8dc9ceaff108239ef3 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Fri, 7 Apr 2017 17:25:51 +0900 Subject: [PATCH 04/16] sensor: remove a bad way for hiding sensor handle - from now on, privilege is not checking. Change-Id: I4853b27e2bb7a7c2fc1775974d9df8e199b46ec8 Signed-off-by: kibak.yoon --- src/client/sensor_manager.cpp | 6 ------ src/server/sensor_manager.cpp | 3 --- 2 files changed, 9 deletions(-) diff --git a/src/client/sensor_manager.cpp b/src/client/sensor_manager.cpp index 74ed6c7..5602312 100644 --- a/src/client/sensor_manager.cpp +++ b/src/client/sensor_manager.cpp @@ -89,9 +89,6 @@ int sensor_manager::get_sensor(const char *uri, sensor_t *sensor) return -ENODATA; } - if (info->get_uri() == SENSOR_URI_PERMISSION_DENIED) - return -EACCES; - *sensor = (sensor_t)info; return OP_SUCCESS; } @@ -109,9 +106,6 @@ int sensor_manager::get_sensors(const char *uri, sensor_t **list, int *count) return -ENODATA; } - if (infos[0]->get_uri() == SENSOR_URI_PERMISSION_DENIED) - return -EACCES; - *list = (sensor_t *)malloc(sizeof(sensor_info *) * size); retvm_if(!*list, -ENOMEM, "Failed to allocate memory"); diff --git a/src/server/sensor_manager.cpp b/src/server/sensor_manager.cpp index 7a0ccc9..c7a692d 100644 --- a/src/server/sensor_manager.cpp +++ b/src/server/sensor_manager.cpp @@ -267,9 +267,6 @@ size_t sensor_manager::serialize(int sock_fd, char **bytes) for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) { info = it->second->get_sensor_info(); - if (!checker.has_permission(sock_fd, info.get_permission())) - info.set_uri(SENSOR_URI_PERMISSION_DENIED); - raw_data_t *raw = new(std::nothrow) raw_data_t(); retvm_if(!raw, -ENOMEM, "Failed to allocated memory"); -- 2.7.4 From 69dfc88f31ca89c3ede1de88ccfb4d5683cc05f6 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 10:43:29 +0900 Subject: [PATCH 05/16] sensord: move member functions from public to private Change-Id: Ibbf486527e7b41663c6a3948071602d897b890b0 Signed-off-by: kibak.yoon --- src/server/permission_checker.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/server/permission_checker.h b/src/server/permission_checker.h index b307dc0..06499a7 100644 --- a/src/server/permission_checker.h +++ b/src/server/permission_checker.h @@ -32,12 +32,13 @@ public: void init(void); + bool has_permission(int sock_fd, std::string &perm); + bool has_permission(int sock_fd, sensor_permission_t perm); + +private: void init_cynara(void); void deinit_cynara(void); bool has_permission_cynara(int sock_fd, std::string &perm); - - bool has_permission(int sock_fd, std::string &perm); - bool has_permission(int sock_fd, sensor_permission_t perm); }; } -- 2.7.4 From c96ddb24d1a3bebea6ddd5df66c297ac62fc7503 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 10:52:13 +0900 Subject: [PATCH 06/16] sensord: fix a bug which did not check privilege - missing cynara check Change-Id: I3bb6de4babadfd17f45b0b99f2b957942c05cb95 Signed-off-by: kibak.yoon --- src/server/permission_checker.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/server/permission_checker.cpp b/src/server/permission_checker.cpp index 644ce61..e275c30 100644 --- a/src/server/permission_checker.cpp +++ b/src/server/permission_checker.cpp @@ -89,6 +89,7 @@ bool permission_checker::has_permission_cynara(int sock_fd, std::string &perm) { retvm_if(cynara_env == NULL, false, "Cynara not initialized"); + int ret; int pid = -1; char *client = NULL; char *session = NULL; @@ -109,7 +110,13 @@ bool permission_checker::has_permission_cynara(int sock_fd, std::string &perm) return false; } - return true; + ret = cynara_check(cynara_env, client, session, user, perm.c_str()); + + free(client); + free(session); + free(user); + + return (ret == CYNARA_API_ACCESS_ALLOWED); } bool permission_checker::has_permission(int sock_fd, std::string &perm) -- 2.7.4 From 66ab6ae6524109a61092965618a1d178d9f6e410 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 10:56:31 +0900 Subject: [PATCH 07/16] sensord: remove sensor_permission_t in the sensord - SENSOR_PRIVILEGE_PUBLIC should be 0 because of backwards compatibility. Change-Id: I81ff50e0e15459ede107925cc9eedfbabdedc9b8 Signed-off-by: kibak.yoon --- include/sensor_types.h | 10 +--------- src/client/sensor_internal.cpp | 24 ++++++++---------------- src/server/permission_checker.cpp | 15 --------------- src/server/permission_checker.h | 3 --- src/server/sensor_manager.cpp | 3 --- 5 files changed, 9 insertions(+), 46 deletions(-) diff --git a/include/sensor_types.h b/include/sensor_types.h index 3da9cfc..9c9426c 100644 --- a/include/sensor_types.h +++ b/include/sensor_types.h @@ -60,8 +60,6 @@ extern "C" #define SENSOR_UNKNOWN_TYPE "http://tizen.org/sensor/unknown" #define SENSOR_UNKNOWN_NAME "Unknown" -#define SENSOR_URI_PERMISSION_DENIED "http://tizen.org/sensor/EACCES" - typedef int64_t sensor_id_t; typedef void *sensor_t; @@ -179,14 +177,8 @@ typedef struct sensor_info2_t { void *reserved[8]; } sensor_info2_t; -typedef enum sensor_permission_t { - SENSOR_PERMISSION_NONE = 0, - SENSOR_PERMISSION_STANDARD = 1, - SENSOR_PERMISSION_HEALTH_INFO = 2, -} sensor_permission_t; - typedef enum sensor_privilege_t { - SENSOR_PRIVILEGE_PUBLIC = 1, + SENSOR_PRIVILEGE_PUBLIC = 0, } sensor_privilege_t; typedef struct sensor_event_t { diff --git a/src/client/sensor_internal.cpp b/src/client/sensor_internal.cpp index f9b2698..364eb92 100644 --- a/src/client/sensor_internal.cpp +++ b/src/client/sensor_internal.cpp @@ -156,22 +156,6 @@ API const char* sensord_get_vendor(sensor_t sensor) return static_cast(sensor)->get_vendor().c_str(); } -API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege) -{ - retvm_if(!manager.connect(), false, "Failed to connect"); - retvm_if(!privilege, false, "Invalid parameter[%#x]", privilege); - retvm_if(!manager.is_supported(sensor), false, - "Invalid sensor[%#x]", sensor); - - /* TODO: - * sensor_permission_t perm = static_cast(sensor)->get_permission(); - * *privilege = static_cast(perm); - */ - *privilege = SENSOR_PRIVILEGE_PUBLIC; - - return true; -} - API bool sensord_get_min_range(sensor_t sensor, float *min_range) { retvm_if(!manager.connect(), false, "Failed to connect"); @@ -650,3 +634,11 @@ API bool sensord_send_command(int handle, const char *command, int command_len) return (sensord_set_attribute_str(handle, 0, command, command_len) == OP_SUCCESS); } +/* deprecated */ +API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege) +{ + *privilege = SENSOR_PRIVILEGE_PUBLIC; + + return true; +} + diff --git a/src/server/permission_checker.cpp b/src/server/permission_checker.cpp index e275c30..05ead10 100644 --- a/src/server/permission_checker.cpp +++ b/src/server/permission_checker.cpp @@ -42,12 +42,6 @@ permission_checker::~permission_checker() deinit_cynara(); } -void permission_checker::init(void) -{ - /* if needed, add privilege to permissions */ - permissions[SENSOR_PERMISSION_HEALTH_INFO] = "http://tizen.org/privilege/healthinfo"; -} - void permission_checker::init_cynara(void) { int err; @@ -125,12 +119,3 @@ bool permission_checker::has_permission(int sock_fd, std::string &perm) return has_permission_cynara(sock_fd, perm); } - -/* TODO: remove sensor_permission_t and this function */ -bool permission_checker::has_permission(int sock_fd, sensor_permission_t perm) -{ - auto it = permissions.find(perm); - retv_if(it == permissions.end(), true); - - return has_permission(sock_fd, permissions[perm]); -} diff --git a/src/server/permission_checker.h b/src/server/permission_checker.h index 06499a7..7549de4 100644 --- a/src/server/permission_checker.h +++ b/src/server/permission_checker.h @@ -30,10 +30,7 @@ public: permission_checker(); ~permission_checker(); - void init(void); - bool has_permission(int sock_fd, std::string &perm); - bool has_permission(int sock_fd, sensor_permission_t perm); private: void init_cynara(void); diff --git a/src/server/sensor_manager.cpp b/src/server/sensor_manager.cpp index c7a692d..6b8bc91 100644 --- a/src/server/sensor_manager.cpp +++ b/src/server/sensor_manager.cpp @@ -27,7 +27,6 @@ #include #include "sensor_event_handler.h" -#include "permission_checker.h" #include "sensor_loader.h" #include "physical_sensor_handler.h" #include "fusion_sensor_handler.h" @@ -257,8 +256,6 @@ static void put_int_to_vec(std::vector &data, int value) */ size_t sensor_manager::serialize(int sock_fd, char **bytes) { - static permission_checker checker; - sensor_info info; std::vector raw_list; -- 2.7.4 From 0369befbb6d81edf9b839fffe6b688c807c9a3f3 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 10:59:22 +0900 Subject: [PATCH 08/16] sensord: add tokenize function to sensor::utils Change-Id: I8f646d00a241f23a8ee2ca3725102fecf8ec220c Signed-off-by: kibak.yoon --- src/shared/sensor_utils.cpp | 20 ++++++++++++++++++++ src/shared/sensor_utils.h | 4 ++++ 2 files changed, 24 insertions(+) diff --git a/src/shared/sensor_utils.cpp b/src/shared/sensor_utils.cpp index 2b2781f..6ef0504 100644 --- a/src/shared/sensor_utils.cpp +++ b/src/shared/sensor_utils.cpp @@ -19,6 +19,7 @@ #include "sensor_utils.h" +#include #include #include #include @@ -29,7 +30,9 @@ #include +#ifndef PATH_MAX #define PATH_MAX 256 +#endif /* TODO: move and define string type to sensor_type.h */ static std::map types = { @@ -199,3 +202,20 @@ const char* sensor::utils::get_client_name(void) return client_name; } + +std::vector sensor::utils::tokenize(const std::string &in, const char *delim) +{ + std::vector tokens; + char *input = g_strdup(in.c_str()); + + char *save = NULL; + char *token = strtok_r(input, delim, &save); + + while (token != NULL) { + tokens.push_back(token); + token = strtok_r(NULL, delim, &save); + } + + g_free(input); + return tokens; +} diff --git a/src/shared/sensor_utils.h b/src/shared/sensor_utils.h index c6ab64d..7e31f6d 100644 --- a/src/shared/sensor_utils.h +++ b/src/shared/sensor_utils.h @@ -22,6 +22,8 @@ #include #include +#include +#include namespace sensor { @@ -33,6 +35,8 @@ namespace utils { const char* get_client_name(void); bool get_proc_name(pid_t pid, char *process_name); + + std::vector tokenize(const std::string &in, const char *delim); } } -- 2.7.4 From fc87b7c292bb3ab6d9f735c2b52b059a40d17fa9 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 11:00:27 +0900 Subject: [PATCH 09/16] sensord: check privilege everytime for every request - check privilege for get_sensor/get_sensor_list - check privilege for all controls Change-Id: I7148c7d506bb1eaa01046e60b1b81a0ce5ec899a Signed-off-by: kibak.yoon --- src/client/sensor_manager.cpp | 64 +++++++++++++++++++++++++++++------ src/client/sensor_manager.h | 1 + src/server/sensor_listener_proxy.cpp | 6 ++++ src/server/sensor_listener_proxy.h | 1 + src/server/server_channel_handler.cpp | 61 +++++++++++++++++++++++++++++++++ src/server/server_channel_handler.h | 5 +++ src/shared/command_types.h | 6 ++++ 7 files changed, 134 insertions(+), 10 deletions(-) diff --git a/src/client/sensor_manager.cpp b/src/client/sensor_manager.cpp index 5602312..c50cdae 100644 --- a/src/client/sensor_manager.cpp +++ b/src/client/sensor_manager.cpp @@ -27,6 +27,8 @@ #include #include +#define SIZE_STR_SENSOR_ALL 27 + using namespace sensor; class manager_handler : public ipc::channel_handler @@ -81,20 +83,22 @@ int sensor_manager::get_sensors(sensor_type_t type, sensor_t **list, int *count) int sensor_manager::get_sensor(const char *uri, sensor_t *sensor) { - sensor_info *info; - - info = get_info(uri); - if (!info) { + if (!is_supported(uri)) { *sensor = NULL; return -ENODATA; } + sensor_info *info = get_info(uri); + retv_if(!info, -EACCES); + *sensor = (sensor_t)info; return OP_SUCCESS; } int sensor_manager::get_sensors(const char *uri, sensor_t **list, int *count) { + retv_if(!is_supported(uri), -ENODATA); + std::vector infos; int size; @@ -130,8 +134,13 @@ bool sensor_manager::is_supported(sensor_t sensor) bool sensor_manager::is_supported(const char *uri) { + if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) + return true; + for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { - if ((*it).get_uri() == uri) + std::size_t found = (*it).get_uri().rfind(uri); + + if (found != std::string::npos) return true; } @@ -260,9 +269,34 @@ bool sensor_manager::get_sensors_internal(void) return true; } +bool sensor_manager::has_privilege(std::string &uri) +{ + retvm_if(!is_connected(), false, "Failed to get sensors"); + + bool ret; + ipc::message msg; + ipc::message reply; + cmd_has_privilege_t buf = {0, }; + + msg.set_type(CMD_HAS_PRIVILEGE); + memcpy(buf.sensor, uri.c_str(), uri.size()); + msg.enclose((const char *)&buf, sizeof(buf)); + + ret = m_channel->send_sync(&msg); + retvm_if(!ret, false, "Failed to send message"); + + ret = m_channel->read_sync(reply); + retvm_if(!ret, false, "Failed to receive message"); + + if (reply.header()->err == OP_SUCCESS) + return true; + + return false; +} + sensor_info *sensor_manager::get_info(const char *uri) { - if (strncmp(uri, utils::get_uri(ALL_SENSOR), 27) == 0) + if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) return &m_infos[0]; for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { @@ -271,7 +305,11 @@ sensor_info *sensor_manager::get_info(const char *uri) if (found == std::string::npos) continue; - return &*it; + if ((*it).get_privilege().empty()) + return &*it; + + if (has_privilege((*it).get_uri())) + return &*it; } return NULL; @@ -282,16 +320,22 @@ std::vector sensor_manager::get_infos(const char *uri) std::vector infos; bool all = false; - if (strncmp(uri, utils::get_uri(ALL_SENSOR), 27) == 0) + if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) all = true; - for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { +for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { std::size_t found = (*it).get_uri().rfind(uri); if (!all && found == std::string::npos) continue; - infos.push_back(&*it); + if ((*it).get_privilege().empty()) { + infos.push_back(&*it); + continue; + } + + if (has_privilege((*it).get_uri())) + infos.push_back(&*it); } return infos; diff --git a/src/client/sensor_manager.h b/src/client/sensor_manager.h index 35ae863..5cb7d40 100644 --- a/src/client/sensor_manager.h +++ b/src/client/sensor_manager.h @@ -65,6 +65,7 @@ private: void decode_sensors(const char *buf, std::vector &infos); bool get_sensors_internal(void); + bool has_privilege(std::string &uri); sensor_info *get_info(const char *uri); std::vector get_infos(const char *uri); diff --git a/src/server/sensor_listener_proxy.cpp b/src/server/sensor_listener_proxy.cpp index 29608b0..b542af8 100644 --- a/src/server/sensor_listener_proxy.cpp +++ b/src/server/sensor_listener_proxy.cpp @@ -127,3 +127,9 @@ int sensor_listener_proxy::get_data(sensor_data_t **data, int *len) /* TODO : caching the last data & retry logic if there is no data */ return m_sensor->get_data(data, len); } + +std::string sensor_listener_proxy::get_required_privileges(void) +{ + sensor_info info = m_sensor->get_sensor_info(); + return info.get_privilege(); +} diff --git a/src/server/sensor_listener_proxy.h b/src/server/sensor_listener_proxy.h index 709f057..583cf36 100644 --- a/src/server/sensor_listener_proxy.h +++ b/src/server/sensor_listener_proxy.h @@ -48,6 +48,7 @@ public: int set_attribute(int attribute, const char *value, int len); int flush(void); int get_data(sensor_data_t **data, int *len); + std::string get_required_privileges(void); private: uint32_t m_id; diff --git a/src/server/server_channel_handler.cpp b/src/server/server_channel_handler.cpp index a34f58f..1c18d1d 100644 --- a/src/server/server_channel_handler.cpp +++ b/src/server/server_channel_handler.cpp @@ -22,8 +22,13 @@ #include #include #include +#include #include +#include "permission_checker.h" + +#define PRIV_DELIMINATOR ";" + using namespace sensor; using namespace ipc; @@ -78,6 +83,8 @@ void server_channel_handler::read(channel *ch, message &msg) err = provider_disconnect(ch, msg); break; case CMD_PROVIDER_POST: err = provider_post(ch, msg); break; + case CMD_HAS_PRIVILEGE: + err = has_privileges(ch, msg); break; default: break; } @@ -118,6 +125,8 @@ int server_channel_handler::listener_connect(channel *ch, message &msg) sensor_listener_proxy *listener = new(std::nothrow) sensor_listener_proxy(listener_id, sensor, ch); retvm_if(!listener, OP_ERROR, "Failed to allocate memory"); + retvm_if(!has_privileges(ch->get_fd(), listener->get_required_privileges()), + -EACCES, "Permission denied"); buf.listener_id = listener_id; @@ -142,6 +151,9 @@ int server_channel_handler::listener_disconnect(channel *ch, message &msg) uint32_t id = m_listeners[ch]->get_id(); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); + delete m_listeners[ch]; m_listeners.erase(ch); @@ -154,6 +166,8 @@ int server_channel_handler::listener_start(channel *ch, message &msg) { auto it = m_listeners.find(ch); retv_if(it == m_listeners.end(), -EINVAL); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); int ret = m_listeners[ch]->start(); retv_if(ret < 0, ret); @@ -165,6 +179,8 @@ int server_channel_handler::listener_stop(channel *ch, message &msg) { auto it = m_listeners.find(ch); retv_if(it == m_listeners.end(), -EINVAL); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); int ret = m_listeners[ch]->stop(); retv_if(ret < 0, ret); @@ -178,6 +194,8 @@ int server_channel_handler::listener_attr_int(channel *ch, message &msg) auto it = m_listeners.find(ch); retv_if(it == m_listeners.end(), -EINVAL); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); cmd_listener_attr_int_t buf; msg.disclose((char *)&buf); @@ -203,6 +221,8 @@ int server_channel_handler::listener_attr_str(channel *ch, message &msg) { auto it = m_listeners.find(ch); retv_if(it == m_listeners.end(), -EINVAL); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); cmd_listener_attr_str_t buf; msg.disclose((char *)&buf); @@ -215,6 +235,11 @@ int server_channel_handler::listener_attr_str(channel *ch, message &msg) int server_channel_handler::listener_get_data(channel *ch, message &msg) { + auto it = m_listeners.find(ch); + retv_if(it == m_listeners.end(), -EINVAL); + retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()), + -EACCES, "Permission denied"); + return send_reply(ch, OP_ERROR); } @@ -233,9 +258,45 @@ int server_channel_handler::provider_post(channel *ch, message &msg) return send_reply(ch, OP_ERROR); } +int server_channel_handler::has_privileges(channel *ch, message &msg) +{ + sensor_handler *sensor; + cmd_has_privilege_t buf; + msg.disclose((char *)&buf); + + sensor = m_manager->get_sensor(buf.sensor); + retv_if(!sensor, OP_ERROR); + + sensor_info info = sensor->get_sensor_info(); + + if (!has_privileges(ch->get_fd(), info.get_privilege())) + return OP_ERROR; + + return send_reply(ch, OP_SUCCESS); +} + int server_channel_handler::send_reply(channel *ch, int error) { message reply(error); retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply"); return OP_SUCCESS; } + +bool server_channel_handler::has_privilege(int fd, std::string &priv) +{ + static permission_checker checker; + return checker.has_permission(fd, priv); +} + +bool server_channel_handler::has_privileges(int fd, std::string priv) +{ + std::vector privileges; + privileges = utils::tokenize(priv, PRIV_DELIMINATOR); + + for (auto it = privileges.begin(); it != privileges.end(); ++it) { + if (!has_privilege(fd, *it)) + return false; + } + + return true; +} diff --git a/src/server/server_channel_handler.h b/src/server/server_channel_handler.h index d48ff7e..1ccc998 100644 --- a/src/server/server_channel_handler.h +++ b/src/server/server_channel_handler.h @@ -58,6 +58,11 @@ private: int provider_disconnect(ipc::channel *ch, ipc::message &msg); int provider_post(ipc::channel *ch, ipc::message &msg); + int has_privileges(ipc::channel *ch, ipc::message &msg); + + bool has_privilege(int fd, std::string &priv); + bool has_privileges(int fd, std::string priv); + int send_reply(ipc::channel *ch, int error); sensor_manager *m_manager; diff --git a/src/shared/command_types.h b/src/shared/command_types.h index 81d4a21..6b5e0c6 100644 --- a/src/shared/command_types.h +++ b/src/shared/command_types.h @@ -51,6 +51,8 @@ enum cmd_type_e { CMD_PROVIDER_DISCONNECT, CMD_PROVIDER_POST, + CMD_HAS_PRIVILEGE, + CMD_CNT, }; @@ -113,4 +115,8 @@ typedef struct { sensorhub_data_t base_data; } cmd_provider_post_t; +typedef struct { + char sensor[NAME_MAX]; +} cmd_has_privilege_t ; + #endif /* __COMMAND_TYPES_H__ */ -- 2.7.4 From 90758547f668fe9d8932f0099aee552e47d9a2a9 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 11:24:49 +0900 Subject: [PATCH 10/16] sensord: fix to return approprivate error Change-Id: I4d1ca524b4041232ed7c8e350f3261b264112ceb Signed-off-by: kibak.yoon --- src/client/sensor_internal.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/sensor_internal.cpp b/src/client/sensor_internal.cpp index 364eb92..a0b683f 100644 --- a/src/client/sensor_internal.cpp +++ b/src/client/sensor_internal.cpp @@ -117,7 +117,7 @@ API int sensord_get_default_sensor(sensor_type_t type, sensor_t *sensor) { int ret = OP_ERROR; - retvm_if(!sensor, -EPERM, "Invalid parameter[%#x]", sensor); + retvm_if(!sensor, -EINVAL, "Invalid parameter[%#x]", sensor); retvm_if(!manager.connect(), -EIO, "Failed to connect"); ret = manager.get_sensor(type, sensor); @@ -548,7 +548,7 @@ API int sensord_external_connect(const char *key, sensor_external_command_cb_t c * 3. first connection(client) * 4. cmd_connect for external sensor with key */ - retvm_if(!key, -EPERM, "Invalid key"); + retvm_if(!key, -EINVAL, "Invalid key"); return 0; } -- 2.7.4 From 135fdeb7dbdccf1d255ba692772bbf87c28ca1f7 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 03:06:21 +0900 Subject: [PATCH 11/16] sensord: support original path to load HAL library Change-Id: Id32a8e5d2f008766542ee9a46e5757a284667630 Signed-off-by: kibak.yoon --- src/server/sensor_loader.cpp | 14 +++++++++++++- src/server/sensor_manager.cpp | 2 ++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/server/sensor_loader.cpp b/src/server/sensor_loader.cpp index d46a5cf..4d1d20e 100644 --- a/src/server/sensor_loader.cpp +++ b/src/server/sensor_loader.cpp @@ -19,6 +19,9 @@ #include "sensor_loader.h" +#include +#include +#include #include #include #include @@ -112,6 +115,7 @@ bool sensor_loader::get_module_paths(const std::string &dir_path, std::vector Date: Wed, 12 Apr 2017 12:28:15 +0900 Subject: [PATCH 12/16] sensord: rename information list/map properly Change-Id: I1e56466e0ef00c428196cb5df1340839236c9ab5 Signed-off-by: kibak.yoon --- src/client/sensor_manager.cpp | 12 ++++++------ src/client/sensor_manager.h | 4 ++-- src/shared/event_loop.cpp | 14 +++++++------- src/shared/event_loop.h | 2 +- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/client/sensor_manager.cpp b/src/client/sensor_manager.cpp index c50cdae..4be1065 100644 --- a/src/client/sensor_manager.cpp +++ b/src/client/sensor_manager.cpp @@ -124,7 +124,7 @@ bool sensor_manager::is_supported(sensor_t sensor) { retvm_if(!sensor, false, "Invalid parameter[%#x]", sensor); - for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { + for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) { if (&*it == sensor) return true; } @@ -137,7 +137,7 @@ bool sensor_manager::is_supported(const char *uri) if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) return true; - for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { + for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) { std::size_t found = (*it).get_uri().rfind(uri); if (found != std::string::npos) @@ -264,7 +264,7 @@ bool sensor_manager::get_sensors_internal(void) reply.disclose(buf); - decode_sensors(buf, m_infos); + decode_sensors(buf, m_sensors); return true; } @@ -297,9 +297,9 @@ bool sensor_manager::has_privilege(std::string &uri) sensor_info *sensor_manager::get_info(const char *uri) { if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) - return &m_infos[0]; + return &m_sensors[0]; - for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { + for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) { std::size_t found = (*it).get_uri().rfind(uri); if (found == std::string::npos) @@ -323,7 +323,7 @@ std::vector sensor_manager::get_infos(const char *uri) if (strncmp(uri, utils::get_uri(ALL_SENSOR), SIZE_STR_SENSOR_ALL) == 0) all = true; -for (auto it = m_infos.begin(); it != m_infos.end(); ++it) { + for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) { std::size_t found = (*it).get_uri().rfind(uri); if (!all && found == std::string::npos) diff --git a/src/client/sensor_manager.h b/src/client/sensor_manager.h index 5cb7d40..8839943 100644 --- a/src/client/sensor_manager.h +++ b/src/client/sensor_manager.h @@ -54,7 +54,7 @@ public: /* int unregister_sensor(const char *uri) */ private: - typedef std::vector sensor_infos_t; + typedef std::vector sensor_list_t; bool init(void); void deinit(void); @@ -75,7 +75,7 @@ private: ipc::event_loop m_loop; std::atomic m_connected; - sensor_infos_t m_infos; + sensor_list_t m_sensors; }; } diff --git a/src/shared/event_loop.cpp b/src/shared/event_loop.cpp index 73854b5..1b569a1 100644 --- a/src/shared/event_loop.cpp +++ b/src/shared/event_loop.cpp @@ -127,7 +127,7 @@ uint64_t event_loop::add_event(const int fd, const event_condition cond, event_h g_source_set_callback(src, (GSourceFunc) g_io_handler, info, NULL); g_source_attach(src, g_main_loop_get_context(m_mainloop)); - m_infos[id] = info; + m_handlers[id] = info; /* _D("Added[%llu](fd:%d)", id, fd); */ return id; @@ -151,14 +151,14 @@ uint64_t event_loop::add_idle_event(unsigned int priority, idle_handler *handler bool event_loop::remove_event(uint64_t id, bool close_channel) { - auto it = m_infos.find(id); - retv_if(it == m_infos.end(), false); + auto it = m_handlers.find(id); + retv_if(it == m_handlers.end(), false); if (close_channel) g_io_channel_shutdown(it->second->g_ch, TRUE, NULL); release_info(it->second); - m_infos.erase(it); + m_handlers.erase(it); /* _D("Removed[%llu]", id); */ return true; @@ -166,10 +166,10 @@ bool event_loop::remove_event(uint64_t id, bool close_channel) void event_loop::remove_all_events(void) { - auto it = m_infos.begin(); - while (it != m_infos.end()) { + auto it = m_handlers.begin(); + while (it != m_handlers.end()) { release_info(it->second); - it = m_infos.erase(it); + it = m_handlers.erase(it); } } diff --git a/src/shared/event_loop.h b/src/shared/event_loop.h index 934a8b4..870e6a3 100644 --- a/src/shared/event_loop.h +++ b/src/shared/event_loop.h @@ -92,7 +92,7 @@ private: std::atomic m_running; std::atomic m_terminating; std::atomic m_sequence; - std::map m_infos; + std::map m_handlers; int m_term_fd; }; -- 2.7.4 From d6fec29ca61fe6634f9c3dc19cd4b2ea84e021fc Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 12:39:16 +0900 Subject: [PATCH 13/16] sensord: fix warnings detected from static analysis - fix member variable initialziation ordered warnings - add missing breaks in switch-case statement - check the range of index Change-Id: Iaf75452578b69b9a7952321d25db75e53be7ca81 Signed-off-by: kibak.yoon --- src/client/sensor_listener.cpp | 2 ++ src/sensorctl/sensor_adapter.cpp | 2 ++ src/sensorctl/test_bench.cpp | 1 + src/server/external_sensor_handler.cpp | 2 +- src/server/fusion_sensor_handler.cpp | 5 ++--- src/server/fusion_sensor_handler.h | 1 - src/shared/ipc_server.cpp | 3 +++ src/shared/socket.cpp | 5 ++--- 8 files changed, 13 insertions(+), 8 deletions(-) diff --git a/src/client/sensor_listener.cpp b/src/client/sensor_listener.cpp index da9dbe8..a5c4af2 100644 --- a/src/client/sensor_listener.cpp +++ b/src/client/sensor_listener.cpp @@ -47,9 +47,11 @@ public: case CMD_LISTENER_EVENT: if (m_listener->get_event_handler()) m_listener->get_event_handler()->read(ch, msg); + break; case CMD_LISTENER_ACC_EVENT: if (m_listener->get_accuracy_handler()) m_listener->get_accuracy_handler()->read(ch, msg); + break; } } diff --git a/src/sensorctl/sensor_adapter.cpp b/src/sensorctl/sensor_adapter.cpp index 9ed2b24..82a54a2 100644 --- a/src/sensorctl/sensor_adapter.cpp +++ b/src/sensorctl/sensor_adapter.cpp @@ -73,6 +73,8 @@ bool sensor_adapter::start(sensor_info info, int &handle) err = sensord_get_sensors(info.type, &sensors, &count); ASSERT_EQ(err, 0); + ASSERT_LT(info.index, count); + ASSERT_GE(info.index, 0); handle = sensord_connect(sensors[info.index]); ASSERT_GE(handle, 0); diff --git a/src/sensorctl/test_bench.cpp b/src/sensorctl/test_bench.cpp index 191fb0d..201a7f5 100644 --- a/src/sensorctl/test_bench.cpp +++ b/src/sensorctl/test_bench.cpp @@ -51,6 +51,7 @@ void test_option::set_options(int argc, char *argv[]) test_case::test_case(const std::string &group, const std::string &name) : m_group(group) , m_name(name) +, m_func(NULL) { test_bench::register_testcase(group, this); } diff --git a/src/server/external_sensor_handler.cpp b/src/server/external_sensor_handler.cpp index 110e15b..7ace9a5 100644 --- a/src/server/external_sensor_handler.cpp +++ b/src/server/external_sensor_handler.cpp @@ -60,8 +60,8 @@ int external_sensor_notifier::notify(void) external_sensor_handler::external_sensor_handler(const sensor_info &info, external_sensor *sensor) : m_info(info) -, m_sensor(sensor) , m_notifier(NULL) +, m_policy(OP_DEFAULT) { init(); } diff --git a/src/server/fusion_sensor_handler.cpp b/src/server/fusion_sensor_handler.cpp index 44c794a..ace60b8 100644 --- a/src/server/fusion_sensor_handler.cpp +++ b/src/server/fusion_sensor_handler.cpp @@ -29,7 +29,6 @@ fusion_sensor_handler::fusion_sensor_handler(const sensor_info &info, fusion_sensor *sensor) : m_info(info) , m_sensor(sensor) -, m_policy(OP_DEFAULT) { } @@ -187,7 +186,7 @@ int fusion_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, int3 policy = m_sensor->set_attribute(ob, attr, value); retv_if(policy <= OP_ERROR, policy); - if (m_policy == OP_DEFAULT) { + if (policy == OP_DEFAULT) { /* default logic */ } @@ -203,7 +202,7 @@ int fusion_sensor_handler::set_attribute(sensor_observer *ob, int32_t attr, cons policy = m_sensor->set_attribute(ob, attr, value, len); retv_if(policy <= OP_ERROR, policy); - if (m_policy == OP_DEFAULT) { + if (policy == OP_DEFAULT) { /* default logic */ } diff --git a/src/server/fusion_sensor_handler.h b/src/server/fusion_sensor_handler.h index d16278f..151bb16 100644 --- a/src/server/fusion_sensor_handler.h +++ b/src/server/fusion_sensor_handler.h @@ -71,7 +71,6 @@ private: std::unordered_map m_interval_map; std::unordered_map m_batch_latency_map; - int m_policy; }; } diff --git a/src/shared/ipc_server.cpp b/src/shared/ipc_server.cpp index 9723a98..dba54f0 100644 --- a/src/shared/ipc_server.cpp +++ b/src/shared/ipc_server.cpp @@ -30,6 +30,9 @@ using namespace ipc; #define MAX_CONNECTIONS 1000 ipc_server::ipc_server(const std::string &path) +: m_event_loop(NULL) +, m_handler(NULL) +, m_accept_handler(NULL) { m_accept_sock.create(path); } diff --git a/src/shared/socket.cpp b/src/shared/socket.cpp index 239e554..b29ba96 100644 --- a/src/shared/socket.cpp +++ b/src/shared/socket.cpp @@ -375,12 +375,11 @@ bool socket::set_recv_timeout(int sec) bool socket::set_sock_type(int type) { socklen_t opt_len; - int sock_type; - opt_len = sizeof(sock_type); + opt_len = sizeof(type); retvm_if(m_sock_fd < 0, false, "Invalid socket[%d]", m_sock_fd); - if (setsockopt(m_sock_fd, SOL_SOCKET, SO_TYPE, &sock_type, opt_len) < 0) { + if (setsockopt(m_sock_fd, SOL_SOCKET, SO_TYPE, &type, opt_len) < 0) { _ERRNO(errno, _E, "Failed to setsockopt[%d]", m_sock_fd); return false; } -- 2.7.4 From 4a99e65c8d000f7dd4b90c94f3c8f0fbcc8e4fc5 Mon Sep 17 00:00:00 2001 From: Mu-Woong Lee Date: Wed, 12 Apr 2017 21:30:47 +0900 Subject: [PATCH 14/16] Rename packages in a more conventional way: sensord & sensord-dummy Change-Id: I5a86ca6256fc0781cccea5e6806520c4d3b9822b Signed-off-by: Mu-Woong Lee --- packaging/sensord.spec | 78 ++++++++++++++++++++++++++++---------------------- 1 file changed, 43 insertions(+), 35 deletions(-) diff --git a/packaging/sensord.spec b/packaging/sensord.spec index cb86503..e4dfaf3 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -1,6 +1,6 @@ Name: sensord Summary: Sensor daemon -Version: 2.0.10 +Version: 2.0.11 Release: 1 Group: System/Sensor Framework License: Apache-2.0 @@ -18,34 +18,38 @@ BuildRequires: pkgconfig(cynara-creds-socket) BuildRequires: pkgconfig(cynara-client) BuildRequires: pkgconfig(cynara-session) -Provides: %{name}-profile_tv = %{version}-%{release} -# For backward compatibility - -%description -Sensor daemon - -%package genuine -Summary: Genuine Sensor Framework service daemon and shared library -Requires: %{name} = %{version}-%{release} +Requires: %{name}-dummy = %{version}-%{release} Provides: %{name}-profile_mobile = %{version}-%{release} Provides: %{name}-profile_wearable = %{version}-%{release} Provides: %{name}-profile_ivi = %{version}-%{release} Provides: %{name}-profile_common = %{version}-%{release} +%global __provides_exclude ^.*-genuine\\.so.*$ + +%description +This package provides the fully functional internal API library and the service daemon +of the Sensor Framework. The library replaces the dummy library installed by %{name}-dummy. + + +%package dummy +Summary: Sensor Framework 'dummy' library +Provides: libsensord +Provides: %{name}-profile_tv = %{version}-%{release} + +%description dummy +This package provides the dummy library of the sensor internal API. +Installing %{name} replaces this dummy library with the actually functional library. -%description genuine -Binary replacement for sensord. -This genuine sensord package contains actually working shared library -of the sensor internal APIs and the sensor service daemon. -If you want to keep using %{name} after uninstalling this, you need to reinstall %{name}. %package devel Summary: Internal Sensor API (Development) Group: System/Development -Requires: %{name} = %{version}-%{release} +Requires: %{name}-dummy = %{version}-%{release} +Provides: libsensord-devel %description devel Internal Sensor API (Development) + %package -n sensor-hal-devel Summary: Sensord HAL interface Group: System/Development @@ -53,6 +57,7 @@ Group: System/Development %description -n sensor-hal-devel Sensord HAL interface + %package -n sensor-test Summary: Sensord library Group: System/Testing @@ -60,14 +65,15 @@ Group: System/Testing %description -n sensor-test Sensor functional testing + # These dummy packages will be removed later. %package -n libsensord Summary: Dummy package for backward compatibility Requires: sensord %description -n libsensord -Without this dummy package, obs may reports several 'unresolvable' issues. -This is a temporal solution to handle such cases. +A yaml requires libsensord explicitly. This is a temporal solution to prevent image creation failures. + %package -n libsensord-devel Summary: Dummy package for backward compatibility @@ -77,6 +83,7 @@ Requires: sensord-devel Some packages require libsensord-devel directly, and it causes local gbs build failures with the old build snapshots. This is a temporal solution to handle such cases. + %prep %setup -q @@ -100,35 +107,35 @@ install -m 0644 %SOURCE2 %{buildroot}%{_unitdir} ln -s libsensor.so.2 %{buildroot}%{_libdir}/libsensor.so.1 %post -/sbin/ldconfig - -%postun -/sbin/ldconfig - -%files -%manifest packaging/sensord.manifest -%{_libdir}/libsensor.so.* -%license LICENSE.APLv2 - -%post genuine pushd %{_libdir} ln -sf libsensor-genuine.so.%{version} libsensor.so.%{version} chsmack -a "_" libsensor.so.%{version} popd /sbin/ldconfig -%preun genuine -echo "You need to reinstall %{name}, if you need to keep using the APIs after uinstalling this." +%preun +echo "You need to reinstall %{name}-dummy to keep using the APIs after uninstalling this." -%files genuine +%files %manifest packaging/sensord.manifest -%{_libdir}/libsensord-shared.so %{_libdir}/libsensor-genuine.so.* +%{_libdir}/libsensord-shared.so %{_bindir}/sensord %{_unitdir}/sensord.service %{_unitdir}/sensord.socket %{_unitdir}/multi-user.target.wants/sensord.service %{_unitdir}/sockets.target.wants/sensord.socket +%license LICENSE.APLv2 + + +%post dummy +/sbin/ldconfig + +%files dummy +%manifest packaging/sensord.manifest +%{_libdir}/libsensor.so.* +%license LICENSE.APLv2 + %files devel %manifest packaging/sensord.manifest @@ -137,15 +144,16 @@ echo "You need to reinstall %{name}, if you need to keep using the APIs after ui %{_libdir}/libsensor.so %{_libdir}/pkgconfig/sensor.pc + %files -n sensor-hal-devel %manifest packaging/sensord.manifest %{_includedir}/sensor/sensor_hal*.h + %files -n sensor-test %{_bindir}/sensorctl + %files -n libsensord -%license LICENSE.APLv2 %files -n libsensord-devel -%license LICENSE.APLv2 -- 2.7.4 From d5a83bb3924e79727fce9891c10e0df0bb510ae4 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 18:54:08 +0900 Subject: [PATCH 15/16] sensord: modify sensor plugin interface - rename from get_sensors to get_sensor_info() - change the parameter of update() from id to URI * [TBD] the name of sensor_notifier Change-Id: Ie50afe75a3517847d17e259a6bf317095a827cc7 Signed-off-by: kibak.yoon --- include/external_sensor.h | 4 +-- include/fusion_sensor.h | 11 +++++-- src/server/external_sensor_handler.cpp | 3 +- src/server/fusion_sensor_handler.cpp | 51 ++++++++++++++++--------------- src/server/fusion_sensor_handler.h | 15 +++++++-- src/server/sensor_event_handler.cpp | 2 +- src/server/sensor_manager.cpp | 56 +++++++++++++++------------------- 7 files changed, 77 insertions(+), 65 deletions(-) diff --git a/include/external_sensor.h b/include/external_sensor.h index d34cf96..d029419 100644 --- a/include/external_sensor.h +++ b/include/external_sensor.h @@ -68,8 +68,8 @@ public: inline uint32_t get_version(void) { return EXTERNAL_SENSOR_VERSION(1, 0); } - virtual int get_sensors(const sensor_info2_t **sensors) = 0; - virtual void set_notifier(sensor_notifier *notifier) = 0; + virtual int get_sensor_info(const sensor_info2_t **info) = 0; + virtual int set_notifier(sensor_notifier *notifier) = 0; virtual int get_data(sensor_data_t **data, int *len) = 0; virtual int start(observer_h ob) diff --git a/include/fusion_sensor.h b/include/fusion_sensor.h index 6fa6d09..f772e3d 100644 --- a/include/fusion_sensor.h +++ b/include/fusion_sensor.h @@ -49,6 +49,11 @@ typedef int (*create_fusion_t)(fusion_sensor_t **sensors); typedef void *observer_h; +typedef struct required_sensor_s { + uint32_t id; + const char *uri; +} required_sensor_s; + /* * Sensor interface */ @@ -58,11 +63,11 @@ public: inline uint32_t get_version(void) { return FUSION_SENSOR_VERSION(1, 0); } - virtual int get_sensors(const sensor_info2_t **sensors) = 0; - virtual void get_required_sensors(std::vector &sensors) = 0; + virtual int get_sensor_info(const sensor_info2_t **info) = 0; + virtual int get_required_sensors(const required_sensor_s **info) = 0; /* if update() returns positive value, then get_data() is called */ - virtual int update(const char *uri, sensor_data_t *data, int len) = 0; + virtual int update(uint32_t id, sensor_data_t *data, int len) = 0; virtual int get_data(sensor_data_t **data, int *len) = 0; virtual int start(observer_h ob) diff --git a/src/server/external_sensor_handler.cpp b/src/server/external_sensor_handler.cpp index 7ace9a5..15b8bae 100644 --- a/src/server/external_sensor_handler.cpp +++ b/src/server/external_sensor_handler.cpp @@ -52,9 +52,8 @@ int external_sensor_notifier::notify(void) /* TODO: pointer would be better */ sensor_info info = m_sensor->get_sensor_info(); - std::string uri = info.get_type_uri(); - return m_sensor->notify(uri.c_str(), data, len); + return m_sensor->notify(info.get_uri().c_str(), data, len); } external_sensor_handler::external_sensor_handler(const sensor_info &info, diff --git a/src/server/fusion_sensor_handler.cpp b/src/server/fusion_sensor_handler.cpp index ace60b8..05ab314 100644 --- a/src/server/fusion_sensor_handler.cpp +++ b/src/server/fusion_sensor_handler.cpp @@ -34,18 +34,23 @@ fusion_sensor_handler::fusion_sensor_handler(const sensor_info &info, fusion_sensor_handler::~fusion_sensor_handler() { + m_required_sensors.clear(); } -void fusion_sensor_handler::add_required_sensor(sensor_handler *sensor) +void fusion_sensor_handler::add_required_sensor(uint32_t id, sensor_handler *sensor) { - m_required_sensors.push_back(sensor); + sensor_info info = sensor->get_sensor_info(); + m_required_sensors.emplace(info.get_uri(), required_sensor(id, sensor)); } int fusion_sensor_handler::update(const char *uri, ipc::message *msg) { retv_if(!m_sensor, -EINVAL); - if (m_sensor->update(uri, (sensor_data_t *)msg->body(), msg->size()) < 0) + auto it = m_required_sensors.find(uri); + retv_if(it == m_required_sensors.end(), OP_SUCCESS); + + if (m_sensor->update(it->second.id, (sensor_data_t *)msg->body(), msg->size()) < 0) return OP_SUCCESS; sensor_data_t *data; @@ -54,9 +59,7 @@ int fusion_sensor_handler::update(const char *uri, ipc::message *msg) if (m_sensor->get_data(&data, &len) < 0) return OP_ERROR; - std::string fsensor_uri = m_info.get_type_uri(); - - return notify(fsensor_uri.c_str(), data, len); + return notify(m_info.get_uri().c_str(), data, len); } const sensor_info &fusion_sensor_handler::get_sensor_info(void) @@ -226,9 +229,9 @@ int fusion_sensor_handler::flush(sensor_observer *ob) int fusion_sensor_handler::start_internal(void) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->start(this) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->start(this) < 0) return OP_ERROR; } @@ -237,9 +240,9 @@ int fusion_sensor_handler::start_internal(void) int fusion_sensor_handler::stop_internal(void) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->stop(this) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->stop(this) < 0) return OP_ERROR; } @@ -248,9 +251,9 @@ int fusion_sensor_handler::stop_internal(void) int fusion_sensor_handler::set_interval_internal(int32_t interval) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->set_interval(this, interval) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->set_interval(this, interval) < 0) return OP_ERROR; } @@ -259,9 +262,9 @@ int fusion_sensor_handler::set_interval_internal(int32_t interval) int fusion_sensor_handler::set_batch_latency_internal(int32_t latency) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->set_batch_latency(this, latency) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->set_batch_latency(this, latency) < 0) return OP_ERROR; } @@ -270,9 +273,9 @@ int fusion_sensor_handler::set_batch_latency_internal(int32_t latency) int fusion_sensor_handler::set_attribute_internal(int32_t attr, int32_t value) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->set_attribute(this, attr, value) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->set_attribute(this, attr, value) < 0) return OP_ERROR; } @@ -281,9 +284,9 @@ int fusion_sensor_handler::set_attribute_internal(int32_t attr, int32_t value) int fusion_sensor_handler::set_attribute_internal(int32_t attr, const char *value, int len) { - int size = m_required_sensors.size(); - for (int i = 0; i < size; ++i) { - if (m_required_sensors[i]->set_attribute(this, attr, value, len) < 0) + auto it = m_required_sensors.begin(); + for (; it != m_required_sensors.end(); ++it) { + if (it->second.sensor->set_attribute(this, attr, value, len) < 0) return OP_ERROR; } diff --git a/src/server/fusion_sensor_handler.h b/src/server/fusion_sensor_handler.h index 151bb16..0bd1fa6 100644 --- a/src/server/fusion_sensor_handler.h +++ b/src/server/fusion_sensor_handler.h @@ -30,13 +30,24 @@ namespace sensor { +class required_sensor { +public: + required_sensor(uint32_t _id, sensor_handler *_sensor) + : id(_id) + , sensor(_sensor) + {} + + uint32_t id; + sensor_handler *sensor; +}; + class fusion_sensor_handler : public sensor_handler, public sensor_observer { public: fusion_sensor_handler(const sensor_info &info, fusion_sensor *sensor); ~fusion_sensor_handler(); - void add_required_sensor(sensor_handler *sensor); + void add_required_sensor(uint32_t id, sensor_handler *sensor); /* subscriber */ int update(const char *uri, ipc::message *msg); @@ -67,7 +78,7 @@ private: sensor_info m_info; fusion_sensor *m_sensor; - std::vector m_required_sensors; + std::unordered_map m_required_sensors; std::unordered_map m_interval_map; std::unordered_map m_batch_latency_map; diff --git a/src/server/sensor_event_handler.cpp b/src/server/sensor_event_handler.cpp index de13006..4fac18d 100644 --- a/src/server/sensor_event_handler.cpp +++ b/src/server/sensor_event_handler.cpp @@ -62,7 +62,7 @@ bool sensor_event_handler::handle(int fd, ipc::event_condition condition) info = m_sensor->get_sensor_info(); //_I("[Data] allocate %p", data); - if (m_sensor->notify(info.get_type_uri().c_str(), data, length) < 0) { + if (m_sensor->notify(info.get_uri().c_str(), data, length) < 0) { free(data); } info.clear(); diff --git a/src/server/sensor_manager.cpp b/src/server/sensor_manager.cpp index 7aa04fe..9a06489 100644 --- a/src/server/sensor_manager.cpp +++ b/src/server/sensor_manager.cpp @@ -187,41 +187,37 @@ void sensor_manager::create_physical_sensors(device_sensor_registry_t &devices, void sensor_manager::create_fusion_sensors(fusion_sensor_registry_t &fsensors) { const sensor_info2_t *info; + const required_sensor_s *required_sensors; fusion_sensor_handler *fsensor; - std::vector req_names; + sensor_handler *sensor = NULL; for (auto it = fsensors.begin(); it != fsensors.end(); ++it) { - int count = (*it)->get_sensors(&info); - - for (int i = 0; i < count; ++i) { - bool support = true; - req_names.clear(); + bool support = true; - fsensor = new(std::nothrow) fusion_sensor_handler(info[i], it->get()); - retm_if(!fsensor, "Failed to allocate memory"); + (*it)->get_sensor_info(&info); - (*it)->get_required_sensors(req_names); - for (unsigned int j = 0; j < req_names.size(); ++j) { - sensor_handler *sensor; - sensor = get_sensor_by_type(req_names[j]); + fsensor = new(std::nothrow) fusion_sensor_handler(info[0], it->get()); + retm_if(!fsensor, "Failed to allocate memory"); - if (sensor == NULL) { - support = false; - break; - } + int count = (*it)->get_required_sensors(&required_sensors); + for (int i = 0; i < count; ++i) { + sensor = get_sensor_by_type(required_sensors[i].uri); - fsensor->add_required_sensor(sensor); + if (sensor == NULL) { + support = false; + break; } - if (!support) { - delete fsensor; - /* TODO: remove plugin */ - continue; - } + fsensor->add_required_sensor(required_sensors[i].id, sensor); + } - sensor_info sinfo = fsensor->get_sensor_info(); - m_sensors[sinfo.get_uri()] = fsensor; + if (!support) { + delete fsensor; + continue; } + + sensor_info sinfo = fsensor->get_sensor_info(); + m_sensors[sinfo.get_uri()] = fsensor; } } @@ -231,15 +227,13 @@ void sensor_manager::create_external_sensors(external_sensor_registry_t &esensor external_sensor_handler *esensor; for (auto it = esensors.begin(); it != esensors.end(); ++it) { - int count = (*it)->get_sensors(&info); + (*it)->get_sensor_info(&info); - for (int i = 0; i < count; ++i) { - esensor = new(std::nothrow) external_sensor_handler(info[i], it->get()); - retm_if(!esensor, "Failed to allocate memory"); + esensor = new(std::nothrow) external_sensor_handler(info[0], it->get()); + retm_if(!esensor, "Failed to allocate memory"); - sensor_info sinfo = esensor->get_sensor_info(); - m_sensors[sinfo.get_uri()] = esensor; - } + sensor_info sinfo = esensor->get_sensor_info(); + m_sensors[sinfo.get_uri()] = esensor; } } -- 2.7.4 From 3bbc00562a898ecbab323355207e5a9fc4d65fc7 Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 12 Apr 2017 18:57:17 +0900 Subject: [PATCH 16/16] sensord: enable auto_rotation sensor Signed-off-by: kibak.yoon Change-Id: I16b057a84c9606297a5a7d8b481bae633a95b69c --- CMakeLists.txt | 1 + packaging/sensord.spec | 1 + src/sensor/CMakeLists.txt | 92 ++++----- src/sensor/auto_rotation/auto_rotation_alg.cpp | 3 +- src/sensor/auto_rotation/auto_rotation_alg.h | 6 +- .../auto_rotation/auto_rotation_alg_emul.cpp | 9 +- src/sensor/auto_rotation/auto_rotation_alg_emul.h | 11 +- src/sensor/auto_rotation/auto_rotation_sensor.cpp | 209 +++++++-------------- src/sensor/auto_rotation/auto_rotation_sensor.h | 50 ++--- src/sensor/create.cpp | 69 +++++++ 10 files changed, 207 insertions(+), 244 deletions(-) create mode 100644 src/sensor/create.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index e91c388..0f30d92 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -20,6 +20,7 @@ ADD_SUBDIRECTORY(src/server) ADD_SUBDIRECTORY(src/client) ADD_SUBDIRECTORY(src/client-dummy) ADD_SUBDIRECTORY(src/sensorctl) +ADD_SUBDIRECTORY(src/sensor) INSTALL( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ diff --git a/packaging/sensord.spec b/packaging/sensord.spec index e4dfaf3..f340404 100644 --- a/packaging/sensord.spec +++ b/packaging/sensord.spec @@ -120,6 +120,7 @@ echo "You need to reinstall %{name}-dummy to keep using the APIs after uninstall %manifest packaging/sensord.manifest %{_libdir}/libsensor-genuine.so.* %{_libdir}/libsensord-shared.so +%{_libdir}/sensor/fusion/libsensor-fusion.so %{_bindir}/sensord %{_unitdir}/sensord.service %{_unitdir}/sensord.socket diff --git a/src/sensor/CMakeLists.txt b/src/sensor/CMakeLists.txt index 0339c23..dc6f04b 100644 --- a/src/sensor/CMakeLists.txt +++ b/src/sensor/CMakeLists.txt @@ -1,79 +1,53 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -PROJECT(sensors CXX) +PROJECT(sensor-fusion CXX) INCLUDE(GNUInstallDirs) -SET(ACC "OFF") -SET(HRM "OFF") -SET(HRM_VIRT "OFF") -SET(AUTO_ROTATION "OFF") +SET(AUTO_ROTATION "ON") SET(GRAVITY "OFF") SET(LINEAR_ACCEL "OFF") -SET(RV "OFF") -SET(ORIENTATION "OFF") -SET(FACE_DOWN "OFF") -SET(SENSORHUB "OFF") INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/src/shared - ${CMAKE_SOURCE_DIR}/src/server ${CMAKE_CURRENT_SOURCE_DIR} ) -FILE(GLOB SENSOR_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) -SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}) +# Common Options +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O2 -omit-frame-pointer -std=gnu++0x") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdata-sections -ffunction-sections") +SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections -Wl,--print-gc-sections") +MESSAGE("FLAGS: ${CMAKE_CXX_FLAGS}") +MESSAGE("FLAGS: ${CMAKE_EXE_LINKER_FLAGS}") -IF("${ACC}" STREQUAL "ON") -FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/accel/*.cpp) -SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/accel) -SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_ACCEL") -ENDIF() +# Internal Debugging Options +#ADD_DEFINITIONS(-Wall -g -D_DEBUG) + +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(PLUGINS_PKGS REQUIRED dlog) + +FOREACH(flag ${PLUGINS_PKGS_CFLAGS}) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + +FILE(GLOB SRCS *.cpp) -IF("${HRM}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/hrm/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/hrm) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_HRM") -ENDIF() -IF("${HRM_VIRT}" STREQUAL "ON") -add_subdirectory(hrm_virt) -ENDIF() IF("${AUTO_ROTATION}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_AUTO_ROTATION") +FILE(GLOB_RECURSE SRCS ${SRCS} auto_rotation/*.cpp) +ADD_DEFINITIONS(-DENABLE_AUTO_ROTATION) ENDIF() + IF("${GRAVITY}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/gravity/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/gravity) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_GRAVITY") +FILE(GLOB_RECURSE SRCS ${SRCS} gravity/*.cpp) +ADD_DEFINITIONS(-DENABLE_GRAVITY) ENDIF() + IF("${LINEAR_ACCEL}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/linear_accel/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/linear_accel) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_LINEAR_ACCEL") -ENDIF() -IF("${ORIENTATION}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/orientation/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/orientation) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_ORIENTATION") -ENDIF() -IF("${RV}" STREQUAL "ON") - FILE(GLOB SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_ROTATION_VECTOR") - FILE(GLOB SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/fusion_utils/*.cpp) -ENDIF() -IF("${FACE_DOWN}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/gesture/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/gesture) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_FACE_DOWN") -ENDIF() -IF("${SENSORHUB}" STREQUAL "ON") - FILE(GLOB_RECURSE SENSOR_SRCS ${SENSOR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/sensorhub/*.cpp) - SET(SENSOR_HEADERS ${SENSOR_HEADERS} ${CMAKE_CURRENT_SOURCE_DIR}/sensorhub) - SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} "-DENABLE_SENSORHUB") +FILE(GLOB_RECURSE SRCS ${SRCS} linear_accel/*.cpp) +ADD_DEFINITIONS(-DENABLE_LINEAR_ACCEL) ENDIF() -MESSAGE("${SENSOR_SRCS}") -SET(SENSOR_SRCS ${SENSOR_SRCS} PARENT_SCOPE) -SET(SENSOR_HEADERS ${SENSOR_HEADERS} PARENT_SCOPE) -SET(SENSOR_DEFINITIONS ${SENSOR_DEFINITIONS} PARENT_SCOPE) +MESSAGE("Sources: ${SRCS}") +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${PLUGINS_PKGS_LDFLAGS}) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}/sensor/fusion) diff --git a/src/sensor/auto_rotation/auto_rotation_alg.cpp b/src/sensor/auto_rotation/auto_rotation_alg.cpp index 14f61ae..d01bac4 100644 --- a/src/sensor/auto_rotation/auto_rotation_alg.cpp +++ b/src/sensor/auto_rotation/auto_rotation_alg.cpp @@ -17,8 +17,7 @@ * */ -#include -#include +#include "auto_rotation_alg.h" auto_rotation_alg::auto_rotation_alg() { diff --git a/src/sensor/auto_rotation/auto_rotation_alg.h b/src/sensor/auto_rotation/auto_rotation_alg.h index cfcc72d..301330c 100644 --- a/src/sensor/auto_rotation/auto_rotation_alg.h +++ b/src/sensor/auto_rotation/auto_rotation_alg.h @@ -17,8 +17,8 @@ * */ -#ifndef _AUTO_ROTATION_ALG_H_ -#define _AUTO_ROTATION_ALG_H_ +#ifndef __AUTO_ROTATION_ALG_H__ +#define __AUTO_ROTATION_ALG_H__ class auto_rotation_alg { public: @@ -32,4 +32,4 @@ public: virtual bool get_rotation(float acc[3], unsigned long long timestamp, int prev_rotation, int &rotation) = 0; }; -#endif /* _AUTO_ROTATION_ALG_H_ */ +#endif /* __AUTO_ROTATION_ALG_H__ */ diff --git a/src/sensor/auto_rotation/auto_rotation_alg_emul.cpp b/src/sensor/auto_rotation/auto_rotation_alg_emul.cpp index e3200dd..0448e6b 100644 --- a/src/sensor/auto_rotation/auto_rotation_alg_emul.cpp +++ b/src/sensor/auto_rotation/auto_rotation_alg_emul.cpp @@ -17,12 +17,11 @@ * */ -#include -#include -#include -#include -#include +#include "auto_rotation_alg_emul.h" + #include +#include +#include #define ROTATION_RULE_CNT 4 diff --git a/src/sensor/auto_rotation/auto_rotation_alg_emul.h b/src/sensor/auto_rotation/auto_rotation_alg_emul.h index 1c9357c..bf148a0 100644 --- a/src/sensor/auto_rotation/auto_rotation_alg_emul.h +++ b/src/sensor/auto_rotation/auto_rotation_alg_emul.h @@ -17,20 +17,21 @@ * */ -#ifndef _AUTO_ROTATION_ALG_EMUL_H_ -#define _AUTO_ROTATION_ALG_EMUL_H_ +#ifndef __AUTO_ROTATION_ALG_EMUL_H__ +#define __AUTO_ROTATION_ALG_EMUL_H__ -#include +#include "auto_rotation_alg.h" class auto_rotation_alg_emul : public auto_rotation_alg { public: auto_rotation_alg_emul(); virtual ~auto_rotation_alg_emul(); - virtual bool get_rotation(float acc[3], unsigned long long timestamp, int prev_rotation, int &cur_rotation); + bool get_rotation(float acc[3], unsigned long long timestamp, + int prev_rotation, int &cur_rotation); private: int convert_rotation(int prev_rotation, float acc_pitch, float acc_theta); }; -#endif /* _AUTO_ROTATION_ALG_EMUL_H_ */ +#endif /* __AUTO_ROTATION_ALG_EMUL_H__ */ diff --git a/src/sensor/auto_rotation/auto_rotation_sensor.cpp b/src/sensor/auto_rotation/auto_rotation_sensor.cpp index 71d10b4..2a6aa98 100644 --- a/src/sensor/auto_rotation/auto_rotation_sensor.cpp +++ b/src/sensor/auto_rotation/auto_rotation_sensor.cpp @@ -1,7 +1,7 @@ /* * sensord * - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 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. @@ -17,151 +17,98 @@ * */ -#include -#include -#include -#include -#include -#include -#include -#include +#include "auto_rotation_sensor.h" #include #include -#include -#include -#include -#include -#include -#include +#include "auto_rotation_alg_emul.h" -#define SENSOR_NAME "SENSOR_AUTO_ROTATION" +#define NAME_SENSOR "http://tizen.org/sensor/auto_rotation/AUTO_ROTATION" +#define NAME_VENDOR "Samsung" + +#define SRC_ID_ACC 0x1 +#define SRC_STR_ACC "http://tizen.org/sensor/accelerometer" + +static sensor_info2_t sensor_info = { + id: 0x1, + type: AUTO_ROTATION_SENSOR, + uri: NAME_SENSOR, + vendor: NAME_VENDOR, + min_range: AUTO_ROTATION_DEGREE_UNKNOWN, + max_range: AUTO_ROTATION_DEGREE_270, + resolution: 1, + min_interval: 60, + max_batch_count: 0, + wakeup_supported: false, + privilege:"", +}; + +static required_sensor_s required_sensors[] = { + {SRC_ID_ACC, SRC_STR_ACC} +}; auto_rotation_sensor::auto_rotation_sensor() -: m_accel_sensor(NULL) -, m_alg(NULL) -, m_rotation(0) -, m_interval(100) +: m_rotation(0) , m_rotation_time(0) +, m_alg(NULL) { + if (!init()) + throw OP_ERROR; } auto_rotation_sensor::~auto_rotation_sensor() { - delete m_alg; - - _I("auto_rotation_sensor is destroyed!\n"); + deinit(); } bool auto_rotation_sensor::init(void) { - m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR); - - if (!m_accel_sensor) { - _W("cannot load accel sensor_hal from %s", get_name()); - return false; - } - m_alg = get_alg(); - - if (!m_alg) { - _E("Not supported AUTO ROTATION sensor"); - return false; - } - - if (!m_alg->open()) - return false; - - _I("%s is created!\n", get_name()); - + retvm_if(!m_alg, false, "Not supported"); + retvm_if(!m_alg->open(), false, "Cannot open auto rotation algorithm"); return true; } -sensor_type_t auto_rotation_sensor::get_type(void) +void auto_rotation_sensor::deinit(void) { - return AUTO_ROTATION_SENSOR; + delete m_alg; } -unsigned int auto_rotation_sensor::get_event_type(void) +int auto_rotation_sensor::get_sensor_info(const sensor_info2_t **info) { - return AUTO_ROTATION_EVENT_CHANGE_STATE; + *info = &sensor_info; + return OP_SUCCESS; } -const char* auto_rotation_sensor::get_name(void) +int auto_rotation_sensor::get_required_sensors(const required_sensor_s **sensors) { - return SENSOR_NAME; + *sensors = required_sensors; + return 1; } -bool auto_rotation_sensor::get_sensor_info(sensor_info &info) +int auto_rotation_sensor::update(uint32_t id, sensor_data_t *data, int len) { - info.set_type(get_type()); - info.set_id(get_id()); - info.set_privilege(SENSOR_PRIVILEGE_PUBLIC); // FIXME - info.set_name("Auto Rotation Sensor"); - info.set_vendor("Samsung Electronics"); - info.set_min_range(AUTO_ROTATION_DEGREE_UNKNOWN); - info.set_max_range(AUTO_ROTATION_DEGREE_270); - info.set_resolution(1); - info.set_min_interval(1); - info.set_fifo_count(0); - info.set_max_batch_count(0); - info.set_supported_event(get_event_type()); - info.set_wakeup_supported(false); - - return true; -} - -void auto_rotation_sensor::synthesize(const sensor_event_t& event) -{ - if (event.event_type != ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME) - return; - int rotation; float acc[3]; - acc[0] = event.data->values[0]; - acc[1] = event.data->values[1]; - acc[2] = event.data->values[2]; - - if (!m_alg->get_rotation(acc, event.data->timestamp, m_rotation, rotation)) - return; - - m_rotation = rotation; - m_rotation_time = event.data->timestamp; + acc[0] = data->values[0]; + acc[1] = data->values[1]; + acc[2] = data->values[2]; - sensor_event_t *rotation_event; - sensor_data_t *rotation_data; - int data_length; - int remains; + if (!m_alg->get_rotation(acc, data->timestamp, m_rotation, rotation)) + return OP_ERROR; - rotation_event = (sensor_event_t *)malloc(sizeof(sensor_event_t)); - if (!rotation_event) { - _E("Failed to allocate memory"); - return; - } + _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", + rotation, data->values[0], data->values[1], data->values[2]); - remains = get_data(&rotation_data, &data_length); - - if (remains < 0) { - free(rotation_event); - return; - } - - rotation_event->sensor_id = get_id(); - rotation_event->event_type = AUTO_ROTATION_EVENT_CHANGE_STATE; - rotation_event->data_length = data_length; - rotation_event->data = rotation_data; - - push(rotation_event); + m_rotation = rotation; + m_rotation_time = data->timestamp; - _D("Rotation: %d, ACC[0]: %f, ACC[1]: %f, ACC[2]: %f", rotation, event.data->values[0], event.data->values[1], event.data->values[2]); + return OP_SUCCESS; } int auto_rotation_sensor::get_data(sensor_data_t **data, int *length) { - /* if It is batch sensor, remains can be 2+ */ - int remains = 1; - sensor_data_t *sensor_data; sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t)); @@ -173,54 +120,36 @@ int auto_rotation_sensor::get_data(sensor_data_t **data, int *length) *data = sensor_data; *length = sizeof(sensor_data_t); - return --remains; + return 1; } -bool auto_rotation_sensor::set_interval(unsigned long interval) +int auto_rotation_sensor::start(observer_h ob) { - m_accel_sensor->add_interval((intptr_t)this , interval, true); - - m_interval = interval; - return false; -} + m_rotation = AUTO_ROTATION_DEGREE_UNKNOWN; -bool auto_rotation_sensor::set_batch_latency(unsigned long latency) -{ - return false; -} + /* TODO: cache */ -bool auto_rotation_sensor::set_wakeup(int wakeup) -{ - return false; -} + m_alg->start(); -bool auto_rotation_sensor::pre_start(void) -{ - m_rotation = AUTO_ROTATION_DEGREE_UNKNOWN; - return true; + /* if OP_DEFAULT is returned, + * this function is not called anymore before stop() is called */ + return OP_DEFAULT; } -bool auto_rotation_sensor::on_start(void) +int auto_rotation_sensor::stop(observer_h ob) { - int length; - m_rotation = AUTO_ROTATION_DEGREE_UNKNOWN; + m_alg->stop(); - get_data(&m_last_data, &length); - - m_alg->start(); - - m_accel_sensor->add_interval((intptr_t)this , m_interval, true); - m_accel_sensor->start(); - - return activate(); + /* if OP_DEFAULT is returned, + * this function is not called anymore before start() is called */ + return OP_DEFAULT; } -bool auto_rotation_sensor::on_stop(void) +int auto_rotation_sensor::set_interval(observer_h ob, int32_t &interval) { - m_accel_sensor->delete_interval((intptr_t)this , true); - m_accel_sensor->stop(); - - return deactivate(); + /* Fix internal */ + interval = 60; + return OP_SUCCESS; } auto_rotation_alg *auto_rotation_sensor::get_alg(void) diff --git a/src/sensor/auto_rotation/auto_rotation_sensor.h b/src/sensor/auto_rotation/auto_rotation_sensor.h index d50f728..c573203 100644 --- a/src/sensor/auto_rotation/auto_rotation_sensor.h +++ b/src/sensor/auto_rotation/auto_rotation_sensor.h @@ -1,7 +1,7 @@ /* * sensord * - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 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. @@ -17,50 +17,40 @@ * */ -#ifndef _AUTO_ROTATION_SENSOR_H_ -#define _AUTO_ROTATION_SENSOR_H_ +#ifndef __AUTO_ROTATION_SENSOR_H__ +#define __AUTO_ROTATION_SENSOR_H__ -#include +#include #include -#include -class auto_rotation_sensor : public virtual_sensor { +#include "auto_rotation_alg.h" + +class auto_rotation_sensor : public fusion_sensor { public: auto_rotation_sensor(); virtual ~auto_rotation_sensor(); - /* initialize sensor */ - bool init(void); + int get_sensor_info(const sensor_info2_t **info); + int get_required_sensors(const required_sensor_s **sensors); - /* sensor info */ - virtual sensor_type_t get_type(void); - virtual unsigned int get_event_type(void); - virtual const char* get_name(void); + int update(uint32_t id, sensor_data_t *data, int len); + int get_data(sensor_data_t **data, int *len); - virtual bool get_sensor_info(sensor_info &info); + int start(observer_h ob); + int stop(observer_h ob); - /* synthesize event */ - virtual void synthesize(const sensor_event_t& event); + int set_interval(observer_h ob, int32_t &interval); - /* get data */ - virtual int get_data(sensor_data_t **data, int *length); private: - sensor_base *m_accel_sensor; - auto_rotation_alg *m_alg; + bool init(void); + void deinit(void); + + auto_rotation_alg *get_alg(void); int m_rotation; - unsigned int m_interval; unsigned long long m_rotation_time; - virtual bool set_interval(unsigned long interval); - virtual bool set_batch_latency(unsigned long latency); - virtual bool set_wakeup(int wakeup); - - virtual bool pre_start(void); - virtual bool on_start(void); - virtual bool on_stop(void); - - auto_rotation_alg *get_alg(void); + auto_rotation_alg *m_alg; }; -#endif /* _AUTO_ROTATION_SENSOR_H_ */ +#endif /* __AUTO_ROTATION_SENSOR_H__ */ diff --git a/src/sensor/create.cpp b/src/sensor/create.cpp new file mode 100644 index 0000000..10dd21f --- /dev/null +++ b/src/sensor/create.cpp @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2016 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. + * + */ + +#include +#include +#include + +#ifdef ENABLE_AUTO_ROTATION +#include "auto_rotation/auto_rotation_sensor.h" +#endif +#ifdef ENABLE_GRAVITY +#include "gravity/gravity_lowpass_sensor.h" +#include "gravity/gravity_comp_sensor.h" +#endif +#ifdef ENABLE_LINEAR_ACCEL +#include "linear_accel/linear_accel_sensor.h" +#endif + +static std::vector sensors; + +template +void create_sensor(const char *name) +{ + fusion_sensor *instance = NULL; + try { + instance = new _sensor; + } catch (std::exception &e) { + _E("Failed to create %s sensor, exception: %s", name, e.what()); + return; + } catch (int err) { + _ERRNO(err, _E, "Failed to create %s sensor device", name); + return; + } + + sensors.push_back(instance); +} + +extern "C" int create(fusion_sensor_t **fsensors) +{ +#ifdef ENABLE_AUTO_ROTATION + create_sensor("Accelerometer"); +#endif + +#ifdef ENABLE_GRAVITY + create_sensor("Gravity(Lowpass)"); + create_sensor("Gravity(Complementary)"); +#endif + +#ifdef ENABLE_LINEAR_ACCEL + create_sensor("Linear Acceleration Sensor"); +#endif + + *fsensors = &sensors[0]; + return sensors.size(); +} -- 2.7.4