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