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 <sensor_types_private.h>
  27 #include <command_types.h>
  28 #include <event_loop.h>
  29
  30 #include "permission_checker.h"
  31 #include "application_sensor_handler.h"
  32
  33 using namespace sensor;
  34 using namespace ipc;
  35
  36 /* TODO */
  37 std::unordered_map<uint32_t, sensor_listener_proxy *> server_channel_handler::m_listeners;
  38 std::unordered_map<ipc::channel *, uint32_t> server_channel_handler::m_listener_ids;
  39 std::unordered_map<ipc::channel *, application_sensor_handler *> server_channel_handler::m_app_sensors;
  40
  41 server_channel_handler::server_channel_handler(sensor_manager *manager)
  42 : m_manager(manager)
  43 {
  44         _I("Create[%p]", this);
  45 }
  46
  47 server_channel_handler::~server_channel_handler()
  48 {
  49         _I("Destroy[%p]", this);
  50 }
  51
  52 void server_channel_handler::connected(channel *ch)
  53 {
  54 }
  55
  56 void server_channel_handler::disconnected(channel *ch)
  57 {
  58         _I("Disconnect[%p] using channel[%p]", this, ch);
  59         m_manager->deregister_channel(ch);
  60
  61         auto it_asensor = m_app_sensors.find(ch);
  62         if (it_asensor != m_app_sensors.end()) {
  63                 sensor_info info = it_asensor->second->get_sensor_info();
  64
  65                 _I("Disconnected provider[%s]", info.get_uri().c_str());
  66
  67                 m_manager->deregister_sensor(info.get_uri());
  68                 m_app_sensors.erase(ch);
  69         }
  70
  71         auto it_listener = m_listener_ids.find(ch);
  72         if (it_listener != m_listener_ids.end()) {
  73                 _I("Disconnected listener[%u]", it_listener->second);
  74
  75                 delete m_listeners[it_listener->second];
  76                 m_listeners.erase(it_listener->second);
  77                 m_listener_ids.erase(ch);
  78         }
  79
  80         if (!ch->loop())
  81                 _D("Should not be here : channel[%p]", ch);
  82 }
  83
  84 void server_channel_handler::read(channel *ch, message &msg)
  85 {
  86         int err = -EINVAL;
  87
  88         switch (msg.type()) {
  89         case CMD_MANAGER_CONNECT:
  90                 err = manager_connect(ch, msg); break;
  91         case CMD_MANAGER_SENSOR_LIST:
  92                 err = manager_get_sensor_list(ch, msg); break;
  93         case CMD_LISTENER_CONNECT:
  94                 err = listener_connect(ch, msg); break;
  95         case CMD_LISTENER_START:
  96                 err = listener_start(ch, msg); break;
  97         case CMD_LISTENER_STOP:
  98                 err = listener_stop(ch, msg); break;
  99         case CMD_LISTENER_SET_ATTR_INT:
 100                 err = listener_set_attr_int(ch, msg); break;
 101         case CMD_LISTENER_SET_ATTR_STR:
 102                 err = listener_set_attr_str(ch, msg); break;
 103         case CMD_LISTENER_GET_DATA:
 104                 err = listener_get_data(ch, msg); break;
 105         case CMD_LISTENER_GET_ATTR_INT:
 106                 err = listener_get_attr_int(ch, msg); break;
 107         case CMD_LISTENER_GET_ATTR_STR:
 108                 err = listener_get_attr_str(ch, msg); break;
 109         case CMD_LISTENER_GET_DATA_LIST:
 110                 err = listener_get_data_list(ch, msg); break;
 111         case CMD_PROVIDER_CONNECT:
 112                 err = provider_connect(ch, msg); break;
 113         case CMD_PROVIDER_PUBLISH:
 114                 err = provider_publish(ch, msg); break;
 115         case CMD_HAS_PRIVILEGE:
 116                 err = has_privileges(ch, msg); break;
 117         default: break;
 118         }
 119
 120         if (err != 0) {
 121                 message reply(err);
 122                 ch->send_sync(reply);
 123         }
 124 }
 125
 126 int server_channel_handler::manager_connect(channel *ch, message &msg)
 127 {
 128         m_manager->register_channel(ch);
 129         return OP_SUCCESS;
 130 }
 131
 132 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
 133 {
 134         ipc::message reply;
 135         char *bytes;
 136         int size;
 137
 138         size = m_manager->serialize(ch->get_fd(), &bytes);
 139         retv_if(size < 0, size);
 140
 141         reply.enclose((const char *)bytes, size);
 142         reply.header()->err = OP_SUCCESS;
 143         ch->send_sync(reply);
 144
 145         delete [] bytes;
 146
 147         return OP_SUCCESS;
 148 }
 149
 150 int server_channel_handler::listener_connect(channel *ch, message &msg)
 151 {
 152         static uint32_t listener_id = 1;
 153         cmd_listener_connect_t buf;
 154
 155         msg.disclose((char *)&buf, sizeof(buf));
 156
 157         sensor_listener_proxy *listener;
 158         listener = new(std::nothrow) sensor_listener_proxy(listener_id,
 159                                 buf.sensor, m_manager, ch);
 160         retvm_if(!listener, OP_ERROR, "Failed to allocate memory");
 161         retvm_if(!has_privileges(ch->get_fd(), listener->get_required_privileges()),
 162                         -EACCES, "Permission denied[%d, %s]",
 163                         listener_id, m_listeners[listener_id]->get_required_privileges().c_str());
 164
 165         buf.listener_id = listener_id;
 166
 167         message reply;
 168         reply.set_type(CMD_LISTENER_CONNECTED);
 169         reply.enclose((const char *)&buf, sizeof(buf));
 170         reply.header()->err = OP_SUCCESS;
 171
 172         if (!ch->send_sync(reply))
 173                 return OP_ERROR;
 174
 175         _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
 176         m_listeners[listener_id] = listener;
 177         m_listener_ids[ch] = listener_id;
 178         listener_id++;
 179
 180         return OP_SUCCESS;
 181 }
 182
 183 int server_channel_handler::listener_start(channel *ch, message &msg)
 184 {
 185         cmd_listener_start_t buf;
 186         msg.disclose((char *)&buf, sizeof(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[%d, %s]",
 193                         id, m_listeners[id]->get_required_privileges().c_str());
 194
 195         int ret = m_listeners[id]->start();
 196         retvm_if(ret < 0, ret, "Failed to start listener[%d]", id);
 197
 198         return send_reply(ch, OP_SUCCESS);
 199 }
 200
 201 int server_channel_handler::listener_stop(channel *ch, message &msg)
 202 {
 203         cmd_listener_stop_t buf;
 204         msg.disclose((char *)&buf, sizeof(buf));
 205         uint32_t id = buf.listener_id;
 206
 207         auto it = m_listeners.find(id);
 208         retv_if(it == m_listeners.end(), -EINVAL);
 209         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 210                         -EACCES, "Permission denied[%d, %s]",
 211                         id, m_listeners[id]->get_required_privileges().c_str());
 212
 213         int ret = m_listeners[id]->stop();
 214         retvm_if(ret < 0, ret, "Failed to stop listener[%d]", id);
 215
 216         return send_reply(ch, OP_SUCCESS);
 217 }
 218
 219 int server_channel_handler::listener_set_attr_int(channel *ch, message &msg)
 220 {
 221         cmd_listener_attr_int_t buf;
 222         msg.disclose((char *)&buf, sizeof(buf));
 223         uint32_t id = buf.listener_id;
 224
 225         int ret = OP_SUCCESS;
 226
 227         auto it = m_listeners.find(id);
 228         retv_if(it == m_listeners.end(), -EINVAL);
 229         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 230                         -EACCES, "Permission denied[%d, %s]",
 231                         id, m_listeners[id]->get_required_privileges().c_str());
 232
 233         switch (buf.attribute) {
 234         case SENSORD_ATTRIBUTE_INTERVAL:
 235                 ret = m_listeners[id]->set_interval(buf.value); break;
 236         case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
 237                 ret = m_listeners[id]->set_max_batch_latency(buf.value); break;
 238         case SENSORD_ATTRIBUTE_PASSIVE_MODE:
 239                 ret = m_listeners[id]->set_passive_mode(buf.value); break;
 240         case SENSORD_ATTRIBUTE_PAUSE_POLICY:
 241         case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
 242         default:
 243                 ret = m_listeners[id]->set_attribute(buf.attribute, buf.value);
 244         }
 245         /* TODO : check return value */
 246         if (ret < 0)
 247                 _D("Return : %d", ret);
 248
 249         ret = send_reply(ch, OP_SUCCESS);
 250
 251         if (m_listeners[id]->need_to_notify_attribute_changed()) {
 252                 m_listeners[id]->notify_attribute_changed(buf.attribute, buf.value);
 253                 m_listeners[id]->set_need_to_notify_attribute_changed(false);
 254         }
 255
 256         return ret;
 257 }
 258
 259 int server_channel_handler::listener_set_attr_str(channel *ch, message &msg)
 260 {
 261         uint32_t id;
 262         cmd_listener_attr_str_t *buf;
 263
 264         buf = (cmd_listener_attr_str_t *) new(std::nothrow) char[msg.size()];
 265         retvm_if(!buf, -ENOMEM, "Failed to allocate memory");
 266
 267         msg.disclose((char *)buf, msg.size());
 268
 269         id = buf->listener_id;
 270         auto it = m_listeners.find(id);
 271         if (it == m_listeners.end()) {
 272                 delete [] buf;
 273                 return -EINVAL;
 274         }
 275
 276         if (!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges())) {
 277                 _E("Permission denied[%d, %s]", id, m_listeners[id]->get_required_privileges().c_str());
 278                 delete [] buf;
 279                 return -EACCES;
 280         }
 281
 282         int ret = m_listeners[id]->set_attribute(buf->attribute, buf->value, buf->len);
 283         if (ret < 0) {
 284                 delete [] buf;
 285                 return ret;
 286         }
 287
 288         ret = send_reply(ch, OP_SUCCESS);
 289
 290         if (m_listeners[id]->need_to_notify_attribute_changed()) {
 291                 m_listeners[id]->notify_attribute_changed(buf->attribute, buf->value, buf->len);
 292                 m_listeners[id]->set_need_to_notify_attribute_changed(false);
 293         }
 294
 295         delete [] buf;
 296         return ret;
 297 }
 298
 299 int server_channel_handler::listener_get_attr_int(ipc::channel *ch, ipc::message &msg)
 300 {
 301         cmd_listener_attr_int_t buf;
 302         msg.disclose((char *)&buf, sizeof(buf));
 303         uint32_t id = buf.listener_id;
 304         int attr = buf.attribute;
 305         int value = 0;
 306         int ret = OP_SUCCESS;
 307
 308         auto it = m_listeners.find(id);
 309         retv_if(it == m_listeners.end(), -EINVAL);
 310         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 311                         -EACCES, "Permission denied[%d, %s]",
 312                         id, m_listeners[id]->get_required_privileges().c_str());
 313
 314         switch (attr) {
 315         case SENSORD_ATTRIBUTE_INTERVAL:
 316                 ret = m_listeners[id]->get_interval(value); break;
 317         case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
 318                 ret = m_listeners[id]->get_max_batch_latency(value); break;
 319         case SENSORD_ATTRIBUTE_PASSIVE_MODE:
 320                 // TODO : Are these features required?
 321                 ret = OP_ERROR;
 322                 break;
 323         case SENSORD_ATTRIBUTE_PAUSE_POLICY:
 324         case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
 325         default:
 326                 ret = m_listeners[id]->get_attribute(attr, &value);
 327         }
 328
 329         if (ret != OP_SUCCESS) {
 330                 _E("Failed to listener_get_attr_int");
 331                 return ret;
 332         }
 333         message reply;
 334         cmd_listener_attr_int_t ret_buf;
 335
 336         ret_buf.listener_id = id;
 337         ret_buf.attribute = attr;
 338         ret_buf.value = value;
 339
 340         reply.enclose((char *)&ret_buf, sizeof(ret_buf));
 341         reply.header()->err = OP_SUCCESS;
 342         reply.set_type(CMD_LISTENER_GET_ATTR_INT);
 343         ret = ch->send_sync(reply);
 344
 345         return OP_SUCCESS;
 346 }
 347
 348 int server_channel_handler::listener_get_attr_str(ipc::channel *ch, ipc::message &msg)
 349 {
 350         uint32_t id;
 351         cmd_listener_attr_str_t *buf;
 352
 353         buf = (cmd_listener_attr_str_t *) new(std::nothrow) char[msg.size()];
 354         retvm_if(!buf, -ENOMEM, "Failed to allocate memory");
 355
 356         msg.disclose((char *)buf, msg.size());
 357
 358         id = buf->listener_id;
 359         auto it = m_listeners.find(id);
 360         auto attr = buf->attribute;
 361         delete [] buf;
 362
 363         if (it == m_listeners.end()) {
 364                 return -EINVAL;
 365         }
 366
 367         if (!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges())) {
 368                 _E("Permission denied[%d, %s]", id, m_listeners[id]->get_required_privileges().c_str());
 369                 return -EACCES;
 370         }
 371
 372         char *value = NULL;
 373         int len = 0;
 374         int ret = m_listeners[id]->get_attribute(attr, &value, &len);
 375
 376         if (ret != OP_SUCCESS) {
 377                 _E("Failed to listener_get_attr_str");
 378                 return ret;
 379         }
 380
 381         cmd_listener_attr_str_t *reply_buf;
 382         size_t size = sizeof(cmd_listener_attr_str_t) + len;
 383         reply_buf = (cmd_listener_attr_str_t *) new(std::nothrow) char[size];
 384         retvm_if(!reply_buf, -ENOMEM, "Failed to allocate memory");
 385
 386         reply_buf->attribute = attr;
 387         memcpy(reply_buf->value, value, len);
 388         reply_buf->len = len;
 389         delete [] value;
 390
 391         ipc::message reply;
 392         reply.enclose((char *)reply_buf, size);
 393         reply.set_type(CMD_LISTENER_GET_ATTR_STR);
 394
 395         ret = ch->send_sync(reply);
 396         delete [] reply_buf;
 397
 398         return OP_SUCCESS;
 399 }
 400
 401 int server_channel_handler::listener_get_data(channel *ch, message &msg)
 402 {
 403         ipc::message reply;
 404         cmd_listener_get_data_t buf;
 405         sensor_data_t *data;
 406         int len;
 407         uint32_t id;
 408
 409         msg.disclose((char *)&buf, sizeof(buf));
 410         id = buf.listener_id;
 411
 412         auto it = m_listeners.find(id);
 413         retv_if(it == m_listeners.end(), -EINVAL);
 414         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 415                         -EACCES, "Permission denied[%d, %s]",
 416                         id, m_listeners[id]->get_required_privileges().c_str());
 417
 418         int ret = m_listeners[id]->get_data(&data, &len);
 419         retv_if(ret < 0, ret);
 420
 421         memcpy(&buf.data, data, sizeof(sensor_data_t));
 422         buf.len = sizeof(sensor_data_t);
 423
 424         reply.enclose((const char *)&buf, sizeof(cmd_listener_get_data_t));
 425         reply.header()->err = OP_SUCCESS;
 426         reply.header()->type = CMD_LISTENER_GET_DATA;
 427
 428         ch->send_sync(reply);
 429
 430         free(data);
 431
 432         return OP_SUCCESS;
 433 }
 434
 435 int server_channel_handler::listener_get_data_list(ipc::channel *ch, ipc::message &msg)
 436 {
 437         ipc::message reply;
 438         cmd_listener_get_data_list_t buf;
 439         sensor_data_t *data;
 440         int len;
 441         uint32_t id;
 442
 443         msg.disclose((char *)&buf, sizeof(buf));
 444         id = buf.listener_id;
 445
 446         auto it = m_listeners.find(id);
 447         retv_if(it == m_listeners.end(), -EINVAL);
 448         retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
 449                         -EACCES, "Permission denied[%d, %s]",
 450                         id, m_listeners[id]->get_required_privileges().c_str());
 451
 452         int ret = m_listeners[id]->get_data(&data, &len);
 453         retv_if(ret < 0, ret);
 454
 455         size_t reply_size = sizeof(cmd_listener_get_data_list_t) + len;
 456         cmd_listener_get_data_list_t* reply_buf = (cmd_listener_get_data_list_t *) malloc(reply_size);
 457         if (!reply_buf) {
 458                 _E("Failed to allocate memory");
 459                 free(data);
 460                 return -ENOMEM;
 461         }
 462
 463         memcpy(reply_buf->data, data, len);
 464         reply_buf->len = len;
 465         reply_buf->data_count = len / sizeof(sensor_data_t);
 466         reply.enclose((const char *)reply_buf, reply_size);
 467         reply.header()->err = OP_SUCCESS;
 468         reply.header()->type = CMD_LISTENER_GET_DATA_LIST;
 469
 470         ch->send_sync(reply);
 471
 472         free(data);
 473         free(reply_buf);
 474
 475         return OP_SUCCESS;
 476
 477 }
 478
 479 int server_channel_handler::provider_connect(channel *ch, message &msg)
 480 {
 481         sensor_info info;
 482         info.clear();
 483         info.deserialize(msg.body(), msg.size());
 484
 485         info.show();
 486
 487         application_sensor_handler *sensor;
 488         sensor = new(std::nothrow) application_sensor_handler(info, ch);
 489         retvm_if(!sensor, -ENOMEM, "Failed to allocate memory");
 490
 491         if (!m_manager->register_sensor(sensor)) {
 492                 delete sensor;
 493                 return -EINVAL;
 494         }
 495
 496         /* temporarily */
 497         m_app_sensors[ch] = sensor;
 498
 499         return send_reply(ch, OP_SUCCESS);
 500 }
 501
 502 int server_channel_handler::provider_publish(channel *ch, message &msg)
 503 {
 504         auto it = m_app_sensors.find(ch);
 505         retv_if(it == m_app_sensors.end(), -EINVAL);
 506
 507         size_t size = msg.header()->length;
 508         void *data = (void *)malloc(size);
 509         retvm_if(!data, -ENOMEM, "Failed to allocate memory");
 510
 511         msg.disclose(data, size);
 512
 513         it->second->publish((sensor_data_t*)data, size);
 514         return OP_SUCCESS;
 515 }
 516
 517 int server_channel_handler::has_privileges(channel *ch, message &msg)
 518 {
 519         sensor_handler *sensor;
 520         cmd_has_privilege_t buf;
 521         msg.disclose((char *)&buf, sizeof(buf));
 522
 523         sensor = m_manager->get_sensor(buf.sensor);
 524         retv_if(!sensor, OP_ERROR);
 525
 526         sensor_info info = sensor->get_sensor_info();
 527
 528         if (!has_privileges(ch->get_fd(), info.get_privilege()))
 529                 return OP_ERROR;
 530
 531         return send_reply(ch, OP_SUCCESS);
 532 }
 533
 534 int server_channel_handler::send_reply(channel *ch, int error)
 535 {
 536         message reply(error);
 537         retvm_if(!ch->send_sync(reply), OP_ERROR, "Failed to send reply");
 538         return OP_SUCCESS;
 539 }
 540
 541 bool server_channel_handler::has_privilege(int fd, std::string &priv)
 542 {
 543         static permission_checker checker;
 544         return checker.has_permission(fd, priv);
 545 }
 546
 547 bool server_channel_handler::has_privileges(int fd, std::string priv)
 548 {
 549         std::vector<std::string> privileges;
 550         privileges = utils::tokenize(priv, PRIV_DELIMITER);
 551
 552         for (auto it = privileges.begin(); it != privileges.end(); ++it) {
 553                 if (!has_privilege(fd, *it))
 554                         return false;
 555         }
 556
 557         return true;
 558 }