4 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include "server_channel_handler.h"
22 #include <sensor_log.h>
23 #include <sensor_info.h>
24 #include <sensor_handler.h>
25 #include <sensor_utils.h>
26 #include <command_types.h>
28 #include "permission_checker.h"
30 #define PRIV_DELIMINATOR ";"
32 using namespace sensor;
35 server_channel_handler::server_channel_handler(sensor_manager *manager)
40 server_channel_handler::~server_channel_handler()
44 void server_channel_handler::connected(channel *ch)
48 void server_channel_handler::disconnected(channel *ch)
50 auto it = m_listener_ids.find(ch);
51 ret_if(it == m_listener_ids.end());
53 _I("Disconnected listener[%u]", it->second);
55 delete m_listeners[it->second];
56 m_listeners.erase(it->second);
57 m_listener_ids.erase(ch);
60 void server_channel_handler::read(channel *ch, message &msg)
65 case CMD_MANAGER_SENSOR_LIST:
66 err = manager_get_sensor_list(ch, msg); break;
67 case CMD_LISTENER_CONNECT:
68 err = listener_connect(ch, msg); break;
69 case CMD_LISTENER_DISCONNECT:
70 err = listener_disconnect(ch, msg); break;
71 case CMD_LISTENER_START:
72 err = listener_start(ch, msg); break;
73 case CMD_LISTENER_STOP:
74 err = listener_stop(ch, msg); break;
75 case CMD_LISTENER_ATTR_INT:
76 err = listener_attr_int(ch, msg); break;
77 case CMD_LISTENER_ATTR_STR:
78 err = listener_attr_str(ch, msg); break;
79 case CMD_LISTENER_GET_DATA:
80 err = listener_get_data(ch, msg); break;
81 case CMD_PROVIDER_CONNECT:
82 err = provider_connect(ch, msg); break;
83 case CMD_PROVIDER_DISCONNECT:
84 err = provider_disconnect(ch, msg); break;
85 case CMD_PROVIDER_POST:
86 err = provider_post(ch, msg); break;
87 case CMD_HAS_PRIVILEGE:
88 err = has_privileges(ch, msg); break;
94 ch->send_sync(&reply);
98 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
104 size = m_manager->serialize(ch->get_fd(), &bytes);
105 retv_if(size < 0, size);
107 reply.enclose((const char *)bytes, size);
108 reply.header()->err = OP_SUCCESS;
109 ch->send_sync(&reply);
116 int server_channel_handler::listener_connect(channel *ch, message &msg)
118 static uint32_t listener_id = 1;
119 sensor_handler *sensor;
120 cmd_listener_connect_t buf;
122 msg.disclose((char *)&buf);
124 sensor = m_manager->get_sensor(buf.sensor);
125 retv_if(!sensor, OP_ERROR);
127 sensor_listener_proxy *listener =
128 new(std::nothrow) sensor_listener_proxy(listener_id, sensor, ch);
129 retvm_if(!listener, OP_ERROR, "Failed to allocate memory");
130 retvm_if(!has_privileges(ch->get_fd(), listener->get_required_privileges()),
131 -EACCES, "Permission denied");
133 buf.listener_id = listener_id;
136 reply.enclose((const char *)&buf, sizeof(buf));
137 reply.header()->err = OP_SUCCESS;
139 if (!ch->send_sync(&reply))
142 _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
143 m_listeners[listener_id] = listener;
144 m_listener_ids[ch] = listener_id;
150 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
152 auto it = m_listener_ids.find(ch);
153 retv_if(it == m_listener_ids.end(), -EINVAL);
155 uint32_t id = it->second;
157 retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
158 -EACCES, "Permission denied");
160 delete m_listeners[id];
161 m_listeners.erase(id);
162 m_listener_ids.erase(ch);
164 _D("Disconnected sensor_listener[%u]", id);
166 return send_reply(ch, OP_SUCCESS);
169 int server_channel_handler::listener_start(channel *ch, message &msg)
171 cmd_listener_start_t buf;
172 msg.disclose((char *)&buf);
173 uint32_t id = buf.listener_id;
175 auto it = m_listeners.find(id);
176 retv_if(it == m_listeners.end(), -EINVAL);
177 retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
178 -EACCES, "Permission denied");
180 int ret = m_listeners[id]->start();
181 retv_if(ret < 0, ret);
183 return send_reply(ch, OP_SUCCESS);
186 int server_channel_handler::listener_stop(channel *ch, message &msg)
188 cmd_listener_stop_t buf;
189 msg.disclose((char *)&buf);
190 uint32_t id = buf.listener_id;
192 auto it = m_listeners.find(id);
193 retv_if(it == m_listeners.end(), -EINVAL);
194 retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
195 -EACCES, "Permission denied");
197 int ret = m_listeners[id]->stop();
198 retv_if(ret < 0, ret);
200 return send_reply(ch, OP_SUCCESS);
203 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
205 cmd_listener_attr_int_t buf;
206 msg.disclose((char *)&buf);
207 uint32_t id = buf.listener_id;
209 int ret = OP_SUCCESS;
211 auto it = m_listeners.find(id);
212 retv_if(it == m_listeners.end(), -EINVAL);
213 retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
214 -EACCES, "Permission denied");
216 switch (buf.attribute) {
217 case SENSORD_ATTRIBUTE_INTERVAL:
218 ret = m_listeners[id]->set_interval(buf.value); break;
219 case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
220 ret = m_listeners[id]->set_max_batch_latency(buf.value); break;
221 case SENSORD_ATTRIBUTE_PASSIVE_MODE:
222 ret = m_listeners[id]->set_passive_mode(buf.value); break;
223 case SENSORD_ATTRIBUTE_PAUSE_POLICY:
224 case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
226 ret = m_listeners[id]->set_attribute(buf.attribute, buf.value);
228 /* TODO : check return value */
230 _W("Return : %d", ret);
232 return send_reply(ch, OP_SUCCESS);
235 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
237 cmd_listener_attr_str_t buf;
238 msg.disclose((char *)&buf);
239 uint32_t id = buf.listener_id;
241 auto it = m_listeners.find(id);
242 retv_if(it == m_listeners.end(), -EINVAL);
243 retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
244 -EACCES, "Permission denied");
246 int ret = m_listeners[id]->set_attribute(buf.attribute, buf.value, buf.len);
247 retv_if(ret < 0, ret);
249 return send_reply(ch, OP_SUCCESS);
252 int server_channel_handler::listener_get_data(channel *ch, message &msg)
254 auto it = m_listeners.find(ch);
255 retv_if(it == m_listeners.end(), -EINVAL);
256 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
257 -EACCES, "Permission denied");
259 return send_reply(ch, OP_ERROR);
262 int server_channel_handler::provider_connect(channel *ch, message &msg)
264 return send_reply(ch, OP_ERROR);
267 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
269 return send_reply(ch, OP_ERROR);
272 int server_channel_handler::provider_post(channel *ch, message &msg)
274 return send_reply(ch, OP_ERROR);
277 int server_channel_handler::has_privileges(channel *ch, message &msg)
279 sensor_handler *sensor;
280 cmd_has_privilege_t buf;
281 msg.disclose((char *)&buf);
283 sensor = m_manager->get_sensor(buf.sensor);
284 retv_if(!sensor, OP_ERROR);
286 sensor_info info = sensor->get_sensor_info();
288 if (!has_privileges(ch->get_fd(), info.get_privilege()))
291 return send_reply(ch, OP_SUCCESS);
294 int server_channel_handler::send_reply(channel *ch, int error)
296 message reply(error);
297 retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");
301 bool server_channel_handler::has_privilege(int fd, std::string &priv)
303 static permission_checker checker;
304 return checker.has_permission(fd, priv);
307 bool server_channel_handler::has_privileges(int fd, std::string priv)
309 std::vector<std::string> privileges;
310 privileges = utils::tokenize(priv, PRIV_DELIMINATOR);
312 for (auto it = privileges.begin(); it != privileges.end(); ++it) {
313 if (!has_privilege(fd, *it))