src/server/server_channel_handler.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5  *
   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
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  */
  19
  20 #include "server_channel_handler.h"
  21
  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>
  27
  28 #include "permission_checker.h"
  29
  30 #define PRIV_DELIMINATOR ";"
  31
  32 using namespace sensor;
  33 using namespace ipc;
  34
  35 server_channel_handler::server_channel_handler(sensor_manager *manager)
  36 : m_manager(manager)
  37 {
  38 }
  39
  40 server_channel_handler::~server_channel_handler()
  41 {
  42 }
  43
  44 void server_channel_handler::connected(channel *ch)
  45 {
  46 }
  47
  48 void server_channel_handler::disconnected(channel *ch)
  49 {
  50         auto it = m_listener_ids.find(ch);
  51         ret_if(it == m_listener_ids.end());
  52
  53         _I("Disconnected listener[%u]", it->second);
  54
  55         delete m_listeners[it->second];
  56         m_listeners.erase(it->second);
  57         m_listener_ids.erase(ch);
  58 }
  59
  60 void server_channel_handler::read(channel *ch, message &msg)
  61 {
  62         int err = -EINVAL;
  63
  64         switch (msg.type()) {
  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_PUBLISH:
  86                 err = provider_post(ch, msg); break;
  87         case CMD_HAS_PRIVILEGE:
  88                 err = has_privileges(ch, msg); break;
  89         default: break;
  90         }
  91
  92         if (err != 0) {
  93                 message reply(err);
  94                 ch->send_sync(&reply);
  95         }
  96 }
  97
  98 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
  99 {
 100         ipc::message reply;
 101         char *bytes;
 102         int size;
 103
 104         size = m_manager->serialize(ch->get_fd(), &bytes);
 105         retv_if(size < 0, size);
 106
 107         reply.enclose((const char *)bytes, size);
 108         reply.header()->err = OP_SUCCESS;
 109         ch->send_sync(&reply);
 110
 111         delete [] bytes;
 112
 113         return OP_SUCCESS;
 114 }
 115
 116 int server_channel_handler::listener_connect(channel *ch, message &msg)
 117 {
 118         static uint32_t listener_id = 1;
 119         cmd_listener_connect_t buf;
 120
 121         msg.disclose((char *)&buf);
 122
 123         sensor_listener_proxy *listener;
 124         listener = new(std::nothrow) sensor_listener_proxy(listener_id,
 125                                 buf.sensor, m_manager, ch);
 126         retvm_if(!listener, OP_ERROR, "Failed to allocate memory");
 127         retvm_if(!has_privileges(ch->get_fd(), listener->get_required_privileges()),
 128                         -EACCES, "Permission denied");
 129
 130         buf.listener_id = listener_id;
 131
 132         message reply;
 133         reply.enclose((const char *)&buf, sizeof(buf));
 134         reply.header()->err = OP_SUCCESS;
 135
 136         if (!ch->send_sync(&reply))
 137                 return OP_ERROR;
 138
 139         _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
 140         m_listeners[listener_id] = listener;
 141         m_listener_ids[ch] = listener_id;
 142         listener_id++;
 143
 144         return OP_SUCCESS;
 145 }
 146
 147 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
 148 {
 149         auto it = m_listener_ids.find(ch);
 150         retv_if(it == m_listener_ids.end(), -EINVAL);
 151
 152         uint32_t id = it->second;
 153
 154         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 155                         -EACCES, "Permission denied");
 156
 157         delete m_listeners[id];
 158         m_listeners.erase(id);
 159         m_listener_ids.erase(ch);
 160
 161         _D("Disconnected sensor_listener[%u]", id);
 162
 163         return send_reply(ch, OP_SUCCESS);
 164 }
 165
 166 int server_channel_handler::listener_start(channel *ch, message &msg)
 167 {
 168         cmd_listener_start_t buf;
 169         msg.disclose((char *)&buf);
 170         uint32_t id = buf.listener_id;
 171
 172         auto it = m_listeners.find(id);
 173         retv_if(it == m_listeners.end(), -EINVAL);
 174         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 175                         -EACCES, "Permission denied");
 176
 177         int ret = m_listeners[id]->start();
 178         retv_if(ret < 0, ret);
 179
 180         return send_reply(ch, OP_SUCCESS);
 181 }
 182
 183 int server_channel_handler::listener_stop(channel *ch, message &msg)
 184 {
 185         cmd_listener_stop_t buf;
 186         msg.disclose((char *)&buf);
 187         uint32_t id = buf.listener_id;
 188
 189         auto it = m_listeners.find(id);
 190         retv_if(it == m_listeners.end(), -EINVAL);
 191         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 192                         -EACCES, "Permission denied");
 193
 194         int ret = m_listeners[id]->stop();
 195         retv_if(ret < 0, ret);
 196
 197         return send_reply(ch, OP_SUCCESS);
 198 }
 199
 200 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
 201 {
 202         cmd_listener_attr_int_t buf;
 203         msg.disclose((char *)&buf);
 204         uint32_t id = buf.listener_id;
 205
 206         int ret = OP_SUCCESS;
 207
 208         auto it = m_listeners.find(id);
 209         retv_if(it == m_listeners.end(), -EINVAL);
 210         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 211                         -EACCES, "Permission denied");
 212
 213         switch (buf.attribute) {
 214         case SENSORD_ATTRIBUTE_INTERVAL:
 215                 ret = m_listeners[id]->set_interval(buf.value); break;
 216         case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
 217                 ret = m_listeners[id]->set_max_batch_latency(buf.value); break;
 218         case SENSORD_ATTRIBUTE_PASSIVE_MODE:
 219                 ret = m_listeners[id]->set_passive_mode(buf.value); break;
 220         case SENSORD_ATTRIBUTE_PAUSE_POLICY:
 221         case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
 222         default:
 223                 ret = m_listeners[id]->set_attribute(buf.attribute, buf.value);
 224         }
 225         /* TODO : check return value */
 226         if (ret < 0)
 227                 _W("Return : %d", ret);
 228
 229         return send_reply(ch, OP_SUCCESS);
 230 }
 231
 232 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
 233 {
 234         cmd_listener_attr_str_t buf;
 235         msg.disclose((char *)&buf);
 236         uint32_t id = buf.listener_id;
 237
 238         auto it = m_listeners.find(id);
 239         retv_if(it == m_listeners.end(), -EINVAL);
 240         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 241                         -EACCES, "Permission denied");
 242
 243         int ret = m_listeners[id]->set_attribute(buf.attribute, buf.value, buf.len);
 244         retv_if(ret < 0, ret);
 245
 246         return send_reply(ch, OP_SUCCESS);
 247 }
 248
 249 int server_channel_handler::listener_get_data(channel *ch, message &msg)
 250 {
 251         ipc::message reply;
 252         cmd_listener_get_data_t buf;
 253         sensor_data_t *data;
 254         int len;
 255         uint32_t id;
 256
 257         msg.disclose((char *)&buf);
 258         id = buf.listener_id;
 259
 260         auto it = m_listeners.find(id);
 261         retv_if(it == m_listeners.end(), -EINVAL);
 262         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 263                         -EACCES, "Permission denied");
 264
 265         int ret = m_listeners[id]->get_data(&data, &len);
 266         retv_if(ret < 0, ret);
 267
 268         memcpy(&buf.data, data, sizeof(sensor_data_t));
 269         buf.len = sizeof(sensor_data_t);
 270
 271         reply.enclose((const char *)&buf, sizeof(cmd_listener_get_data_t));
 272         reply.header()->err = OP_SUCCESS;
 273         reply.header()->type = CMD_LISTENER_GET_DATA;
 274
 275         ch->send_sync(&reply);
 276
 277         free(data);
 278
 279         return OP_SUCCESS;
 280 }
 281
 282 int server_channel_handler::provider_connect(channel *ch, message &msg)
 283 {
 284         return send_reply(ch, OP_ERROR);
 285 }
 286
 287 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
 288 {
 289         return send_reply(ch, OP_ERROR);
 290 }
 291
 292 int server_channel_handler::provider_post(channel *ch, message &msg)
 293 {
 294         return send_reply(ch, OP_ERROR);
 295 }
 296
 297 int server_channel_handler::has_privileges(channel *ch, message &msg)
 298 {
 299         sensor_handler *sensor;
 300         cmd_has_privilege_t buf;
 301         msg.disclose((char *)&buf);
 302
 303         sensor = m_manager->get_sensor(buf.sensor);
 304         retv_if(!sensor, OP_ERROR);
 305
 306         sensor_info info = sensor->get_sensor_info();
 307
 308         if (!has_privileges(ch->get_fd(), info.get_privilege()))
 309                 return OP_ERROR;
 310
 311         return send_reply(ch, OP_SUCCESS);
 312 }
 313
 314 int server_channel_handler::send_reply(channel *ch, int error)
 315 {
 316         message reply(error);
 317         retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");
 318         return OP_SUCCESS;
 319 }
 320
 321 bool server_channel_handler::has_privilege(int fd, std::string &priv)
 322 {
 323         static permission_checker checker;
 324         return checker.has_permission(fd, priv);
 325 }
 326
 327 bool server_channel_handler::has_privileges(int fd, std::string priv)
 328 {
 329         std::vector<std::string> privileges;
 330         privileges = utils::tokenize(priv, PRIV_DELIMINATOR);
 331
 332         for (auto it = privileges.begin(); it != privileges.end(); ++it) {
 333                 if (!has_privilege(fd, *it))
 334                         return false;
 335         }
 336
 337         return true;
 338 }