src/server/external_sensor_worker.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2015 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 <sensor_common.h>
  21 #include <command_common.h>
  22 #include <external_sensor_worker.h>
  23 #include <external_client_manager.h>
  24 #include <external_sensor.h>
  25 #include <external_sensor_service.h>
  26
  27 using std::string;
  28
  29 external_sensor_worker::cmd_handler_t external_sensor_worker::m_cmd_handlers[];
  30
  31 external_sensor_worker::external_sensor_worker(const csocket& socket)
  32 : m_client_id(CLIENT_ID_INVALID)
  33 , m_socket(socket)
  34 , m_sensor(NULL)
  35 , m_sensor_id(UNKNOWN_SENSOR)
  36 {
  37         static bool init = false;
  38
  39         if (!init) {
  40                 init_cmd_handlers();
  41                 init = true;
  42         }
  43
  44         m_worker.set_context(this);
  45         m_worker.set_working(working);
  46         m_worker.set_stopped(stopped);
  47 }
  48
  49 external_sensor_worker::~external_sensor_worker()
  50 {
  51         m_socket.close();
  52 }
  53
  54 bool external_sensor_worker::start(void)
  55 {
  56         return m_worker.start();
  57 }
  58
  59 void external_sensor_worker::init_cmd_handlers(void)
  60 {
  61         m_cmd_handlers[CMD_EXT_GET_ID]          = &external_sensor_worker::cmd_get_id;
  62         m_cmd_handlers[CMD_EXT_CONNECT]         = &external_sensor_worker::cmd_connect;
  63         m_cmd_handlers[CMD_EXT_DISCONNECT]      = &external_sensor_worker::cmd_disconnect;
  64         m_cmd_handlers[CMD_EXT_POST]            = &external_sensor_worker::cmd_post;
  65 }
  66
  67 bool external_sensor_worker::working(void *ctx)
  68 {
  69         bool ret;
  70         external_sensor_worker *inst = (external_sensor_worker *)ctx;
  71
  72         packet_header header;
  73         char *payload;
  74
  75         if (inst->m_socket.recv(&header, sizeof(header)) <= 0) {
  76                 string info;
  77                 inst->get_info(info);
  78                 _D("%s failed to receive header", info.c_str());
  79                 return false;
  80         }
  81
  82         retvm_if(header.size == 0, false, "Invalid header size");
  83
  84         payload = new(std::nothrow) char[header.size];
  85         retvm_if(!payload, false, "Failed to allocate memory");
  86
  87         if (inst->m_socket.recv(payload, header.size) <= 0) {
  88                 string info;
  89                 inst->get_info(info);
  90                 _D("%s failed to receive data of packet", info.c_str());
  91                 delete[] payload;
  92                 return false;
  93         }
  94
  95         ret = inst->dispatch_command(header.cmd, payload);
  96
  97         delete[] payload;
  98         return ret;
  99 }
 100
 101 bool external_sensor_worker::stopped(void *ctx)
 102 {
 103         string info;
 104         external_sensor_worker *inst = (external_sensor_worker *)ctx;
 105
 106         inst->get_info(info);
 107         _I("%s is stopped", info.c_str());
 108
 109         if (inst->m_client_id != CLIENT_ID_INVALID) {
 110                 _I("Client:%d leaves without disconnecting", inst->m_client_id);
 111                 if (get_client_manager().has_sensor_record(inst->m_client_id, inst->m_sensor_id)) {
 112                         _I("Removing sensor[%#x] record for client_id[%d]", inst->m_sensor_id, inst->m_client_id);
 113                         get_client_manager().remove_sensor_record(inst->m_client_id, inst->m_sensor_id);
 114
 115                         if (inst->m_sensor)
 116                                 inst->m_sensor->set_source_connected(false);
 117                 }
 118         }
 119
 120         delete inst;
 121         return true;
 122 }
 123
 124 bool external_sensor_worker::dispatch_command(int cmd, void* payload)
 125 {
 126         int ret = false;
 127
 128         if (!(cmd > 0 && cmd < CMD_EXT_CNT)) {
 129                 _E("Unknown command: %d", cmd);
 130         } else {
 131                 cmd_handler_t cmd_handler;
 132                 cmd_handler = external_sensor_worker::m_cmd_handlers[cmd];
 133                 if (cmd_handler)
 134                         ret = (this->*cmd_handler)(payload);
 135         }
 136
 137         return ret;
 138 }
 139
 140 bool external_sensor_worker::send_cmd_done(long value)
 141 {
 142         cpacket* ret_packet;
 143         cmd_ext_done_t *cmd_ext_done;
 144
 145         ret_packet = new(std::nothrow) cpacket(sizeof(cmd_ext_done_t));
 146         retvm_if(!ret_packet, false, "Failed to allocate memory");
 147
 148         ret_packet->set_cmd(CMD_EXT_DONE);
 149
 150         cmd_ext_done = (cmd_ext_done_t*)ret_packet->data();
 151         cmd_ext_done->value = value;
 152
 153         if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
 154                 _E("Failed to send a cmd_done to client_id [%d] with value [%ld]", m_client_id, value);
 155                 delete ret_packet;
 156                 return false;
 157         }
 158
 159         delete ret_packet;
 160         return true;
 161 }
 162
 163 bool external_sensor_worker::send_cmd_get_id_done(int client_id)
 164 {
 165         cpacket* ret_packet;
 166         cmd_ext_get_id_done_t *cmd_ext_get_id_done;
 167
 168         ret_packet = new(std::nothrow) cpacket(sizeof(cmd_ext_get_id_done_t));
 169         retvm_if(!ret_packet, false, "Failed to allocate memory");
 170
 171         ret_packet->set_cmd(CMD_EXT_GET_ID);
 172
 173         cmd_ext_get_id_done = (cmd_ext_get_id_done_t*)ret_packet->data();
 174         cmd_ext_get_id_done->client_id = client_id;
 175
 176         if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
 177                 _E("Failed to send a cmd_get_id_done with client_id [%d]", client_id);
 178                 delete ret_packet;
 179                 return false;
 180         }
 181
 182         delete ret_packet;
 183         return true;
 184 }
 185
 186 bool external_sensor_worker::send_cmd_connect_done(sensor_id_t sensor_id)
 187 {
 188         cpacket* ret_packet;
 189         cmd_ext_connect_done_t *cmd_ext_connect_done;
 190
 191         ret_packet = new(std::nothrow) cpacket(sizeof(cmd_ext_connect_done_t));
 192         retvm_if(!ret_packet, false, "Failed to allocate memory");
 193
 194         ret_packet->set_cmd(CMD_EXT_CONNECT);
 195
 196         cmd_ext_connect_done = (cmd_ext_connect_done_t*)ret_packet->data();
 197         cmd_ext_connect_done->sensor_id = sensor_id;
 198
 199         if (m_socket.send(ret_packet->packet(), ret_packet->size()) <= 0) {
 200                 _E("Failed to send a cmd_connect done");
 201                 delete ret_packet;
 202                 return false;
 203         }
 204
 205         delete ret_packet;
 206         return true;
 207 }
 208
 209 bool external_sensor_worker::cmd_get_id(void *payload)
 210 {
 211         cmd_ext_get_id_t *cmd = static_cast<cmd_ext_get_id_t *>(payload);
 212         int client_id;
 213         struct ucred cr;
 214         socklen_t opt_len = sizeof(cr);
 215
 216         if (getsockopt(m_socket.get_socket_fd(), SOL_SOCKET, SO_PEERCRED, &cr, &opt_len)) {
 217                 _E("Failed to get socket option with SO_PEERCRED");
 218                 return false;
 219         }
 220
 221         client_id = get_client_manager().create_client_record();
 222
 223         if (client_id != MAX_HANDLE_REACHED) {
 224                 get_client_manager().set_client_info(client_id, cr.pid, cmd->name);
 225                 _I("New client id [%d] created", client_id);
 226         }
 227
 228         if (!send_cmd_get_id_done(client_id))
 229                 _E("Failed to send cmd_done to a client");
 230
 231         return true;
 232 }
 233
 234 bool external_sensor_worker::cmd_connect(void *payload)
 235 {
 236         cmd_ext_connect_t *cmd = static_cast<cmd_ext_connect_t *>(payload);
 237         m_client_id = cmd->client_id;
 238
 239         external_sensor *sensor;
 240         sensor = external_sensor_service::get_instance().get_sensor(string(cmd->key));
 241         if (!sensor) {
 242                 _E("No matched external sensor with key: %s", cmd->key);
 243                 goto out;
 244         }
 245
 246         if (!sensor->set_source_connected(true)) {
 247                 _E("External sensor(%s) is already connected", cmd->key);
 248                 goto out;
 249         }
 250
 251         m_sensor = sensor;
 252         m_sensor_id = sensor->get_id();
 253
 254         if (!get_client_manager().create_sensor_record(m_client_id, m_sensor_id)) {
 255                 _E("Failed to create sensor record for client: %d, sensor_id: %d", m_client_id, m_sensor_id);
 256                 m_sensor_id = UNKNOWN_SENSOR;
 257                 goto out;
 258         }
 259
 260 out:
 261         if (!send_cmd_connect_done(m_sensor_id))
 262                 _E("Failed to send cmd_connect_done to a client : %d", m_client_id);
 263
 264         return true;
 265 }
 266
 267 bool external_sensor_worker::cmd_disconnect(void *payload)
 268 {
 269         long ret_value = OP_ERROR;
 270
 271         if (!m_sensor) {
 272                 _E("External sensor is not connected");
 273                 ret_value = OP_ERROR;
 274                 goto out;
 275         }
 276
 277         if (!get_client_manager().remove_sensor_record(m_client_id, m_sensor_id)) {
 278                 _E("Failed to remove sensor record for client [%d]", m_client_id);
 279                 ret_value = OP_ERROR;
 280                 goto out;
 281         }
 282
 283         m_sensor->set_source_connected(false);
 284
 285         m_sensor = NULL;
 286         m_client_id = CLIENT_ID_INVALID;
 287         m_sensor_id = UNKNOWN_SENSOR;
 288         ret_value = OP_SUCCESS;
 289 out:
 290         if (!send_cmd_done(ret_value))
 291                 _E("Failed to send cmd_done to a client");
 292
 293         if (ret_value == OP_SUCCESS)
 294                 return false;
 295
 296         return true;
 297 }
 298
 299 bool external_sensor_worker::cmd_post(void *payload)
 300 {
 301         long ret_value = OP_SUCCESS;
 302         cmd_ext_post_t *cmd = static_cast<cmd_ext_post_t *>(payload);
 303
 304         m_sensor->on_receive(cmd->timestamp, cmd->data, cmd->data_cnt);
 305
 306         if (!send_cmd_done(ret_value))
 307                 _E("Failed to send cmd_done to a client");
 308
 309         return true;
 310 }
 311
 312 external_client_manager& external_sensor_worker::get_client_manager(void)
 313 {
 314         return external_client_manager::get_instance();
 315 }
 316
 317 void external_sensor_worker::get_info(string &info)
 318 {
 319         const char *client_info = NULL;
 320
 321         if (m_client_id != CLIENT_ID_INVALID)
 322                 client_info = get_client_manager().get_client_info(m_client_id);
 323
 324         info = string("Command worker for ") + (client_info ? string(client_info) : string("Unknown"));
 325 }