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_POST:
  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         sensor_handler *sensor;
 120         cmd_listener_connect_t buf;
 121
 122         msg.disclose((char *)&buf);
 123
 124         sensor = m_manager->get_sensor(buf.sensor);
 125         retv_if(!sensor, OP_ERROR);
 126
 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");
 132
 133         buf.listener_id = listener_id;
 134
 135         message reply;
 136         reply.enclose((const char *)&buf, sizeof(buf));
 137         reply.header()->err = OP_SUCCESS;
 138
 139         if (!ch->send_sync(&reply))
 140                 return OP_ERROR;
 141
 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;
 145         listener_id++;
 146
 147         return OP_SUCCESS;
 148 }
 149
 150 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
 151 {
 152         auto it = m_listener_ids.find(ch);
 153         retv_if(it == m_listener_ids.end(), -EINVAL);
 154
 155         uint32_t id = it->second;
 156
 157         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 158                         -EACCES, "Permission denied");
 159
 160         delete m_listeners[id];
 161         m_listeners.erase(id);
 162         m_listener_ids.erase(ch);
 163
 164         _D("Disconnected sensor_listener[%u]", id);
 165
 166         return send_reply(ch, OP_SUCCESS);
 167 }
 168
 169 int server_channel_handler::listener_start(channel *ch, message &msg)
 170 {
 171         cmd_listener_start_t buf;
 172         msg.disclose((char *)&buf);
 173         uint32_t id = buf.listener_id;
 174
 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");
 179
 180         int ret = m_listeners[id]->start();
 181         retv_if(ret < 0, ret);
 182
 183         return send_reply(ch, OP_SUCCESS);
 184 }
 185
 186 int server_channel_handler::listener_stop(channel *ch, message &msg)
 187 {
 188         cmd_listener_stop_t buf;
 189         msg.disclose((char *)&buf);
 190         uint32_t id = buf.listener_id;
 191
 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");
 196
 197         int ret = m_listeners[id]->stop();
 198         retv_if(ret < 0, ret);
 199
 200         return send_reply(ch, OP_SUCCESS);
 201 }
 202
 203 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
 204 {
 205         cmd_listener_attr_int_t buf;
 206         msg.disclose((char *)&buf);
 207         uint32_t id = buf.listener_id;
 208
 209         int ret = OP_SUCCESS;
 210
 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");
 215
 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:
 225         default:
 226                 ret = m_listeners[id]->set_attribute(buf.attribute, buf.value);
 227         }
 228         /* TODO : check return value */
 229         if (ret < 0)
 230                 _W("Return : %d", ret);
 231
 232         return send_reply(ch, OP_SUCCESS);
 233 }
 234
 235 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
 236 {
 237         cmd_listener_attr_str_t buf;
 238         msg.disclose((char *)&buf);
 239         uint32_t id = buf.listener_id;
 240
 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");
 245
 246         int ret = m_listeners[id]->set_attribute(buf.attribute, buf.value, buf.len);
 247         retv_if(ret < 0, ret);
 248
 249         return send_reply(ch, OP_SUCCESS);
 250 }
 251
 252 int server_channel_handler::listener_get_data(channel *ch, message &msg)
 253 {
 254         ipc::message reply;
 255         cmd_listener_get_data_t buf;
 256         sensor_data_t *data;
 257         int len;
 258         uint32_t id;
 259
 260         msg.disclose((char *)&buf);
 261         id = buf.listener_id;
 262
 263         auto it = m_listeners.find(id);
 264         retv_if(it == m_listeners.end(), -EINVAL);
 265         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 266                         -EACCES, "Permission denied");
 267
 268         int ret = m_listeners[id]->get_data(&data, &len);
 269         retv_if(ret < 0, ret);
 270
 271         memcpy(&buf.data, data, sizeof(sensor_data_t));
 272         buf.len = sizeof(sensor_data_t);
 273
 274         reply.enclose((const char *)&buf, sizeof(cmd_listener_get_data_t));
 275         reply.header()->err = OP_SUCCESS;
 276         reply.header()->type = CMD_LISTENER_GET_DATA;
 277
 278         ch->send_sync(&reply);
 279
 280         free(data);
 281
 282         return OP_SUCCESS;
 283 }
 284
 285 int server_channel_handler::provider_connect(channel *ch, message &msg)
 286 {
 287         return send_reply(ch, OP_ERROR);
 288 }
 289
 290 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
 291 {
 292         return send_reply(ch, OP_ERROR);
 293 }
 294
 295 int server_channel_handler::provider_post(channel *ch, message &msg)
 296 {
 297         return send_reply(ch, OP_ERROR);
 298 }
 299
 300 int server_channel_handler::has_privileges(channel *ch, message &msg)
 301 {
 302         sensor_handler *sensor;
 303         cmd_has_privilege_t buf;
 304         msg.disclose((char *)&buf);
 305
 306         sensor = m_manager->get_sensor(buf.sensor);
 307         retv_if(!sensor, OP_ERROR);
 308
 309         sensor_info info = sensor->get_sensor_info();
 310
 311         if (!has_privileges(ch->get_fd(), info.get_privilege()))
 312                 return OP_ERROR;
 313
 314         return send_reply(ch, OP_SUCCESS);
 315 }
 316
 317 int server_channel_handler::send_reply(channel *ch, int error)
 318 {
 319         message reply(error);
 320         retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");
 321         return OP_SUCCESS;
 322 }
 323
 324 bool server_channel_handler::has_privilege(int fd, std::string &priv)
 325 {
 326         static permission_checker checker;
 327         return checker.has_permission(fd, priv);
 328 }
 329
 330 bool server_channel_handler::has_privileges(int fd, std::string priv)
 331 {
 332         std::vector<std::string> privileges;
 333         privileges = utils::tokenize(priv, PRIV_DELIMINATOR);
 334
 335         for (auto it = privileges.begin(); it != privileges.end(); ++it) {
 336                 if (!has_privilege(fd, *it))
 337                         return false;
 338         }
 339
 340         return true;
 341 }