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_listeners.find(ch);
51 ret_if(it == m_listeners.end());
53 _I("Disconnected listener[%u]", it->second->get_id());
56 m_listeners.erase(ch);
59 void server_channel_handler::read(channel *ch, message &msg)
64 case CMD_MANAGER_SENSOR_LIST:
65 err = manager_get_sensor_list(ch, msg); break;
66 case CMD_LISTENER_CONNECT:
67 err = listener_connect(ch, msg); break;
68 case CMD_LISTENER_DISCONNECT:
69 err = listener_disconnect(ch, msg); break;
70 case CMD_LISTENER_START:
71 err = listener_start(ch, msg); break;
72 case CMD_LISTENER_STOP:
73 err = listener_stop(ch, msg); break;
74 case CMD_LISTENER_ATTR_INT:
75 err = listener_attr_int(ch, msg); break;
76 case CMD_LISTENER_ATTR_STR:
77 err = listener_attr_str(ch, msg); break;
78 case CMD_LISTENER_GET_DATA:
79 err = listener_get_data(ch, msg); break;
80 case CMD_PROVIDER_CONNECT:
81 err = provider_connect(ch, msg); break;
82 case CMD_PROVIDER_DISCONNECT:
83 err = provider_disconnect(ch, msg); break;
84 case CMD_PROVIDER_POST:
85 err = provider_post(ch, msg); break;
86 case CMD_HAS_PRIVILEGE:
87 err = has_privileges(ch, msg); break;
93 ch->send_sync(&reply);
97 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
103 size = m_manager->serialize(ch->get_fd(), &bytes);
104 retv_if(size < 0, size);
106 reply.enclose((const char *)bytes, size);
107 ch->send_sync(&reply);
114 int server_channel_handler::listener_connect(channel *ch, message &msg)
116 static uint32_t listener_id = 1;
117 sensor_handler *sensor;
118 cmd_listener_connect_t buf;
120 msg.disclose((char *)&buf);
122 sensor = m_manager->get_sensor(buf.sensor);
123 retv_if(!sensor, OP_ERROR);
125 sensor_listener_proxy *listener =
126 new(std::nothrow) sensor_listener_proxy(listener_id, sensor, ch);
127 retvm_if(!listener, OP_ERROR, "Failed to allocate memory");
128 retvm_if(!has_privileges(ch->get_fd(), listener->get_required_privileges()),
129 -EACCES, "Permission denied");
131 buf.listener_id = listener_id;
134 reply.enclose((const char *)&buf, sizeof(buf));
135 reply.header()->err = OP_SUCCESS;
137 if (!ch->send_sync(&reply))
140 _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
142 m_listeners[ch] = listener;
147 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
149 auto it = m_listeners.find(ch);
150 retv_if(it == m_listeners.end(), -EINVAL);
152 uint32_t id = m_listeners[ch]->get_id();
154 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
155 -EACCES, "Permission denied");
157 delete m_listeners[ch];
158 m_listeners.erase(ch);
160 _D("Disconnected sensor_listener[%u]", id);
162 return send_reply(ch, OP_SUCCESS);
165 int server_channel_handler::listener_start(channel *ch, message &msg)
167 auto it = m_listeners.find(ch);
168 retv_if(it == m_listeners.end(), -EINVAL);
169 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
170 -EACCES, "Permission denied");
172 int ret = m_listeners[ch]->start();
173 retv_if(ret < 0, ret);
175 return send_reply(ch, OP_SUCCESS);
178 int server_channel_handler::listener_stop(channel *ch, message &msg)
180 auto it = m_listeners.find(ch);
181 retv_if(it == m_listeners.end(), -EINVAL);
182 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
183 -EACCES, "Permission denied");
185 int ret = m_listeners[ch]->stop();
186 retv_if(ret < 0, ret);
188 return send_reply(ch, OP_SUCCESS);
191 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
193 int ret = OP_SUCCESS;
195 auto it = m_listeners.find(ch);
196 retv_if(it == m_listeners.end(), -EINVAL);
197 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
198 -EACCES, "Permission denied");
200 cmd_listener_attr_int_t buf;
201 msg.disclose((char *)&buf);
203 switch (buf.attribute) {
204 case SENSORD_ATTRIBUTE_INTERVAL:
205 ret = m_listeners[ch]->set_interval(buf.value); break;
206 case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
207 ret = m_listeners[ch]->set_max_batch_latency(buf.value); break;
208 case SENSORD_ATTRIBUTE_PASSIVE_MODE:
209 ret = m_listeners[ch]->set_passive_mode(buf.value); break;
210 case SENSORD_ATTRIBUTE_PAUSE_POLICY:
211 case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
213 ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value);
215 retv_if(ret < 0, ret);
217 return send_reply(ch, OP_SUCCESS);
220 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
222 auto it = m_listeners.find(ch);
223 retv_if(it == m_listeners.end(), -EINVAL);
224 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
225 -EACCES, "Permission denied");
227 cmd_listener_attr_str_t buf;
228 msg.disclose((char *)&buf);
230 int ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value, buf.len);
231 retv_if(ret < 0, ret);
233 return send_reply(ch, OP_SUCCESS);
236 int server_channel_handler::listener_get_data(channel *ch, message &msg)
238 auto it = m_listeners.find(ch);
239 retv_if(it == m_listeners.end(), -EINVAL);
240 retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
241 -EACCES, "Permission denied");
243 return send_reply(ch, OP_ERROR);
246 int server_channel_handler::provider_connect(channel *ch, message &msg)
248 return send_reply(ch, OP_ERROR);
251 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
253 return send_reply(ch, OP_ERROR);
256 int server_channel_handler::provider_post(channel *ch, message &msg)
258 return send_reply(ch, OP_ERROR);
261 int server_channel_handler::has_privileges(channel *ch, message &msg)
263 sensor_handler *sensor;
264 cmd_has_privilege_t buf;
265 msg.disclose((char *)&buf);
267 sensor = m_manager->get_sensor(buf.sensor);
268 retv_if(!sensor, OP_ERROR);
270 sensor_info info = sensor->get_sensor_info();
272 if (!has_privileges(ch->get_fd(), info.get_privilege()))
275 return send_reply(ch, OP_SUCCESS);
278 int server_channel_handler::send_reply(channel *ch, int error)
280 message reply(error);
281 retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");
285 bool server_channel_handler::has_privilege(int fd, std::string &priv)
287 static permission_checker checker;
288 return checker.has_permission(fd, priv);
291 bool server_channel_handler::has_privileges(int fd, std::string priv)
293 std::vector<std::string> privileges;
294 privileges = utils::tokenize(priv, PRIV_DELIMINATOR);
296 for (auto it = privileges.begin(); it != privileges.end(); ++it) {
297 if (!has_privilege(fd, *it))