common/vc_command.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <cynara-client.h>
  18 #include <cynara-error.h>
  19 #include <cynara-session.h>
  20 #include <libintl.h>
  21 #include <stdlib.h>
  22 #include <system_info.h>
  23
  24 #include "vc_command.h"
  25 #include "vc_main.h"
  26 #include "voice_control_command.h"
  27 #include "voice_control_command_expand.h"
  28 #include "voice_control_common.h"
  29 #include "voice_control_key_defines.h"
  30
  31 static int g_feature_enabled = -1;
  32
  33 static int g_privilege_allowed = -1;
  34 static cynara *p_cynara = NULL;
  35
  36 static int __vc_cmd_get_feature_enabled()
  37 {
  38         if (0 == g_feature_enabled) {
  39                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  40                 return VC_ERROR_NOT_SUPPORTED;
  41         } else if (-1 == g_feature_enabled) {
  42                 bool vc_supported = false;
  43                 bool mic_supported = false;
  44                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  45                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  46                                 if (false == vc_supported || false == mic_supported) {
  47                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  48                                         g_feature_enabled = 0;
  49                                         return VC_ERROR_NOT_SUPPORTED;
  50                                 }
  51
  52                                 g_feature_enabled = 1;
  53                         } else {
  54                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  55                                 return VC_ERROR_NOT_SUPPORTED;
  56                         }
  57                 } else {
  58                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  59                         return VC_ERROR_NOT_SUPPORTED;
  60                 }
  61         }
  62
  63         return 0;
  64 }
  65
  66 static int __check_privilege_initialize()
  67 {
  68         int ret = cynara_initialize(&p_cynara, NULL);
  69         if (CYNARA_API_SUCCESS != ret)
  70                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
  71
  72         return ret == CYNARA_API_SUCCESS;
  73 }
  74
  75 static int __check_privilege(const char* uid, const char * privilege)
  76 {
  77         FILE *fp = NULL;
  78         char smack_label[1024] = "/proc/self/attr/current";
  79
  80         if (!p_cynara) {
  81             return false;
  82         }
  83
  84         fp = fopen(smack_label, "r");
  85         if (fp != NULL) {
  86             if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
  87                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
  88
  89             fclose(fp);
  90         }
  91
  92         pid_t pid = getpid();
  93         char *session = cynara_session_from_pid(pid);
  94         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
  95         SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
  96         if (session)
  97             free(session);
  98
  99         if (ret != CYNARA_API_ACCESS_ALLOWED)
 100             return false;
 101         return true;
 102 }
 103
 104 static void __check_privilege_deinitialize()
 105 {
 106         if (p_cynara)
 107                 cynara_finish(p_cynara);
 108         p_cynara = NULL;
 109 }
 110
 111 static int __vc_cmd_check_privilege()
 112 {
 113 #if 0
 114         char uid[16];
 115         int ret = -1;
 116
 117         if (0 == g_privilege_allowed) {
 118                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 119                 return VC_ERROR_PERMISSION_DENIED;
 120         } else if (-1 == g_privilege_allowed) {
 121                 if (false == __check_privilege_initialize()){
 122                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
 123                         return VC_ERROR_PERMISSION_DENIED;
 124                 }
 125                 snprintf(uid, 16, "%d", getuid());
 126                 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
 127                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 128                         g_privilege_allowed = 0;
 129                         __check_privilege_deinitialize();
 130                         return VC_ERROR_PERMISSION_DENIED;
 131                 }
 132                 __check_privilege_deinitialize();
 133         }
 134
 135         g_privilege_allowed = 1;
 136 #endif
 137         return VC_ERROR_NONE;
 138 }
 139
 140 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
 141 {
 142         if (0 != __vc_cmd_get_feature_enabled()) {
 143                 return VC_ERROR_NOT_SUPPORTED;
 144         }
 145         if (0 != __vc_cmd_check_privilege()) {
 146                 return VC_ERROR_PERMISSION_DENIED;
 147         }
 148
 149         if (NULL == vc_cmd_list) {
 150                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 151                 return VC_ERROR_INVALID_PARAMETER;
 152         }
 153
 154         vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
 155
 156         if (NULL == list) {
 157                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 158                 return VC_ERROR_OUT_OF_MEMORY;
 159         }
 160
 161         list->index = -1;
 162         list->list = NULL;
 163
 164         *vc_cmd_list = (vc_cmd_list_h)list;
 165
 166         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
 167
 168         return VC_ERROR_NONE;
 169 }
 170
 171 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
 172 {
 173         if (0 != __vc_cmd_get_feature_enabled()) {
 174                 return VC_ERROR_NOT_SUPPORTED;
 175         }
 176         if (0 != __vc_cmd_check_privilege()) {
 177                 return VC_ERROR_PERMISSION_DENIED;
 178         }
 179
 180         if (NULL == vc_cmd_list) {
 181                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 182                 return VC_ERROR_INVALID_PARAMETER;
 183         }
 184
 185         vc_cmd_list_remove_all(vc_cmd_list, release_command);
 186
 187         vc_cmd_list_s* list = NULL;
 188         list = (vc_cmd_list_s*)vc_cmd_list;
 189
 190         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
 191
 192         if (NULL != list) {
 193                 free(list);
 194                 list = NULL;
 195         }
 196
 197         return VC_ERROR_NONE;
 198 }
 199
 200 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
 201 {
 202         if (0 != __vc_cmd_get_feature_enabled()) {
 203                 return VC_ERROR_NOT_SUPPORTED;
 204         }
 205         if (0 != __vc_cmd_check_privilege()) {
 206                 return VC_ERROR_PERMISSION_DENIED;
 207         }
 208
 209         if (NULL == vc_cmd_list || NULL == count) {
 210                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
 211                 return VC_ERROR_INVALID_PARAMETER;
 212         }
 213
 214         vc_cmd_list_s* list = NULL;
 215         list = (vc_cmd_list_s*)vc_cmd_list;
 216
 217         *count = g_slist_length(list->list);
 218
 219         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
 220
 221         return VC_ERROR_NONE;
 222 }
 223
 224 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 225 {
 226         if (0 != __vc_cmd_get_feature_enabled()) {
 227                 return VC_ERROR_NOT_SUPPORTED;
 228         }
 229         if (0 != __vc_cmd_check_privilege()) {
 230                 return VC_ERROR_PERMISSION_DENIED;
 231         }
 232
 233         if (NULL == vc_cmd_list || NULL == vc_command) {
 234                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 235                 return VC_ERROR_INVALID_PARAMETER;
 236         }
 237
 238         vc_cmd_list_s* list = NULL;
 239         list = (vc_cmd_list_s*)vc_cmd_list;
 240
 241         vc_cmd_s* cmd = NULL;
 242         cmd = (vc_cmd_s*)vc_command;
 243
 244         list->list = g_slist_append(list->list, cmd);
 245
 246         if (1 == g_slist_length(list->list)) {
 247                 list->index = 0;
 248         }
 249
 250         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 251
 252         return VC_ERROR_NONE;
 253 }
 254
 255 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 256 {
 257         if (0 != __vc_cmd_get_feature_enabled()) {
 258                 return VC_ERROR_NOT_SUPPORTED;
 259         }
 260         if (0 != __vc_cmd_check_privilege()) {
 261                 return VC_ERROR_PERMISSION_DENIED;
 262         }
 263
 264         if (NULL == vc_cmd_list || NULL == vc_command) {
 265                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 266                 return VC_ERROR_INVALID_PARAMETER;
 267         }
 268
 269         vc_cmd_list_s* list = NULL;
 270         list = (vc_cmd_list_s*)vc_cmd_list;
 271
 272         vc_cmd_s* cmd = NULL;
 273         cmd = (vc_cmd_s*)vc_command;
 274
 275         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 276
 277         vc_cmd_s* temp_cmd = NULL;
 278         GSList *iter = NULL;
 279
 280         iter = g_slist_nth(list->list, 0);
 281
 282         while (NULL != iter) {
 283                 temp_cmd = iter->data;
 284
 285                 if (NULL != temp_cmd && cmd == temp_cmd) {
 286                         list->list = g_slist_remove(list->list, temp_cmd);
 287                         /*
 288                         if (true == release_command) {
 289                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
 290                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 291                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 292                                 free(temp_cmd);
 293                                 temp_cmd = NULL;
 294                         }
 295                         */
 296                 }
 297
 298                 iter = g_slist_next(iter);
 299         }
 300
 301         int count = g_slist_length(list->list);
 302
 303         if (0 == count) {
 304                 list->index = -1;
 305         } else if (list->index == count) {
 306                 list->index = count - 1;
 307         }
 308
 309         return VC_ERROR_NONE;
 310 }
 311
 312 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
 313 {
 314         if (0 != __vc_cmd_get_feature_enabled()) {
 315                 return VC_ERROR_NOT_SUPPORTED;
 316         }
 317         if (0 != __vc_cmd_check_privilege()) {
 318                 return VC_ERROR_PERMISSION_DENIED;
 319         }
 320
 321         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Destroy all command");
 322
 323         if (NULL == vc_cmd_list) {
 324                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 325                 return VC_ERROR_INVALID_PARAMETER;
 326         }
 327
 328         vc_cmd_list_s* list = NULL;
 329         list = (vc_cmd_list_s*)vc_cmd_list;
 330
 331         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
 332                  , list, release_command ? "true" : "false");
 333
 334         int count = g_slist_length(list->list);
 335
 336         int i ;
 337         vc_cmd_s *temp_cmd;
 338
 339         for (i = 0; i < count ; i++) {
 340                 temp_cmd = g_slist_nth_data(list->list, 0);
 341
 342                 if (NULL != temp_cmd) {
 343                         list->list = g_slist_remove(list->list, temp_cmd);
 344
 345                         if (true == release_command) {
 346                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
 347                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 348                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 349                                 free(temp_cmd);
 350                                 temp_cmd = NULL;
 351                         }
 352                 }
 353         }
 354
 355         list->index = -1;
 356
 357         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 358         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
 359
 360         return VC_ERROR_NONE;
 361 }
 362
 363 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
 364 {
 365         if (0 != __vc_cmd_get_feature_enabled()) {
 366                 return VC_ERROR_NOT_SUPPORTED;
 367         }
 368         if (0 != __vc_cmd_check_privilege()) {
 369                 return VC_ERROR_PERMISSION_DENIED;
 370         }
 371
 372         if (NULL == vc_cmd_list) {
 373                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 374                 return VC_ERROR_INVALID_PARAMETER;
 375         }
 376
 377         vc_cmd_list_s* list = NULL;
 378         list = (vc_cmd_list_s*)vc_cmd_list;
 379
 380         int count = g_slist_length(list->list);
 381         int i ;
 382
 383         GSList *iter = NULL;
 384         vc_cmd_s *temp_cmd;
 385
 386         iter = g_slist_nth(list->list, 0);
 387
 388         for (i = 0; i < count; i++) {
 389                 temp_cmd = iter->data;
 390
 391                 if (NULL != temp_cmd) {
 392                         if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
 393                                 break;
 394                         }
 395
 396                 }
 397                 iter = g_slist_next(iter);
 398         }
 399
 400         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Foreach commands Done");
 401
 402         return VC_ERROR_NONE;
 403 }
 404
 405 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
 406 {
 407         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Filter by type");
 408
 409         if (0 != __vc_cmd_get_feature_enabled()) {
 410                 return VC_ERROR_NOT_SUPPORTED;
 411         }
 412         if (0 != __vc_cmd_check_privilege()) {
 413                 return VC_ERROR_PERMISSION_DENIED;
 414         }
 415
 416         if (NULL == original) {
 417                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 418                 return VC_ERROR_INVALID_PARAMETER;
 419         }
 420
 421         if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
 422                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
 423                 return VC_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         vc_cmd_list_s* list = NULL;
 427         list = (vc_cmd_list_s*)original;
 428
 429         vc_cmd_list_h temp_list;
 430         if (0 != vc_cmd_list_create(&temp_list)) {
 431                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
 432                 return VC_ERROR_OPERATION_FAILED;
 433         }
 434
 435         int count = g_slist_length(list->list);
 436         int i;
 437
 438         GSList *iter = NULL;
 439         vc_cmd_s *iter_cmd;
 440
 441         iter = g_slist_nth(list->list, 0);
 442
 443         for (i = 0; i < count; i++) {
 444                 if (NULL != iter->data) {
 445                         iter_cmd = iter->data;
 446
 447                         if (NULL != iter_cmd) {
 448                                 int iter_type;
 449                                 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
 450                                         SLOG(LOG_ERROR,TAG_VCCMD, "[ERROR] Fail to get command type");
 451                                         continue;
 452                                 }
 453
 454                                 if (iter_type == type) {
 455                                         vc_cmd_h temp_cmd;
 456                                         if (0 != vc_cmd_create(&temp_cmd)) {
 457                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
 458                                                 continue;
 459                                         }
 460
 461                                         memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
 462                                         if (NULL != iter_cmd->command) {
 463                                                 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
 464                                         }
 465                                         if (NULL != iter_cmd->parameter) {
 466                                                 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
 467                                         }
 468
 469                                         if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
 470                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
 471                                                 vc_cmd_destroy(temp_cmd);
 472                                                 continue;
 473                                         }
 474                                 }
 475                         }
 476                 }
 477                 iter = g_slist_next(iter);
 478         }
 479
 480         count = 0;
 481         if (0 != vc_cmd_list_get_count(temp_list, &count)) {
 482                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
 483         } else {
 484                 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
 485         }
 486
 487         *filtered = temp_list;
 488
 489         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
 490
 491         return VC_ERROR_NONE;
 492 }
 493
 494 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
 495 {
 496         if (0 != __vc_cmd_get_feature_enabled()) {
 497                 return VC_ERROR_NOT_SUPPORTED;
 498         }
 499         if (0 != __vc_cmd_check_privilege()) {
 500                 return VC_ERROR_PERMISSION_DENIED;
 501         }
 502
 503         if (NULL == vc_cmd_list) {
 504                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 505                 return VC_ERROR_INVALID_PARAMETER;
 506         }
 507
 508         vc_cmd_list_s* list = NULL;
 509         list = (vc_cmd_list_s*)vc_cmd_list;
 510
 511         if (0 == g_slist_length(list->list)) {
 512                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 513                 return VC_ERROR_EMPTY;
 514         }
 515
 516         list->index = 0;
 517
 518         return VC_ERROR_NONE;
 519 }
 520
 521 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
 522 {
 523         if (0 != __vc_cmd_get_feature_enabled()) {
 524                 return VC_ERROR_NOT_SUPPORTED;
 525         }
 526         if (0 != __vc_cmd_check_privilege()) {
 527                 return VC_ERROR_PERMISSION_DENIED;
 528         }
 529
 530         if (NULL == vc_cmd_list) {
 531                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 532                 return VC_ERROR_INVALID_PARAMETER;
 533         }
 534
 535         vc_cmd_list_s* list = NULL;
 536         list = (vc_cmd_list_s*)vc_cmd_list;
 537
 538         int count = g_slist_length(list->list);
 539
 540         if (0 == count) {
 541                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 542                 return VC_ERROR_EMPTY;
 543         } else {
 544                 list->index = count - 1;
 545                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 546         }
 547
 548         return VC_ERROR_NONE;
 549 }
 550
 551 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
 552 {
 553         if (0 != __vc_cmd_get_feature_enabled()) {
 554                 return VC_ERROR_NOT_SUPPORTED;
 555         }
 556         if (0 != __vc_cmd_check_privilege()) {
 557                 return VC_ERROR_PERMISSION_DENIED;
 558         }
 559
 560         if (NULL == vc_cmd_list) {
 561                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 562                 return VC_ERROR_INVALID_PARAMETER;
 563         }
 564
 565         vc_cmd_list_s* list = NULL;
 566         list = (vc_cmd_list_s*)vc_cmd_list;
 567
 568         int count = g_slist_length(list->list);
 569
 570         if (list->index < count - 1) {
 571                 list->index = list->index + 1;
 572                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 573         } else {
 574                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 575                 return VC_ERROR_ITERATION_END;
 576         }
 577
 578         return VC_ERROR_NONE;
 579 }
 580
 581 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
 582 {
 583         if (0 != __vc_cmd_get_feature_enabled()) {
 584                 return VC_ERROR_NOT_SUPPORTED;
 585         }
 586         if (0 != __vc_cmd_check_privilege()) {
 587                 return VC_ERROR_PERMISSION_DENIED;
 588         }
 589
 590         if (NULL == vc_cmd_list) {
 591                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 592                 return VC_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         vc_cmd_list_s* list = NULL;
 596         list = (vc_cmd_list_s*)vc_cmd_list;
 597
 598         if (list->index > 0) {
 599                 list->index = list->index - 1;
 600                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 601         } else {
 602                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 603                 return VC_ERROR_ITERATION_END;
 604         }
 605
 606         return VC_ERROR_NONE;
 607 }
 608
 609 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
 610 {
 611         if (0 != __vc_cmd_get_feature_enabled()) {
 612                 return VC_ERROR_NOT_SUPPORTED;
 613         }
 614         if (0 != __vc_cmd_check_privilege()) {
 615                 return VC_ERROR_PERMISSION_DENIED;
 616         }
 617
 618         if (NULL == vc_cmd_list || NULL == vc_command) {
 619                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 620                 return VC_ERROR_INVALID_PARAMETER;
 621         }
 622
 623         vc_cmd_list_s* list = NULL;
 624         list = (vc_cmd_list_s*)vc_cmd_list;
 625
 626         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
 627
 628         if (0 == g_slist_length(list->list)) {
 629                 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
 630                 *vc_command = NULL;
 631                 return VC_ERROR_EMPTY;
 632         }
 633
 634         vc_cmd_s *temp_cmd = NULL;
 635         temp_cmd = g_slist_nth_data(list->list, list->index);
 636
 637         *vc_command = (vc_cmd_h)temp_cmd;
 638
 639         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
 640
 641         return VC_ERROR_NONE;
 642 }
 643
 644
 645 int vc_cmd_create(vc_cmd_h* vc_command)
 646 {
 647         if (0 != __vc_cmd_get_feature_enabled()) {
 648                 return VC_ERROR_NOT_SUPPORTED;
 649         }
 650         if (0 != __vc_cmd_check_privilege()) {
 651                 return VC_ERROR_PERMISSION_DENIED;
 652         }
 653
 654         if (NULL == vc_command) {
 655                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 656                 return VC_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
 660
 661         if (NULL == command) {
 662                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 663                 return VC_ERROR_OUT_OF_MEMORY;
 664         }
 665
 666         command->pid = 0;
 667         command->id = 0;
 668         command->index = 0;
 669         command->type = VC_COMMAND_TYPE_NONE;
 670         command->format = VC_CMD_FORMAT_FIXED;
 671         command->command = NULL;
 672         command->parameter = NULL;
 673         command->domain = 0;
 674         command->key = VC_KEY_NONE;
 675         command->modifier = VC_MODIFIER_NONE;
 676
 677         *vc_command = (vc_cmd_h)command;
 678
 679         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 680
 681         return VC_ERROR_NONE;
 682 }
 683
 684 int vc_cmd_destroy(vc_cmd_h vc_command)
 685 {
 686         if (0 != __vc_cmd_get_feature_enabled()) {
 687                 return VC_ERROR_NOT_SUPPORTED;
 688         }
 689         if (0 != __vc_cmd_check_privilege()) {
 690                 return VC_ERROR_PERMISSION_DENIED;
 691         }
 692
 693         if (NULL == vc_command) {
 694                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 695                 return VC_ERROR_INVALID_PARAMETER;
 696         }
 697
 698         vc_cmd_s* command = NULL;
 699         command = (vc_cmd_s*)vc_command;
 700
 701         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 702
 703         if (NULL != command) {
 704                 if (NULL != command->command)   free(command->command);
 705                 if (NULL != command->parameter) free(command->parameter);
 706                 free(command);
 707                 command = NULL;
 708         }
 709
 710         return VC_ERROR_NONE;
 711 }
 712
 713 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 714 {
 715         if (0 != __vc_cmd_get_feature_enabled()) {
 716                 return VC_ERROR_NOT_SUPPORTED;
 717         }
 718         if (0 != __vc_cmd_check_privilege()) {
 719                 return VC_ERROR_PERMISSION_DENIED;
 720         }
 721
 722         if (NULL == vc_command) {
 723                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 724                 return VC_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         vc_cmd_s* cmd = NULL;
 728         cmd = (vc_cmd_s*)vc_command;
 729
 730         if (NULL != cmd) {
 731                 cmd->id = id;
 732                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 733         }
 734
 735         return 0;
 736 }
 737
 738 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 739 {
 740         if (0 != __vc_cmd_get_feature_enabled()) {
 741                 return VC_ERROR_NOT_SUPPORTED;
 742         }
 743         if (0 != __vc_cmd_check_privilege()) {
 744                 return VC_ERROR_PERMISSION_DENIED;
 745         }
 746
 747         if (NULL == vc_command || NULL == id) {
 748                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 749                 return VC_ERROR_INVALID_PARAMETER;
 750         }
 751
 752         vc_cmd_s* cmd = NULL;
 753         cmd = (vc_cmd_s*)vc_command;
 754
 755         if (NULL != cmd) {
 756                 *id = cmd->id;
 757                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 758         }
 759
 760         return 0;
 761 }
 762
 763 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 764 {
 765         if (0 != __vc_cmd_get_feature_enabled()) {
 766                 return VC_ERROR_NOT_SUPPORTED;
 767         }
 768         if (0 != __vc_cmd_check_privilege()) {
 769                 return VC_ERROR_PERMISSION_DENIED;
 770         }
 771
 772         if (NULL == vc_command) {
 773                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 774                 return VC_ERROR_INVALID_PARAMETER;
 775         }
 776
 777         vc_cmd_s* cmd = NULL;
 778         cmd = (vc_cmd_s*)vc_command;
 779
 780         if (NULL != cmd->command) {
 781                 free(cmd->command);
 782         }
 783
 784         cmd->command = NULL;
 785
 786         if (NULL != command) {
 787                 cmd->command = strdup(command);
 788         }
 789
 790         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 791
 792         return 0;
 793 }
 794
 795 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 796 {
 797         if (0 != __vc_cmd_get_feature_enabled()) {
 798                 return VC_ERROR_NOT_SUPPORTED;
 799         }
 800         if (0 != __vc_cmd_check_privilege()) {
 801                 return VC_ERROR_PERMISSION_DENIED;
 802         }
 803
 804         if (NULL == vc_command || NULL == command) {
 805                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 806                 return VC_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         vc_cmd_s* cmd = NULL;
 810         cmd = (vc_cmd_s*)vc_command;
 811
 812         if (NULL != cmd->command) {
 813                 *command = strdup(gettext(cmd->command));
 814         }
 815
 816         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 817
 818         return 0;
 819 }
 820
 821 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 822 {
 823         if (0 != __vc_cmd_get_feature_enabled()) {
 824                 return VC_ERROR_NOT_SUPPORTED;
 825         }
 826         if (0 != __vc_cmd_check_privilege()) {
 827                 return VC_ERROR_PERMISSION_DENIED;
 828         }
 829
 830         if (NULL == vc_command) {
 831                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 832                 return VC_ERROR_INVALID_PARAMETER;
 833         }
 834
 835         vc_cmd_s* cmd = NULL;
 836         cmd = (vc_cmd_s*)vc_command;
 837
 838         if (NULL != cmd->parameter) {
 839                 free(cmd->parameter);
 840         }
 841
 842         cmd->parameter = NULL;
 843
 844         if (NULL != command) {
 845                 cmd->parameter = strdup(command);
 846                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] parameter(%s)", vc_command, cmd->parameter);
 847         }
 848
 849         return 0;
 850 }
 851
 852 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 853 {
 854         if (0 != __vc_cmd_get_feature_enabled()) {
 855                 return VC_ERROR_NOT_SUPPORTED;
 856         }
 857         if (0 != __vc_cmd_check_privilege()) {
 858                 return VC_ERROR_PERMISSION_DENIED;
 859         }
 860
 861         if (NULL == vc_command || NULL == command) {
 862                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 863                 return VC_ERROR_INVALID_PARAMETER;
 864         }
 865
 866         vc_cmd_s* cmd = NULL;
 867         cmd = (vc_cmd_s*)vc_command;
 868
 869         if (NULL != cmd->parameter) {
 870                 *command = strdup(gettext(cmd->parameter));
 871                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get nonfixed command][%p] nonfixed command(%s)", vc_command, *command);
 872         }
 873
 874         return 0;
 875 }
 876
 877 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
 878 {
 879         if (0 != __vc_cmd_get_feature_enabled()) {
 880                 return VC_ERROR_NOT_SUPPORTED;
 881         }
 882         if (0 != __vc_cmd_check_privilege()) {
 883                 return VC_ERROR_PERMISSION_DENIED;
 884         }
 885
 886         if (NULL == vc_command) {
 887                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 888                 return VC_ERROR_INVALID_PARAMETER;
 889         }
 890
 891         vc_cmd_s* cmd = NULL;
 892         cmd = (vc_cmd_s*)vc_command;
 893
 894         cmd->type = type;
 895
 896         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
 897
 898         return 0;
 899 }
 900
 901 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
 902 {
 903         if (0 != __vc_cmd_get_feature_enabled()) {
 904                 return VC_ERROR_NOT_SUPPORTED;
 905         }
 906         if (0 != __vc_cmd_check_privilege()) {
 907                 return VC_ERROR_PERMISSION_DENIED;
 908         }
 909
 910         if (NULL == vc_command || NULL == type) {
 911                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 912                 return VC_ERROR_INVALID_PARAMETER;
 913         }
 914
 915         vc_cmd_s* cmd = NULL;
 916         cmd = (vc_cmd_s*)vc_command;
 917
 918         *type = cmd->type;
 919
 920         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
 921
 922         return 0;
 923 }
 924
 925 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
 926 {
 927         if (0 != __vc_cmd_get_feature_enabled()) {
 928                 return VC_ERROR_NOT_SUPPORTED;
 929         }
 930         if (0 != __vc_cmd_check_privilege()) {
 931                 return VC_ERROR_PERMISSION_DENIED;
 932         }
 933
 934         if (NULL == vc_command) {
 935                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 936                 return VC_ERROR_INVALID_PARAMETER;
 937         }
 938
 939         vc_cmd_s* cmd = NULL;
 940         cmd = (vc_cmd_s*)vc_command;
 941
 942         cmd->format = format;
 943
 944         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
 945
 946         return 0;
 947 }
 948
 949 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
 950 {
 951         if (0 != __vc_cmd_get_feature_enabled()) {
 952                 return VC_ERROR_NOT_SUPPORTED;
 953         }
 954         if (0 != __vc_cmd_check_privilege()) {
 955                 return VC_ERROR_PERMISSION_DENIED;
 956         }
 957
 958         if (NULL == vc_command || NULL == format) {
 959                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 960                 return VC_ERROR_INVALID_PARAMETER;
 961         }
 962
 963         vc_cmd_s* cmd = NULL;
 964         cmd = (vc_cmd_s*)vc_command;
 965
 966         *format = cmd->format;
 967
 968         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
 969
 970         return 0;
 971 }
 972
 973 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
 974 {
 975         if (0 != __vc_cmd_get_feature_enabled()) {
 976                 return VC_ERROR_NOT_SUPPORTED;
 977         }
 978         if (0 != __vc_cmd_check_privilege()) {
 979                 return VC_ERROR_PERMISSION_DENIED;
 980         }
 981
 982         if (NULL == vc_command) {
 983                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 984                 return VC_ERROR_INVALID_PARAMETER;
 985         }
 986
 987         vc_cmd_s* cmd = NULL;
 988         cmd = (vc_cmd_s*)vc_command;
 989
 990         cmd->pid = pid;
 991
 992         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
 993
 994         return 0;
 995 }
 996
 997 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
 998 {
 999         if (0 != __vc_cmd_get_feature_enabled()) {
1000                 return VC_ERROR_NOT_SUPPORTED;
1001         }
1002         if (0 != __vc_cmd_check_privilege()) {
1003                 return VC_ERROR_PERMISSION_DENIED;
1004         }
1005
1006         if (NULL == vc_command || NULL == pid) {
1007                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1008                 return VC_ERROR_INVALID_PARAMETER;
1009         }
1010
1011         vc_cmd_s* cmd = NULL;
1012         cmd = (vc_cmd_s*)vc_command;
1013
1014         *pid = cmd->pid;
1015
1016         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1017
1018         return 0;
1019 }
1020
1021 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1022 {
1023         if (0 != __vc_cmd_get_feature_enabled()) {
1024                 return VC_ERROR_NOT_SUPPORTED;
1025         }
1026         if (0 != __vc_cmd_check_privilege()) {
1027                 return VC_ERROR_PERMISSION_DENIED;
1028         }
1029
1030         if (NULL == vc_command) {
1031                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1032                 return VC_ERROR_INVALID_PARAMETER;
1033         }
1034
1035         vc_cmd_s* cmd = NULL;
1036         cmd = (vc_cmd_s*)vc_command;
1037
1038         cmd->domain = domain;
1039
1040         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1041
1042         return 0;
1043 }
1044
1045 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1046 {
1047         if (0 != __vc_cmd_get_feature_enabled()) {
1048                 return VC_ERROR_NOT_SUPPORTED;
1049         }
1050         if (0 != __vc_cmd_check_privilege()) {
1051                 return VC_ERROR_PERMISSION_DENIED;
1052         }
1053
1054         if (NULL == vc_command || NULL == domain) {
1055                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1056                 return VC_ERROR_INVALID_PARAMETER;
1057         }
1058
1059         vc_cmd_s* cmd = NULL;
1060         cmd = (vc_cmd_s*)vc_command;
1061
1062         *domain = cmd->domain;
1063
1064         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1065
1066         return 0;
1067 }
1068
1069 /**
1070 * @brief Sets key value of command.
1071 *
1072 * @param[in] vc_command Command handle
1073 * @param[in] key key value
1074 * @param[in] modifier modifier value
1075 *
1076 * @return 0 on success, otherwise a negative error value
1077 * @retval #VC_ERROR_NONE Successful
1078 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1079 *
1080 * @see vc_cmd_get_result_key()
1081 */
1082 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1083 {
1084         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
1085
1086         if (NULL == vc_command) {
1087                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1088                 return VC_ERROR_INVALID_PARAMETER;
1089         }
1090
1091         vc_cmd_s* cmd = NULL;
1092         cmd = (vc_cmd_s*)vc_command;
1093
1094         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1095
1096         cmd->key = key;
1097         cmd->modifier = modifier;
1098
1099         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1100         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1101
1102         return 0;
1103 }
1104
1105 /**
1106 * @brief Gets key value of command.
1107 *
1108 * @param[in] vc_command Command handle
1109 * @param[out] key key value
1110 * @param[out] modifier modifier value
1111 *
1112 * @return 0 on success, otherwise a negative error value
1113 * @retval #VC_ERROR_NONE Successful
1114 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1115 *
1116 * @see vc_cmd_add_result_key()
1117 */
1118 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1119 {
1120         SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
1121
1122         if (NULL == vc_command || NULL == key || NULL == modifier) {
1123                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1124                 return VC_ERROR_INVALID_PARAMETER;
1125         }
1126
1127         vc_cmd_s* cmd = NULL;
1128         cmd = (vc_cmd_s*)vc_command;
1129
1130         *key = cmd->key;
1131         *modifier = cmd->modifier;
1132
1133         SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1134         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1135
1136         return 0;
1137 }
1138
1139 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1140 {
1141         if (NULL == vc_cmd_list) {
1142                 return -1;
1143         }
1144
1145         vc_cmd_list_s* list = NULL;
1146         list = (vc_cmd_list_s*)vc_cmd_list;
1147
1148         SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
1149         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1150
1151         int count = g_slist_length(list->list);
1152
1153         int i;
1154         vc_cmd_s *temp_cmd = NULL;
1155
1156         for (i = 0; i < count ; i++) {
1157                 temp_cmd = g_slist_nth_data(list->list, i);
1158
1159                 if (NULL != temp_cmd) {
1160                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Domain(%d) Command(%s) Param(%s)",
1161                                  i, temp_cmd, temp_cmd->pid, temp_cmd->index, temp_cmd->type, temp_cmd->format, temp_cmd->domain, temp_cmd->command, temp_cmd->parameter);
1162                 }
1163         }
1164
1165         SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1166         SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1167
1168         return 0;
1169 }