src/client/command_channel.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2013 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 <stdlib.h>
  21 #include <command_channel.h>
  22 #include <client_common.h>
  23 #include <command_common.h>
  24 #include <sensor_info.h>
  25 #include <sensor_info_manager.h>
  26
  27 command_channel::command_channel()
  28 : m_client_id(CLIENT_ID_INVALID)
  29 , m_sensor_id(UNKNOWN_SENSOR)
  30 {
  31 }
  32
  33 command_channel::~command_channel()
  34 {
  35         if (m_command_socket.is_valid())
  36                 m_command_socket.close();
  37 }
  38
  39 bool command_channel::command_handler(cpacket *packet, void **return_payload)
  40 {
  41         if (!m_command_socket.is_valid()) {
  42                 _E("Command socket(%d) is not valid for client %s", m_command_socket.get_socket_fd(), get_client_name());
  43                 return false;
  44         }
  45
  46         if (packet->size() == 0) {
  47                 _E("Packet is not valid for client %s", get_client_name());
  48                 return false;
  49         }
  50
  51         if (m_command_socket.send(packet->packet(), packet->size()) <= 0) {
  52                 m_command_socket.close();
  53                 _E("Failed to send command in client %s", get_client_name());
  54                 return false;
  55         }
  56
  57         packet_header header;
  58
  59         if (m_command_socket.recv(&header, sizeof(header)) <= 0) {
  60                 m_command_socket.close();
  61                 _E("Failed to receive header for command reply packet in client %s", get_client_name());
  62                 return false;
  63         }
  64
  65         char *buffer = new(std::nothrow) char[header.size];
  66         retvm_if(!buffer, false, "Failed to allocate memory");
  67
  68         if (m_command_socket.recv(buffer, header.size) <= 0) {
  69                 m_command_socket.close();
  70                 _E("Failed to receive command reply packet in client %s", get_client_name());
  71                 delete[] buffer;
  72                 return false;
  73         }
  74
  75         *return_payload = buffer;
  76
  77         return true;
  78 }
  79
  80 bool command_channel::create_channel(void)
  81 {
  82         const int cllient_type = CLIENT_TYPE_SENSOR_CLIENT;
  83         if (!m_command_socket.create(SOCK_STREAM))
  84                 return false;
  85
  86         if (!m_command_socket.connect(COMMAND_CHANNEL_PATH)) {
  87                 _E("Failed to connect command channel for client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd());
  88                 return false;
  89         }
  90
  91         m_command_socket.set_connection_mode();
  92
  93         if (m_command_socket.send(&cllient_type, sizeof(cllient_type)) <= 0) {
  94                 _E("Failed to send client type in client %s, command socket fd[%d]", get_client_name(), m_command_socket.get_socket_fd());
  95                 return false;
  96         }
  97
  98         return true;
  99 }
 100
 101 void command_channel::set_client_id(int client_id)
 102 {
 103         m_client_id = client_id;
 104 }
 105
 106 bool command_channel::cmd_get_id(int &client_id)
 107 {
 108         cpacket *packet;
 109         cmd_get_id_t *cmd_get_id;
 110         cmd_get_id_done_t *cmd_get_id_done;
 111
 112         packet = new(std::nothrow) cpacket(sizeof(cmd_get_id_t));
 113         retvm_if(!packet, false, "Failed to allocate memory");
 114
 115         packet->set_cmd(CMD_GET_ID);
 116
 117         cmd_get_id = (cmd_get_id_t *)packet->data();
 118
 119         get_proc_name(getpid(), cmd_get_id->name);
 120
 121         _I("%s send cmd_get_id()", get_client_name());
 122
 123         if (!command_handler(packet, (void **)&cmd_get_id_done)) {
 124                 _E("Client %s failed to send/receive command", get_client_name());
 125                 delete packet;
 126                 return false;
 127         }
 128
 129         if (cmd_get_id_done->client_id < 0) {
 130                 _E("Client %s failed to get client_id[%d] from server",
 131                         get_client_name(), cmd_get_id_done->client_id);
 132                 delete[] (char *)cmd_get_id_done;
 133                 delete packet;
 134                 return false;
 135         }
 136
 137         client_id = cmd_get_id_done->client_id;
 138
 139         delete[] (char *)cmd_get_id_done;
 140         delete packet;
 141
 142         return true;
 143 }
 144
 145 bool command_channel::cmd_get_sensor_list(void)
 146 {
 147         cpacket packet;
 148         cmd_get_sensor_list_done_t *cmd_get_sensor_list_done;
 149
 150         packet.set_payload_size(sizeof(cmd_get_sensor_list_t));
 151         packet.set_cmd(CMD_GET_SENSOR_LIST);
 152
 153         _I("%s send cmd_get_sensor_list", get_client_name());
 154
 155         if (!command_handler(&packet, (void **)&cmd_get_sensor_list_done)) {
 156                 _E("Client %s failed to send/receive command", get_client_name());
 157                 return false;
 158         }
 159
 160         int sensor_cnt;
 161         const size_t *size_field;
 162         const char *raw_data_field;
 163
 164         sensor_cnt = cmd_get_sensor_list_done->sensor_cnt;
 165         size_field = (const size_t *)cmd_get_sensor_list_done->data;
 166         raw_data_field = (const char *)size_field + (sizeof(size_t) * sensor_cnt);
 167
 168         sensor_info *info;
 169
 170         int idx = 0;
 171         for (int i = 0; i < sensor_cnt; ++i) {
 172                 info = new(std::nothrow) sensor_info;
 173
 174                 if (!info) {
 175                         _E("Failed to allocate memory");
 176                         delete[] (char *)cmd_get_sensor_list_done;
 177                         return false;
 178                 }
 179
 180                 info->set_raw_data(raw_data_field + idx, size_field[i]);
 181                 sensor_info_manager::get_instance().add_info(info);
 182                 idx += size_field[i];
 183         }
 184
 185         delete[] (char *)cmd_get_sensor_list_done;
 186         return true;
 187 }
 188
 189 bool command_channel::cmd_hello(sensor_id_t sensor)
 190 {
 191         cpacket *packet;
 192         cmd_hello_t *cmd_hello;
 193         cmd_done_t *cmd_done;
 194
 195         packet = new(std::nothrow) cpacket(sizeof(cmd_hello_t));
 196         retvm_if(!packet, false, "Failed to allocate memory");
 197
 198         packet->set_cmd(CMD_HELLO);
 199
 200         cmd_hello = (cmd_hello_t*)packet->data();
 201         cmd_hello->client_id = m_client_id;
 202         cmd_hello->sensor = sensor;
 203
 204         _I("%s send cmd_hello(client_id=%d, %s)",
 205                 get_client_name(), m_client_id, get_sensor_name(sensor));
 206
 207         if (!command_handler(packet, (void **)&cmd_done)) {
 208                 _E("Client %s failed to send/receive command for sensor[%s]",
 209                         get_client_name(), get_sensor_name(sensor));
 210                 delete packet;
 211                 return false;
 212         }
 213
 214         if (cmd_done->value < 0) {
 215                 _W("client %s got value[%d] from server with sensor [%s]",
 216                         get_client_name(), cmd_done->value, get_sensor_name(sensor));
 217
 218                 delete[] (char *)cmd_done;
 219                 delete packet;
 220                 return false;
 221         }
 222
 223         delete[] (char *)cmd_done;
 224         delete packet;
 225
 226         m_sensor_id = sensor;
 227
 228         return true;
 229 }
 230
 231 bool command_channel::cmd_byebye(void)
 232 {
 233         cpacket *packet;
 234         cmd_done_t *cmd_done;
 235
 236         packet = new(std::nothrow) cpacket(sizeof(cmd_byebye_t));
 237         retvm_if(!packet, false, "Failed to allocate memory");
 238
 239         packet->set_cmd(CMD_BYEBYE);
 240
 241         _I("%s send cmd_byebye(client_id=%d, %s)",
 242                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
 243
 244         if (!command_handler(packet, (void **)&cmd_done)) {
 245                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
 246                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
 247                 delete packet;
 248                 return false;
 249         }
 250
 251         if (cmd_done->value < 0) {
 252                 _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
 253                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
 254
 255                 delete[] (char *)cmd_done;
 256                 delete packet;
 257                 return false;
 258         }
 259
 260         delete[] (char *)cmd_done;
 261         delete packet;
 262
 263         if (m_command_socket.is_valid())
 264                 m_command_socket.close();
 265
 266         m_client_id = CLIENT_ID_INVALID;
 267         m_sensor_id = UNKNOWN_SENSOR;
 268
 269         return true;
 270 }
 271
 272 bool command_channel::cmd_start(void)
 273 {
 274         cpacket *packet;
 275         cmd_done_t *cmd_done;
 276
 277         packet = new(std::nothrow) cpacket(sizeof(cmd_start_t));
 278         retvm_if(!packet, false, "Failed to allocate memory");
 279
 280         packet->set_cmd(CMD_START);
 281
 282         _I("%s send cmd_start(client_id=%d, %s)",
 283                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
 284
 285         if (!command_handler(packet, (void **)&cmd_done)) {
 286                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
 287                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
 288                 delete packet;
 289                 return false;
 290         }
 291
 292         if (cmd_done->value < 0) {
 293                 _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
 294                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
 295
 296                 delete[] (char *)cmd_done;
 297                 delete packet;
 298                 return false;
 299         }
 300
 301         delete[] (char *)cmd_done;
 302         delete packet;
 303
 304         return true;
 305 }
 306
 307 bool command_channel::cmd_stop(void)
 308 {
 309         cpacket *packet;
 310         cmd_done_t *cmd_done;
 311
 312         packet = new(std::nothrow) cpacket(sizeof(cmd_stop_t));
 313         retvm_if(!packet, false, "Failed to allocate memory");
 314
 315         packet->set_cmd(CMD_STOP);
 316
 317         _I("%s send cmd_stop(client_id=%d, %s)",
 318                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
 319
 320         if (!command_handler(packet, (void **)&cmd_done)) {
 321                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
 322                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
 323                 delete packet;
 324                 return false;
 325         }
 326
 327         if (cmd_done->value < 0) {
 328                 _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
 329                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
 330
 331                 delete[] (char *)cmd_done;
 332                 delete packet;
 333                 return false;
 334         }
 335
 336         delete[] (char *)cmd_done;
 337         delete packet;
 338
 339         return true;
 340 }
 341
 342 bool command_channel::cmd_set_pause_policy(int pause_policy)
 343 {
 344         cpacket *packet;
 345         cmd_set_pause_policy_t *cmd_set_pause_policy;
 346         cmd_done_t *cmd_done;
 347
 348         packet = new(std::nothrow) cpacket(sizeof(cmd_set_pause_policy_t));
 349         retvm_if(!packet, false, "Failed to allocate memory");
 350
 351         packet->set_cmd(CMD_SET_PAUSE_POLICY);
 352
 353         cmd_set_pause_policy = (cmd_set_pause_policy_t*)packet->data();
 354         cmd_set_pause_policy->pause_policy = pause_policy;
 355
 356         _I("%s send cmd_set_pause_policy(client_id=%d, %s, pause_policy=%d)",
 357                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id), pause_policy);
 358
 359         if (!command_handler(packet, (void **)&cmd_done)) {
 360                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], pause_policy[%d]",
 361                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id, pause_policy);
 362                 delete packet;
 363                 return false;
 364         }
 365
 366         if (cmd_done->value < 0) {
 367                 _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d], pause_policy[%d]",
 368                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, pause_policy);
 369
 370                 delete[] (char *)cmd_done;
 371                 delete packet;
 372                 return false;
 373         }
 374
 375         delete[] (char *)cmd_done;
 376         delete packet;
 377
 378         return true;
 379 }
 380
 381 bool command_channel::cmd_register_event(unsigned int event_type)
 382 {
 383         cpacket *packet;
 384         cmd_reg_t *cmd_reg;
 385         cmd_done_t *cmd_done;
 386
 387         packet = new(std::nothrow) cpacket(sizeof(cmd_reg_t));
 388         retvm_if(!packet, false, "Failed to allocate memory");
 389
 390         packet->set_cmd(CMD_REG);
 391
 392         cmd_reg = (cmd_reg_t*)packet->data();
 393         cmd_reg->event_type = event_type;
 394
 395         _I("%s send cmd_register_event(client_id=%d, %s)",
 396                 get_client_name(), m_client_id, get_event_name(event_type));
 397
 398         if (!command_handler(packet, (void **)&cmd_done)) {
 399                 _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
 400                         get_client_name(), m_client_id, get_event_name(event_type));
 401                 delete packet;
 402                 return false;
 403         }
 404
 405         if (cmd_done->value < 0) {
 406                 _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
 407                         get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type));
 408
 409                 delete[] (char *)cmd_done;
 410                 delete packet;
 411                 return false;
 412         }
 413
 414         delete[] (char *)cmd_done;
 415         delete packet;
 416
 417         return true;
 418 }
 419
 420 bool command_channel::cmd_register_events(event_type_vector &event_vec)
 421 {
 422         auto it_event = event_vec.begin();
 423
 424         while (it_event != event_vec.end()) {
 425                 if (!cmd_register_event(*it_event))
 426                         return false;
 427
 428                 ++it_event;
 429         }
 430
 431         return true;
 432 }
 433
 434 bool command_channel::cmd_unregister_event(unsigned int event_type)
 435 {
 436         cpacket *packet;
 437         cmd_unreg_t *cmd_unreg;
 438         cmd_done_t *cmd_done;
 439
 440         packet = new(std::nothrow) cpacket(sizeof(cmd_unreg_t));
 441         retvm_if(!packet, false, "Failed to allocate memory");
 442
 443         packet->set_cmd(CMD_UNREG);
 444
 445         cmd_unreg = (cmd_unreg_t*)packet->data();
 446         cmd_unreg->event_type = event_type;
 447
 448         _I("%s send cmd_unregister_event(client_id=%d, %s)",
 449                 get_client_name(), m_client_id, get_event_name(event_type));
 450
 451         if (!command_handler(packet, (void **)&cmd_done)) {
 452                 _E("Client %s failed to send/receive command with client_id [%d], event_type[%s]",
 453                         get_client_name(), m_client_id, get_event_name(event_type));
 454                 delete packet;
 455                 return false;
 456         }
 457
 458         if (cmd_done->value < 0) {
 459                 _E("Client %s got error[%d] from server with client_id [%d], event_type[%s]",
 460                         get_client_name(), cmd_done->value, m_client_id, get_event_name(event_type));
 461
 462                 delete[] (char *)cmd_done;
 463                 delete packet;
 464                 return false;
 465         }
 466
 467         delete[] (char *)cmd_done;
 468         delete packet;
 469
 470         return true;
 471 }
 472
 473 bool command_channel::cmd_unregister_events(event_type_vector &event_vec)
 474 {
 475         auto it_event = event_vec.begin();
 476
 477         while (it_event != event_vec.end()) {
 478                 if (!cmd_unregister_event(*it_event))
 479                         return false;
 480
 481                 ++it_event;
 482         }
 483
 484         return true;
 485 }
 486
 487 bool command_channel::cmd_set_batch(unsigned int interval, unsigned int latency)
 488 {
 489         cpacket *packet;
 490         cmd_set_batch_t *cmd_set_batch;
 491         cmd_done_t *cmd_done;
 492
 493         packet = new(std::nothrow) cpacket(sizeof(cmd_set_batch_t));
 494         retvm_if(!packet, false, "Failed to allocate memory");
 495
 496         packet->set_cmd(CMD_SET_BATCH);
 497
 498         cmd_set_batch = (cmd_set_batch_t*)packet->data();
 499         cmd_set_batch->interval = interval;
 500         cmd_set_batch->latency = latency;
 501
 502         _I("%s send cmd_set_batch(client_id=%d, %s, interval=%d, latency = %d)",
 503                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id), interval, latency);
 504
 505         if (!command_handler(packet, (void **)&cmd_done)) {
 506                 _E("%s failed to send/receive command for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
 507                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id, interval, latency);
 508                 delete packet;
 509                 return false;
 510         }
 511
 512         if (cmd_done->value < 0) {
 513                 _E("%s got error[%d] from server for sensor[%s] with client_id [%d], interval[%d], latency[%d]",
 514                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id, interval, latency);
 515
 516                 delete[] (char *)cmd_done;
 517                 delete packet;
 518                 return false;
 519         }
 520
 521         delete[] (char *)cmd_done;
 522         delete packet;
 523
 524         return true;
 525 }
 526
 527 bool command_channel::cmd_unset_batch(void)
 528 {
 529         cpacket *packet;
 530         cmd_done_t *cmd_done;
 531
 532         packet = new(std::nothrow) cpacket(sizeof(cmd_unset_batch_t));
 533         retvm_if(!packet, false, "Failed to allocate memory");
 534
 535         packet->set_cmd(CMD_UNSET_BATCH);
 536
 537         _I("%s send cmd_unset_batch(client_id=%d, %s)",
 538                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id));
 539
 540         if (!command_handler(packet, (void **)&cmd_done)) {
 541                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d]",
 542                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id);
 543                 delete packet;
 544                 return false;
 545         }
 546
 547         if (cmd_done->value < 0) {
 548                 _E("Client %s got error[%d] from server for sensor[%s] with client_id [%d]",
 549                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), m_client_id);
 550
 551                 delete[] (char *)cmd_done;
 552                 delete packet;
 553                 return false;
 554         }
 555
 556         delete[] (char *)cmd_done;
 557         delete packet;
 558
 559         return true;
 560 }
 561
 562 bool command_channel::cmd_get_data(unsigned int type, sensor_data_t* sensor_data)
 563 {
 564         cpacket *packet;
 565         cmd_get_data_t *cmd_get_data;
 566         cmd_get_data_done_t *cmd_get_data_done;
 567
 568         packet = new(std::nothrow) cpacket(sizeof(cmd_get_data_done_t));
 569         retvm_if(!packet, false, "Failed to allocate memory");
 570
 571         packet->set_cmd(CMD_GET_DATA);
 572
 573         cmd_get_data = (cmd_get_data_t*)packet->data();
 574         cmd_get_data->type = type;
 575
 576         if (!command_handler(packet, (void **)&cmd_get_data_done)) {
 577                 _E("Client %s failed to send/receive command with client_id [%d]",
 578                         get_client_name(), m_client_id);
 579                 delete packet;
 580                 return false;
 581         }
 582
 583         if (cmd_get_data_done->state < 0 ) {
 584                 _E("Client %s got error[%d] from server with client_id [%d]",
 585                         get_client_name(), cmd_get_data_done->state, m_client_id);
 586                 sensor_data->accuracy = SENSOR_ACCURACY_UNDEFINED;
 587                 sensor_data->timestamp = 0;
 588                 sensor_data->value_count = 0;
 589                 delete[] (char *)cmd_get_data_done;
 590                 delete packet;
 591                 return false;
 592         }
 593
 594         memcpy(sensor_data, &cmd_get_data_done->base_data, sizeof(sensor_data_t));
 595
 596         delete[] (char *)cmd_get_data_done;
 597         delete packet;
 598
 599         return true;
 600 }
 601
 602 bool command_channel::cmd_set_attribute_int(int attribute, int value)
 603 {
 604         cpacket *packet;
 605         cmd_set_attribute_int_t *cmd_set_attribute_int;
 606         cmd_done_t *cmd_done;
 607
 608         packet = new(std::nothrow) cpacket(sizeof(cmd_set_attribute_int_t));
 609         retvm_if(!packet, false, "Failed to allocate memory");
 610
 611         packet->set_cmd(CMD_SET_ATTRIBUTE_INT);
 612
 613         cmd_set_attribute_int = (cmd_set_attribute_int_t*)packet->data();
 614         cmd_set_attribute_int->attribute = attribute;
 615         cmd_set_attribute_int->value = value;
 616
 617         _I("%s send cmd_set_attribute_int(client_id=%d, %s, %#x, %d)",
 618                 get_client_name(), m_client_id, get_sensor_name(m_sensor_id), attribute, value);
 619
 620         if (!command_handler(packet, (void **)&cmd_done)) {
 621                 _E("Client %s failed to send/receive command for sensor[%s] with client_id [%d], attribute[%#x], value[%d]",
 622                         get_client_name(), get_sensor_name(m_sensor_id), m_client_id, attribute, value);
 623                 delete packet;
 624                 return false;
 625         }
 626
 627         if (cmd_done->value < 0) {
 628                 _E("Client %s got error[%d] from server for sensor[%s] with attribute[%#x], value[%d]",
 629                         get_client_name(), cmd_done->value, get_sensor_name(m_sensor_id), attribute, value);
 630
 631                 delete[] (char *)cmd_done;
 632                 delete packet;
 633                 return false;
 634         }
 635
 636         delete[] (char *)cmd_done;
 637         delete packet;
 638
 639         return true;
 640 }
 641
 642 bool command_channel::cmd_set_attribute_str(int attribute, const char* value, int len)
 643 {
 644         cpacket *packet;
 645         cmd_set_attribute_str_t *cmd_set_attribute_str;
 646         cmd_done_t *cmd_done;
 647
 648         packet = new(std::nothrow) cpacket(sizeof(cmd_set_attribute_str_t) + len);
 649         retvm_if(!packet, false, "Failed to allocate memory");
 650
 651         packet->set_cmd(CMD_SET_ATTRIBUTE_STR);
 652
 653         cmd_set_attribute_str = (cmd_set_attribute_str_t*)packet->data();
 654         cmd_set_attribute_str->attribute = attribute;
 655         cmd_set_attribute_str->len = len;
 656         memcpy(cmd_set_attribute_str->value, value, len);
 657
 658         _I("%s send cmd_set_attribute_str(client_id=%d, attribute = %#x, value_len = %d, value = %#x)",
 659                 get_client_name(), m_client_id, attribute, len, value);
 660
 661         if (!command_handler(packet, (void **)&cmd_done)) {
 662                 _E("%s failed to send/receive command with client_id [%d]",
 663                         get_client_name(), m_client_id);
 664                 delete packet;
 665                 return false;
 666         }
 667
 668         if (cmd_done->value < 0) {
 669                 _E("%s got error[%d] from server with client_id [%d]",
 670                         get_client_name(), cmd_done->value, m_client_id);
 671
 672                 delete[] (char *)cmd_done;
 673                 delete packet;
 674                 return false;
 675         }
 676
 677         delete[] (char *)cmd_done;
 678         delete packet;
 679         return true;
 680 }
 681
 682 bool command_channel::cmd_flush(void)
 683 {
 684         cpacket *packet;
 685         cmd_done_t *cmd_done;
 686
 687         packet = new(std::nothrow) cpacket(sizeof(cmd_flush_t));
 688         retvm_if(!packet, false, "Failed to allocate memory");
 689
 690         packet->set_cmd(CMD_FLUSH);
 691
 692         _I("%s send cmd_flush(client_id=%d)", get_client_name(), m_client_id);
 693
 694         if (!command_handler(packet, (void **)&cmd_done)) {
 695                 _E("%s failed to send flush with client_id [%d]",
 696                         get_client_name(), m_client_id);
 697                 delete packet;
 698                 return false;
 699         }
 700
 701         if (cmd_done->value < 0) {
 702                 _E("%s got error[%d] from server with client_id [%d]",
 703                         get_client_name(), cmd_done->value, m_client_id);
 704
 705                 delete [] (char *)cmd_done;
 706                 delete packet;
 707                 return false;
 708         }
 709
 710         delete [] (char *)cmd_done;
 711         delete packet;
 712         return true;
 713 }