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