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_listeners.find(ch);
  51         ret_if(it == m_listeners.end());
  52
  53         _I("Disconnected listener[%u]", it->second->get_id());
  54
  55         delete it->second;
  56         m_listeners.erase(ch);
  57 }
  58
  59 void server_channel_handler::read(channel *ch, message &msg)
  60 {
  61         int err = -EINVAL;
  62
  63         switch (msg.type()) {
  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;
  88         default: break;
  89         }
  90
  91         if (err != 0) {
  92                 message reply(err);
  93                 ch->send_sync(&reply);
  94         }
  95 }
  96
  97 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
  98 {
  99         ipc::message reply;
 100         char *bytes;
 101         int size;
 102
 103         size = m_manager->serialize(ch->get_fd(), &bytes);
 104         retv_if(size < 0, size);
 105
 106         reply.enclose((const char *)bytes, size);
 107         ch->send_sync(&reply);
 108
 109         delete [] bytes;
 110
 111         return OP_SUCCESS;
 112 }
 113
 114 int server_channel_handler::listener_connect(channel *ch, message &msg)
 115 {
 116         static uint32_t listener_id = 1;
 117         sensor_handler *sensor;
 118         cmd_listener_connect_t buf;
 119
 120         msg.disclose((char *)&buf);
 121
 122         sensor = m_manager->get_sensor(buf.sensor);
 123         retv_if(!sensor, OP_ERROR);
 124
 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");
 130
 131         buf.listener_id = listener_id;
 132
 133         message reply;
 134         reply.enclose((const char *)&buf, sizeof(buf));
 135         reply.header()->err = OP_SUCCESS;
 136
 137         if (!ch->send_sync(&reply))
 138                 return OP_ERROR;
 139
 140         _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
 141         listener_id++;
 142         m_listeners[ch] = listener;
 143
 144         return OP_SUCCESS;
 145 }
 146
 147 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
 148 {
 149         auto it = m_listeners.find(ch);
 150         retv_if(it == m_listeners.end(), -EINVAL);
 151
 152         uint32_t id = m_listeners[ch]->get_id();
 153
 154         retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
 155                         -EACCES, "Permission denied");
 156
 157         delete m_listeners[ch];
 158         m_listeners.erase(ch);
 159
 160         _D("Disconnected sensor_listener[%u]", id);
 161
 162         return send_reply(ch, OP_SUCCESS);
 163 }
 164
 165 int server_channel_handler::listener_start(channel *ch, message &msg)
 166 {
 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");
 171
 172         int ret = m_listeners[ch]->start();
 173         retv_if(ret < 0, ret);
 174
 175         return send_reply(ch, OP_SUCCESS);
 176 }
 177
 178 int server_channel_handler::listener_stop(channel *ch, message &msg)
 179 {
 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");
 184
 185         int ret = m_listeners[ch]->stop();
 186         retv_if(ret < 0, ret);
 187
 188         return send_reply(ch, OP_SUCCESS);
 189 }
 190
 191 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
 192 {
 193         int ret = OP_SUCCESS;
 194
 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");
 199
 200         cmd_listener_attr_int_t buf;
 201         msg.disclose((char *)&buf);
 202
 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:
 212         default:
 213                 ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value);
 214         }
 215         retv_if(ret < 0, ret);
 216
 217         return send_reply(ch, OP_SUCCESS);
 218 }
 219
 220 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
 221 {
 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");
 226
 227         cmd_listener_attr_str_t buf;
 228         msg.disclose((char *)&buf);
 229
 230         int ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value, buf.len);
 231         retv_if(ret < 0, ret);
 232
 233         return send_reply(ch, OP_SUCCESS);
 234 }
 235
 236 int server_channel_handler::listener_get_data(channel *ch, message &msg)
 237 {
 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");
 242
 243         return send_reply(ch, OP_ERROR);
 244 }
 245
 246 int server_channel_handler::provider_connect(channel *ch, message &msg)
 247 {
 248         return send_reply(ch, OP_ERROR);
 249 }
 250
 251 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
 252 {
 253         return send_reply(ch, OP_ERROR);
 254 }
 255
 256 int server_channel_handler::provider_post(channel *ch, message &msg)
 257 {
 258         return send_reply(ch, OP_ERROR);
 259 }
 260
 261 int server_channel_handler::has_privileges(channel *ch, message &msg)
 262 {
 263         sensor_handler *sensor;
 264         cmd_has_privilege_t buf;
 265         msg.disclose((char *)&buf);
 266
 267         sensor = m_manager->get_sensor(buf.sensor);
 268         retv_if(!sensor, OP_ERROR);
 269
 270         sensor_info info = sensor->get_sensor_info();
 271
 272         if (!has_privileges(ch->get_fd(), info.get_privilege()))
 273                 return OP_ERROR;
 274
 275         return send_reply(ch, OP_SUCCESS);
 276 }
 277
 278 int server_channel_handler::send_reply(channel *ch, int error)
 279 {
 280         message reply(error);
 281         retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");
 282         return OP_SUCCESS;
 283 }
 284
 285 bool server_channel_handler::has_privilege(int fd, std::string &priv)
 286 {
 287         static permission_checker checker;
 288         return checker.has_permission(fd, priv);
 289 }
 290
 291 bool server_channel_handler::has_privileges(int fd, std::string priv)
 292 {
 293         std::vector<std::string> privileges;
 294         privileges = utils::tokenize(priv, PRIV_DELIMINATOR);
 295
 296         for (auto it = privileges.begin(); it != privileges.end(); ++it) {
 297                 if (!has_privilege(fd, *it))
 298                         return false;
 299         }
 300
 301         return true;
 302 }