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 #define _GNU_SOURCE
  18
  19 #include <cynara-client.h>
  20 #include <cynara-error.h>
  21 #include <cynara-session.h>
  22 #include <libintl.h>
  23 #include <stdlib.h>
  24 #include <system_info.h>
  25
  26 #include "vc_command.h"
  27 #include "vc_info_parser.h"
  28 #include "vc_main.h"
  29 #include "vc_regex_rule.h"
  30 #include "vc_config_mgr.h"
  31 #include "voice_control_command.h"
  32 #include "voice_control_command_expand.h"
  33 #include "voice_control_common.h"
  34 #include "voice_control_key_defines.h"
  35
  36 static int g_feature_enabled = -1;
  37
  38 static int g_privilege_allowed = 1; /* Always True */
  39 static cynara *p_cynara = NULL;
  40 static GList *g_cmdlist_list = NULL;
  41
  42
  43 // For getting timestamp using regular expression
  44 static regex_t reg[MAX_NUM_REGEX];
  45 static time_t t_now;            //time_t is based on UTC
  46 static struct tm td_now;        //if use localtime function, the value follows the local time zone, otherwise it follows the UTC.
  47
  48 static int g_time_flag;
  49 static int g_date_flag;
  50
  51 static int g_data_sidx;
  52 static int g_data_eidx;
  53
  54 static int __vc_cmd_get_feature_enabled()
  55 {
  56         if (0 == g_feature_enabled) {
  57                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  58                 return VC_ERROR_NOT_SUPPORTED;
  59         } else if (-1 == g_feature_enabled) {
  60                 bool vc_supported = false;
  61                 bool mic_supported = false;
  62                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  63                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  64                                 if (false == vc_supported || false == mic_supported) {
  65                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
  66                                         g_feature_enabled = 0;
  67                                         return VC_ERROR_NOT_SUPPORTED;
  68                                 }
  69
  70                                 g_feature_enabled = 1;
  71                         } else {
  72                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  73                                 return VC_ERROR_NOT_SUPPORTED;
  74                         }
  75                 } else {
  76                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
  77                         return VC_ERROR_NOT_SUPPORTED;
  78                 }
  79         }
  80
  81         return 0;
  82 }
  83
  84 static int __check_privilege_initialize()
  85 {
  86         int ret = cynara_initialize(&p_cynara, NULL);
  87         if (CYNARA_API_SUCCESS != ret)
  88                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
  89
  90         return ret == CYNARA_API_SUCCESS;
  91 }
  92
  93 static int __check_privilege(const char* uid, const char * privilege)
  94 {
  95         FILE *fp = NULL;
  96         char label_path[1024] = "/proc/self/attr/current";
  97         char smack_label[1024] = {'\0',};
  98
  99         if (!p_cynara) {
 100                 return false;
 101         }
 102
 103         fp = fopen(label_path, "r");
 104         if (fp != NULL) {
 105                 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
 106                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
 107
 108                 fclose(fp);
 109         }
 110
 111         pid_t pid = getpid();
 112         char *session = cynara_session_from_pid(pid);
 113         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 114         SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
 115         if (session)
 116                 free(session);
 117
 118         if (ret != CYNARA_API_ACCESS_ALLOWED)
 119                 return false;
 120         return true;
 121 }
 122
 123 static void __check_privilege_deinitialize()
 124 {
 125         if (p_cynara)
 126                 cynara_finish(p_cynara);
 127         p_cynara = NULL;
 128 }
 129
 130 static int __vc_cmd_check_privilege()
 131 {
 132         char uid[16];
 133
 134         if (0 == g_privilege_allowed) {
 135                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 136                 return VC_ERROR_PERMISSION_DENIED;
 137         } else if (-1 == g_privilege_allowed) {
 138                 if (false == __check_privilege_initialize()) {
 139                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
 140                         return VC_ERROR_PERMISSION_DENIED;
 141                 }
 142                 snprintf(uid, 16, "%d", getuid());
 143                 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
 144                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
 145                         g_privilege_allowed = 0;
 146                         __check_privilege_deinitialize();
 147                         return VC_ERROR_PERMISSION_DENIED;
 148                 }
 149                 __check_privilege_deinitialize();
 150         }
 151
 152         g_privilege_allowed = 1;
 153
 154         return VC_ERROR_NONE;
 155 }
 156
 157 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
 158 {
 159         if (0 != __vc_cmd_get_feature_enabled()) {
 160                 return VC_ERROR_NOT_SUPPORTED;
 161         }
 162         if (0 != __vc_cmd_check_privilege()) {
 163                 return VC_ERROR_PERMISSION_DENIED;
 164         }
 165
 166         if (NULL == vc_cmd_list) {
 167                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 168                 return VC_ERROR_INVALID_PARAMETER;
 169         }
 170
 171         vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
 172
 173         if (NULL == list) {
 174                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 175                 return VC_ERROR_OUT_OF_MEMORY;
 176         }
 177
 178         list->index = -1;
 179         list->list = NULL;
 180
 181         *vc_cmd_list = (vc_cmd_list_h)list;
 182
 183         g_cmdlist_list = g_list_append(g_cmdlist_list, list);
 184
 185         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
 186
 187         return VC_ERROR_NONE;
 188 }
 189
 190 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
 191 {
 192         if (0 != __vc_cmd_get_feature_enabled()) {
 193                 return VC_ERROR_NOT_SUPPORTED;
 194         }
 195         if (0 != __vc_cmd_check_privilege()) {
 196                 return VC_ERROR_PERMISSION_DENIED;
 197         }
 198
 199         if (NULL == vc_cmd_list) {
 200                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 201                 return VC_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         vc_cmd_list_remove_all(vc_cmd_list, release_command);
 205
 206         vc_cmd_list_s* list = NULL;
 207         list = (vc_cmd_list_s*)vc_cmd_list;
 208
 209         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
 210
 211         GList *iter = NULL;
 212         vc_cmd_list_s *data = NULL;
 213
 214         /* if list have item */
 215         if (g_list_length(g_cmdlist_list) > 0) {
 216                 /* Get a first item */
 217                 iter = g_list_first(g_cmdlist_list);
 218
 219                 while (NULL != iter) {
 220                         data = iter->data;
 221                         if (data && list == data) {
 222                                 g_cmdlist_list = g_list_remove_link(g_cmdlist_list, iter);
 223
 224                                 free(data);
 225                                 data = NULL;
 226
 227                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
 228                                 g_list_free(iter);
 229
 230                                 return VC_ERROR_NONE;
 231                         }
 232                         /* Next item */
 233                         iter = g_list_next(iter);
 234                 }
 235         }
 236         SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
 237
 238         return VC_ERROR_INVALID_PARAMETER;
 239 }
 240
 241 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
 242 {
 243         if (0 != __vc_cmd_get_feature_enabled()) {
 244                 return VC_ERROR_NOT_SUPPORTED;
 245         }
 246         if (0 != __vc_cmd_check_privilege()) {
 247                 return VC_ERROR_PERMISSION_DENIED;
 248         }
 249
 250         if (NULL == vc_cmd_list || NULL == count) {
 251                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
 252                 return VC_ERROR_INVALID_PARAMETER;
 253         }
 254
 255         vc_cmd_list_s* list = NULL;
 256         list = (vc_cmd_list_s*)vc_cmd_list;
 257
 258         *count = g_slist_length(list->list);
 259
 260         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
 261
 262         return VC_ERROR_NONE;
 263 }
 264
 265 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 266 {
 267         if (0 != __vc_cmd_get_feature_enabled()) {
 268                 return VC_ERROR_NOT_SUPPORTED;
 269         }
 270         if (0 != __vc_cmd_check_privilege()) {
 271                 return VC_ERROR_PERMISSION_DENIED;
 272         }
 273
 274         if (NULL == vc_cmd_list || NULL == vc_command) {
 275                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 276                 return VC_ERROR_INVALID_PARAMETER;
 277         }
 278
 279         vc_cmd_list_s* list = NULL;
 280         list = (vc_cmd_list_s*)vc_cmd_list;
 281
 282         vc_cmd_s* cmd = NULL;
 283         cmd = (vc_cmd_s*)vc_command;
 284
 285         list->list = g_slist_append(list->list, cmd);
 286
 287         if (1 == g_slist_length(list->list)) {
 288                 list->index = 0;
 289         }
 290
 291         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 292
 293         return VC_ERROR_NONE;
 294 }
 295
 296 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
 297 {
 298         if (0 != __vc_cmd_get_feature_enabled()) {
 299                 return VC_ERROR_NOT_SUPPORTED;
 300         }
 301         if (0 != __vc_cmd_check_privilege()) {
 302                 return VC_ERROR_PERMISSION_DENIED;
 303         }
 304
 305         if (NULL == vc_cmd_list || NULL == vc_command) {
 306                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 307                 return VC_ERROR_INVALID_PARAMETER;
 308         }
 309
 310         vc_cmd_list_s* list = NULL;
 311         list = (vc_cmd_list_s*)vc_cmd_list;
 312
 313         vc_cmd_s* cmd = NULL;
 314         cmd = (vc_cmd_s*)vc_command;
 315
 316         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
 317
 318         vc_cmd_s* temp_cmd = NULL;
 319         GSList *iter = NULL;
 320
 321         iter = g_slist_nth(list->list, 0);
 322
 323         while (NULL != iter) {
 324                 temp_cmd = iter->data;
 325
 326                 if (NULL != temp_cmd && cmd == temp_cmd) {
 327                         list->list = g_slist_remove(list->list, temp_cmd);
 328                         /*
 329                         if (true == release_command) {
 330                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
 331                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 332                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 333                                 free(temp_cmd);
 334                                 temp_cmd = NULL;
 335                         }
 336                         */
 337                 }
 338
 339                 iter = g_slist_next(iter);
 340         }
 341
 342         int count = g_slist_length(list->list);
 343
 344         if (0 == count) {
 345                 list->index = -1;
 346         } else if (list->index == count) {
 347                 list->index = count - 1;
 348         }
 349
 350         return VC_ERROR_NONE;
 351 }
 352
 353 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
 354 {
 355         if (0 != __vc_cmd_get_feature_enabled()) {
 356                 return VC_ERROR_NOT_SUPPORTED;
 357         }
 358         if (0 != __vc_cmd_check_privilege()) {
 359                 return VC_ERROR_PERMISSION_DENIED;
 360         }
 361
 362         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Destroy all command");
 363
 364         if (NULL == vc_cmd_list) {
 365                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 366                 return VC_ERROR_INVALID_PARAMETER;
 367         }
 368
 369         vc_cmd_list_s* list = NULL;
 370         list = (vc_cmd_list_s*)vc_cmd_list;
 371
 372         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
 373                  , list, release_command ? "true" : "false");
 374
 375         int count = g_slist_length(list->list);
 376
 377         int i ;
 378         vc_cmd_s *temp_cmd;
 379
 380         for (i = 0; i < count ; i++) {
 381                 temp_cmd = g_slist_nth_data(list->list, 0);
 382
 383                 if (NULL != temp_cmd) {
 384                         list->list = g_slist_remove(list->list, temp_cmd);
 385
 386                         if (true == release_command) {
 387                                 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
 388                                 if (NULL != temp_cmd->command)          free(temp_cmd->command);
 389                                 if (NULL != temp_cmd->parameter)        free(temp_cmd->parameter);
 390                                 if (NULL != temp_cmd->appid)            free(temp_cmd->appid);
 391                                 if (NULL != temp_cmd->invocation_name)  free(temp_cmd->invocation_name);
 392                                 if (NULL != temp_cmd->fixed)            free(temp_cmd->fixed);
 393                                 free(temp_cmd);
 394                                 temp_cmd = NULL;
 395                         }
 396                 }
 397         }
 398         list->list = NULL;
 399         list->index = -1;
 400
 401         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
 402
 403         return VC_ERROR_NONE;
 404 }
 405
 406 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
 407 {
 408         if (0 != __vc_cmd_get_feature_enabled()) {
 409                 return VC_ERROR_NOT_SUPPORTED;
 410         }
 411         if (0 != __vc_cmd_check_privilege()) {
 412                 return VC_ERROR_PERMISSION_DENIED;
 413         }
 414
 415         if (NULL == vc_cmd_list) {
 416                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 417                 return VC_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         vc_cmd_list_s* list = NULL;
 421         list = (vc_cmd_list_s*)vc_cmd_list;
 422
 423         int count = g_slist_length(list->list);
 424         int i ;
 425
 426         GSList *iter = NULL;
 427         vc_cmd_s *temp_cmd;
 428
 429         iter = g_slist_nth(list->list, 0);
 430
 431         for (i = 0; i < count; i++) {
 432                 if (NULL == iter) {
 433                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
 434                         return VC_ERROR_OPERATION_FAILED;
 435                 }
 436
 437                 temp_cmd = iter->data;
 438
 439                 if (NULL != temp_cmd) {
 440                         if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
 441                                 break;
 442                         }
 443
 444                 }
 445                 iter = g_slist_next(iter);
 446         }
 447
 448         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Foreach commands Done");
 449
 450         return VC_ERROR_NONE;
 451 }
 452
 453 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
 454 {
 455         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Filter by type");
 456
 457         if (0 != __vc_cmd_get_feature_enabled()) {
 458                 return VC_ERROR_NOT_SUPPORTED;
 459         }
 460         if (0 != __vc_cmd_check_privilege()) {
 461                 return VC_ERROR_PERMISSION_DENIED;
 462         }
 463
 464         if (NULL == original) {
 465                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 466                 return VC_ERROR_INVALID_PARAMETER;
 467         }
 468
 469         if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
 470                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
 471                 return VC_ERROR_INVALID_PARAMETER;
 472         }
 473
 474         vc_cmd_list_s* list = NULL;
 475         list = (vc_cmd_list_s*)original;
 476
 477         vc_cmd_list_h temp_list;
 478         if (0 != vc_cmd_list_create(&temp_list)) {
 479                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
 480                 return VC_ERROR_OPERATION_FAILED;
 481         }
 482
 483         int count = g_slist_length(list->list);
 484         int i;
 485
 486         GSList *iter = NULL;
 487         vc_cmd_s *iter_cmd;
 488
 489         iter = g_slist_nth(list->list, 0);
 490
 491         for (i = 0; i < count; i++) {
 492                 if (NULL == iter) {
 493                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
 494                         return VC_ERROR_OPERATION_FAILED;
 495                 }
 496                 if (NULL != iter->data) {
 497                         iter_cmd = iter->data;
 498
 499                         if (NULL != iter_cmd) {
 500                                 int iter_type;
 501                                 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
 502                                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
 503                                         continue;
 504                                 }
 505
 506                                 if (iter_type == type) {
 507                                         vc_cmd_h temp_cmd;
 508                                         if (0 != vc_cmd_create(&temp_cmd)) {
 509                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
 510                                                 continue;
 511                                         }
 512
 513                                         memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
 514                                         if (NULL != iter_cmd->command) {
 515                                                 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
 516                                         }
 517                                         if (NULL != iter_cmd->parameter) {
 518                                                 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
 519                                         }
 520
 521                                         if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
 522                                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
 523                                                 vc_cmd_destroy(temp_cmd);
 524                                                 continue;
 525                                         }
 526                                 }
 527                         }
 528                 }
 529                 iter = g_slist_next(iter);
 530         }
 531
 532         count = 0;
 533         if (0 != vc_cmd_list_get_count(temp_list, &count)) {
 534                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
 535         } else {
 536                 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
 537         }
 538
 539         *filtered = temp_list;
 540
 541         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
 542
 543         return VC_ERROR_NONE;
 544 }
 545
 546 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
 547 {
 548         if (0 != __vc_cmd_get_feature_enabled()) {
 549                 return VC_ERROR_NOT_SUPPORTED;
 550         }
 551         if (0 != __vc_cmd_check_privilege()) {
 552                 return VC_ERROR_PERMISSION_DENIED;
 553         }
 554
 555         if (NULL == vc_cmd_list) {
 556                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 557                 return VC_ERROR_INVALID_PARAMETER;
 558         }
 559
 560         vc_cmd_list_s* list = NULL;
 561         list = (vc_cmd_list_s*)vc_cmd_list;
 562
 563         if (0 == g_slist_length(list->list)) {
 564                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 565                 return VC_ERROR_EMPTY;
 566         }
 567
 568         list->index = 0;
 569
 570         return VC_ERROR_NONE;
 571 }
 572
 573 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
 574 {
 575         if (0 != __vc_cmd_get_feature_enabled()) {
 576                 return VC_ERROR_NOT_SUPPORTED;
 577         }
 578         if (0 != __vc_cmd_check_privilege()) {
 579                 return VC_ERROR_PERMISSION_DENIED;
 580         }
 581
 582         if (NULL == vc_cmd_list) {
 583                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 584                 return VC_ERROR_INVALID_PARAMETER;
 585         }
 586
 587         vc_cmd_list_s* list = NULL;
 588         list = (vc_cmd_list_s*)vc_cmd_list;
 589
 590         int count = g_slist_length(list->list);
 591
 592         if (0 == count) {
 593                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
 594                 return VC_ERROR_EMPTY;
 595         } else {
 596                 list->index = count - 1;
 597                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 598         }
 599
 600         return VC_ERROR_NONE;
 601 }
 602
 603 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
 604 {
 605         if (0 != __vc_cmd_get_feature_enabled()) {
 606                 return VC_ERROR_NOT_SUPPORTED;
 607         }
 608         if (0 != __vc_cmd_check_privilege()) {
 609                 return VC_ERROR_PERMISSION_DENIED;
 610         }
 611
 612         if (NULL == vc_cmd_list) {
 613                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 614                 return VC_ERROR_INVALID_PARAMETER;
 615         }
 616
 617         vc_cmd_list_s* list = NULL;
 618         list = (vc_cmd_list_s*)vc_cmd_list;
 619
 620         int count = g_slist_length(list->list);
 621
 622         if (list->index < count - 1) {
 623                 list->index = list->index + 1;
 624                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 625         } else {
 626                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 627                 return VC_ERROR_ITERATION_END;
 628         }
 629
 630         return VC_ERROR_NONE;
 631 }
 632
 633 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
 634 {
 635         if (0 != __vc_cmd_get_feature_enabled()) {
 636                 return VC_ERROR_NOT_SUPPORTED;
 637         }
 638         if (0 != __vc_cmd_check_privilege()) {
 639                 return VC_ERROR_PERMISSION_DENIED;
 640         }
 641
 642         if (NULL == vc_cmd_list) {
 643                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 644                 return VC_ERROR_INVALID_PARAMETER;
 645         }
 646
 647         vc_cmd_list_s* list = NULL;
 648         list = (vc_cmd_list_s*)vc_cmd_list;
 649
 650         if (list->index > 0) {
 651                 list->index = list->index - 1;
 652                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 653         } else {
 654                 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
 655                 return VC_ERROR_ITERATION_END;
 656         }
 657
 658         return VC_ERROR_NONE;
 659 }
 660
 661 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
 662 {
 663         if (0 != __vc_cmd_get_feature_enabled()) {
 664                 return VC_ERROR_NOT_SUPPORTED;
 665         }
 666         if (0 != __vc_cmd_check_privilege()) {
 667                 return VC_ERROR_PERMISSION_DENIED;
 668         }
 669
 670         if (NULL == vc_cmd_list || NULL == vc_command) {
 671                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 672                 return VC_ERROR_INVALID_PARAMETER;
 673         }
 674
 675         vc_cmd_list_s* list = NULL;
 676         list = (vc_cmd_list_s*)vc_cmd_list;
 677
 678         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
 679
 680         if (0 == g_slist_length(list->list)) {
 681                 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
 682                 *vc_command = NULL;
 683                 return VC_ERROR_EMPTY;
 684         }
 685
 686         vc_cmd_s *temp_cmd = NULL;
 687         temp_cmd = g_slist_nth_data(list->list, list->index);
 688
 689         *vc_command = (vc_cmd_h)temp_cmd;
 690
 691         SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
 692
 693         return VC_ERROR_NONE;
 694 }
 695
 696
 697 int vc_cmd_create(vc_cmd_h* vc_command)
 698 {
 699         if (0 != __vc_cmd_get_feature_enabled()) {
 700                 return VC_ERROR_NOT_SUPPORTED;
 701         }
 702         if (0 != __vc_cmd_check_privilege()) {
 703                 return VC_ERROR_PERMISSION_DENIED;
 704         }
 705
 706         if (NULL == vc_command) {
 707                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 708                 return VC_ERROR_INVALID_PARAMETER;
 709         }
 710
 711         vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
 712
 713         if (NULL == command) {
 714                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
 715                 return VC_ERROR_OUT_OF_MEMORY;
 716         }
 717
 718         command->pid = 0;
 719         command->id = 0;
 720         command->index = 0;
 721         command->type = VC_COMMAND_TYPE_NONE;
 722         command->format = VC_CMD_FORMAT_FIXED;
 723         command->command = NULL;
 724         command->parameter = NULL;
 725         command->domain = 0;
 726         command->priority = 0;
 727         command->key = VC_KEY_NONE;
 728         command->modifier = VC_MODIFIER_NONE;
 729         command->invocation_name = NULL;
 730         command->appid = NULL;
 731         command->fixed = NULL;
 732         command->coordinates = NULL;
 733
 734         *vc_command = (vc_cmd_h)command;
 735
 736         SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
 737
 738         return VC_ERROR_NONE;
 739 }
 740
 741 int vc_cmd_destroy(vc_cmd_h vc_command)
 742 {
 743         if (0 != __vc_cmd_get_feature_enabled()) {
 744                 return VC_ERROR_NOT_SUPPORTED;
 745         }
 746         if (0 != __vc_cmd_check_privilege()) {
 747                 return VC_ERROR_PERMISSION_DENIED;
 748         }
 749
 750         if (NULL == vc_command) {
 751                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
 752                 return VC_ERROR_INVALID_PARAMETER;
 753         }
 754
 755         vc_cmd_s* command = NULL;
 756         command = (vc_cmd_s*)vc_command;
 757
 758         SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
 759
 760         if (NULL != command) {
 761                 if (NULL != command->command) {
 762                         free(command->command);
 763                         command->command = NULL;
 764                 }
 765                 if (NULL != command->parameter) {
 766                         free(command->parameter);
 767                         command->parameter = NULL;
 768                 }
 769                 if (NULL != command->invocation_name) {
 770                         free(command->invocation_name);
 771                         command->invocation_name = NULL;
 772                 }
 773                 if (NULL != command->appid) {
 774                         free(command->appid);
 775                         command->appid = NULL;
 776                 }
 777                 if (NULL != command->fixed) {
 778                         free(command->fixed);
 779                         command->fixed = NULL;
 780                 }
 781                 if (NULL != command->coordinates) {
 782                         free(command->coordinates);
 783                         command->coordinates = NULL;
 784                 }
 785                 free(command);
 786                 command = NULL;
 787         }
 788
 789         return VC_ERROR_NONE;
 790 }
 791
 792 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
 793 {
 794         if (0 != __vc_cmd_get_feature_enabled()) {
 795                 return VC_ERROR_NOT_SUPPORTED;
 796         }
 797         if (0 != __vc_cmd_check_privilege()) {
 798                 return VC_ERROR_PERMISSION_DENIED;
 799         }
 800
 801         if (NULL == vc_command) {
 802                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 803                 return VC_ERROR_INVALID_PARAMETER;
 804         }
 805
 806         vc_cmd_s* cmd = NULL;
 807         cmd = (vc_cmd_s*)vc_command;
 808
 809         if (NULL != cmd) {
 810                 cmd->id = id;
 811                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
 812         }
 813
 814         return 0;
 815 }
 816
 817 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
 818 {
 819         if (0 != __vc_cmd_get_feature_enabled()) {
 820                 return VC_ERROR_NOT_SUPPORTED;
 821         }
 822         if (0 != __vc_cmd_check_privilege()) {
 823                 return VC_ERROR_PERMISSION_DENIED;
 824         }
 825
 826         if (NULL == vc_command || NULL == id) {
 827                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 828                 return VC_ERROR_INVALID_PARAMETER;
 829         }
 830
 831         vc_cmd_s* cmd = NULL;
 832         cmd = (vc_cmd_s*)vc_command;
 833
 834         if (NULL != cmd) {
 835                 *id = cmd->id;
 836                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
 837         }
 838
 839         return 0;
 840 }
 841
 842 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
 843 {
 844         if (0 != __vc_cmd_get_feature_enabled()) {
 845                 return VC_ERROR_NOT_SUPPORTED;
 846         }
 847
 848         if (NULL == vc_command) {
 849                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
 850                 return VC_ERROR_INVALID_PARAMETER;
 851         }
 852
 853         if (NULL == appid) {
 854                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
 855                 return VC_ERROR_INVALID_PARAMETER;
 856         }
 857
 858         vc_cmd_s* cmd = NULL;
 859         cmd = (vc_cmd_s*)vc_command;
 860
 861         if (NULL != cmd->appid) {
 862                 free(cmd->appid);
 863                 cmd->appid = NULL;
 864         }
 865
 866         cmd->appid = strdup(appid);
 867
 868         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
 869         return 0;
 870 }
 871
 872 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
 873 {
 874         if (0 != __vc_cmd_get_feature_enabled()) {
 875                 return VC_ERROR_NOT_SUPPORTED;
 876         }
 877
 878         if (NULL == vc_command || NULL == appid) {
 879                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 880                 return VC_ERROR_INVALID_PARAMETER;
 881         }
 882
 883         vc_cmd_s* cmd = NULL;
 884         cmd = (vc_cmd_s*)vc_command;
 885
 886         if (NULL != cmd->appid) {
 887                 *appid = strdup(gettext(cmd->appid));
 888         }
 889
 890         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
 891         return 0;
 892 }
 893
 894 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
 895 {
 896         if (0 != __vc_cmd_get_feature_enabled()) {
 897                 return VC_ERROR_NOT_SUPPORTED;
 898         }
 899         if (0 != __vc_cmd_check_privilege()) {
 900                 return VC_ERROR_PERMISSION_DENIED;
 901         }
 902
 903         if (NULL == vc_command) {
 904                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 905                 return VC_ERROR_INVALID_PARAMETER;
 906         }
 907
 908         vc_cmd_s* cmd = NULL;
 909         cmd = (vc_cmd_s*)vc_command;
 910
 911         if (NULL != cmd->command) {
 912                 free(cmd->command);
 913         }
 914
 915         cmd->command = NULL;
 916
 917         if (NULL != command) {
 918                 cmd->command = strdup(command);
 919         }
 920
 921         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
 922
 923         return 0;
 924 }
 925
 926 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
 927 {
 928         if (0 != __vc_cmd_get_feature_enabled()) {
 929                 return VC_ERROR_NOT_SUPPORTED;
 930         }
 931         if (0 != __vc_cmd_check_privilege()) {
 932                 return VC_ERROR_PERMISSION_DENIED;
 933         }
 934
 935         if (NULL == vc_command || NULL == command) {
 936                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 937                 return VC_ERROR_INVALID_PARAMETER;
 938         }
 939
 940         vc_cmd_s* cmd = NULL;
 941         cmd = (vc_cmd_s*)vc_command;
 942
 943         if (NULL != cmd->command) {
 944                 *command = strdup(gettext(cmd->command));
 945         }
 946
 947         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
 948
 949         return 0;
 950 }
 951
 952 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
 953 {
 954         if (0 != __vc_cmd_get_feature_enabled()) {
 955                 return VC_ERROR_NOT_SUPPORTED;
 956         }
 957         if (0 != __vc_cmd_check_privilege()) {
 958                 return VC_ERROR_PERMISSION_DENIED;
 959         }
 960
 961         if (NULL == vc_command) {
 962                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
 963                 return VC_ERROR_INVALID_PARAMETER;
 964         }
 965
 966         vc_cmd_s* cmd = NULL;
 967         cmd = (vc_cmd_s*)vc_command;
 968
 969         if (NULL != cmd->parameter) {
 970                 free(cmd->parameter);
 971         }
 972
 973         cmd->parameter = NULL;
 974
 975         if (NULL != command) {
 976                 cmd->parameter = strdup(command);
 977                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
 978         }
 979
 980         return 0;
 981 }
 982
 983 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
 984 {
 985         if (0 != __vc_cmd_get_feature_enabled()) {
 986                 return VC_ERROR_NOT_SUPPORTED;
 987         }
 988
 989         if (NULL == vc_command || NULL == command) {
 990                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
 991                 return VC_ERROR_INVALID_PARAMETER;
 992         }
 993
 994         vc_cmd_s* cmd = NULL;
 995         cmd = (vc_cmd_s*)vc_command;
 996
 997         if (NULL != cmd->parameter) {
 998                 *command = strdup(gettext(cmd->parameter));
 999                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
1000         }
1001
1002         return 0;
1003 }
1004
1005 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
1006 {
1007         if (0 != __vc_cmd_get_feature_enabled()) {
1008                 return VC_ERROR_NOT_SUPPORTED;
1009         }
1010
1011         if (NULL == vc_command) {
1012                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1013                 return VC_ERROR_INVALID_PARAMETER;
1014         }
1015
1016         if (NULL == fixed) {
1017                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
1018                 return VC_ERROR_INVALID_PARAMETER;
1019         }
1020
1021         vc_cmd_s* cmd = NULL;
1022         cmd = (vc_cmd_s*)vc_command;
1023
1024         if (NULL != cmd->fixed) {
1025                 free(cmd->fixed);
1026                 cmd->fixed = NULL;
1027         }
1028
1029         cmd->fixed = strdup(fixed);
1030
1031         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
1032         return 0;
1033 }
1034
1035 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
1036 {
1037         if (0 != __vc_cmd_get_feature_enabled()) {
1038                 return VC_ERROR_NOT_SUPPORTED;
1039         }
1040
1041         if (NULL == vc_command || NULL == fixed) {
1042                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1043                 return VC_ERROR_INVALID_PARAMETER;
1044         }
1045
1046         vc_cmd_s* cmd = NULL;
1047         cmd = (vc_cmd_s*)vc_command;
1048
1049         if (NULL != cmd->fixed) {
1050                 *fixed = strdup(gettext(cmd->fixed));
1051                 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1052         }
1053
1054         return 0;
1055 }
1056
1057 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1058 {
1059         if (0 != __vc_cmd_get_feature_enabled()) {
1060                 return VC_ERROR_NOT_SUPPORTED;
1061         }
1062
1063         if (NULL == vc_command) {
1064                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1065                 return VC_ERROR_INVALID_PARAMETER;
1066         }
1067
1068         if (NULL == invocation_name) {
1069                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1070                 return VC_ERROR_INVALID_PARAMETER;
1071         }
1072
1073         vc_cmd_s* cmd = NULL;
1074         cmd = (vc_cmd_s*)vc_command;
1075
1076         if (NULL != cmd->invocation_name) {
1077                 free(cmd->invocation_name);
1078                 cmd->invocation_name = NULL;
1079         }
1080
1081         cmd->invocation_name = strdup(invocation_name);
1082
1083         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1084         return 0;
1085 }
1086
1087 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1088 {
1089         if (0 != __vc_cmd_get_feature_enabled()) {
1090                 return VC_ERROR_NOT_SUPPORTED;
1091         }
1092
1093         if (NULL == vc_command || NULL == invocation_name) {
1094                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1095                 return VC_ERROR_INVALID_PARAMETER;
1096         }
1097
1098         vc_cmd_s* cmd = NULL;
1099         cmd = (vc_cmd_s*)vc_command;
1100
1101         if (NULL != cmd->invocation_name) {
1102                 *invocation_name = strdup(gettext(cmd->invocation_name));
1103         }
1104
1105         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1106         return 0;
1107 }
1108
1109 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1110 {
1111         if (0 != __vc_cmd_get_feature_enabled()) {
1112                 return VC_ERROR_NOT_SUPPORTED;
1113         }
1114         if (0 != __vc_cmd_check_privilege()) {
1115                 return VC_ERROR_PERMISSION_DENIED;
1116         }
1117
1118         if (NULL == vc_command) {
1119                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1120                 return VC_ERROR_INVALID_PARAMETER;
1121         }
1122
1123         vc_cmd_s* cmd = NULL;
1124         cmd = (vc_cmd_s*)vc_command;
1125
1126         cmd->type = type;
1127
1128         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1129
1130         return 0;
1131 }
1132
1133 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1134 {
1135         if (0 != __vc_cmd_get_feature_enabled()) {
1136                 return VC_ERROR_NOT_SUPPORTED;
1137         }
1138         if (0 != __vc_cmd_check_privilege()) {
1139                 return VC_ERROR_PERMISSION_DENIED;
1140         }
1141
1142         if (NULL == vc_command || NULL == type) {
1143                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1144                 return VC_ERROR_INVALID_PARAMETER;
1145         }
1146
1147         vc_cmd_s* cmd = NULL;
1148         cmd = (vc_cmd_s*)vc_command;
1149
1150         *type = cmd->type;
1151
1152         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1153
1154         return 0;
1155 }
1156
1157 int vc_cmd_set_format(vc_cmd_h vc_command, int format)
1158 {
1159         if (0 != __vc_cmd_get_feature_enabled()) {
1160                 return VC_ERROR_NOT_SUPPORTED;
1161         }
1162
1163         if (NULL == vc_command) {
1164                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1165                 return VC_ERROR_INVALID_PARAMETER;
1166         }
1167
1168         vc_cmd_s* cmd = NULL;
1169         cmd = (vc_cmd_s*)vc_command;
1170
1171         cmd->format = format;
1172
1173         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1174
1175         return 0;
1176 }
1177
1178 int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
1179 {
1180         if (0 != __vc_cmd_get_feature_enabled()) {
1181                 return VC_ERROR_NOT_SUPPORTED;
1182         }
1183
1184         if (NULL == vc_command || NULL == format) {
1185                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1186                 return VC_ERROR_INVALID_PARAMETER;
1187         }
1188
1189         vc_cmd_s* cmd = NULL;
1190         cmd = (vc_cmd_s*)vc_command;
1191
1192         *format = cmd->format;
1193
1194         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1195
1196         return 0;
1197 }
1198
1199 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1200 {
1201         if (0 != __vc_cmd_get_feature_enabled()) {
1202                 return VC_ERROR_NOT_SUPPORTED;
1203         }
1204         if (0 != __vc_cmd_check_privilege()) {
1205                 return VC_ERROR_PERMISSION_DENIED;
1206         }
1207
1208         if (NULL == vc_command) {
1209                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1210                 return VC_ERROR_INVALID_PARAMETER;
1211         }
1212
1213         vc_cmd_s* cmd = NULL;
1214         cmd = (vc_cmd_s*)vc_command;
1215
1216         cmd->pid = pid;
1217
1218         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1219
1220         return 0;
1221 }
1222
1223 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1224 {
1225         if (0 != __vc_cmd_get_feature_enabled()) {
1226                 return VC_ERROR_NOT_SUPPORTED;
1227         }
1228         if (0 != __vc_cmd_check_privilege()) {
1229                 return VC_ERROR_PERMISSION_DENIED;
1230         }
1231
1232         if (NULL == vc_command || NULL == pid) {
1233                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1234                 return VC_ERROR_INVALID_PARAMETER;
1235         }
1236
1237         vc_cmd_s* cmd = NULL;
1238         cmd = (vc_cmd_s*)vc_command;
1239
1240         *pid = cmd->pid;
1241
1242         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1243
1244         return 0;
1245 }
1246
1247 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1248 {
1249         if (0 != __vc_cmd_get_feature_enabled()) {
1250                 return VC_ERROR_NOT_SUPPORTED;
1251         }
1252         if (0 != __vc_cmd_check_privilege()) {
1253                 return VC_ERROR_PERMISSION_DENIED;
1254         }
1255
1256         if (NULL == vc_command) {
1257                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1258                 return VC_ERROR_INVALID_PARAMETER;
1259         }
1260
1261         vc_cmd_s* cmd = NULL;
1262         cmd = (vc_cmd_s*)vc_command;
1263
1264         cmd->domain = domain;
1265
1266         SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1267
1268         return 0;
1269 }
1270
1271 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1272 {
1273         if (0 != __vc_cmd_get_feature_enabled()) {
1274                 return VC_ERROR_NOT_SUPPORTED;
1275         }
1276         if (0 != __vc_cmd_check_privilege()) {
1277                 return VC_ERROR_PERMISSION_DENIED;
1278         }
1279
1280         if (NULL == vc_command || NULL == domain) {
1281                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1282                 return VC_ERROR_INVALID_PARAMETER;
1283         }
1284
1285         vc_cmd_s* cmd = NULL;
1286         cmd = (vc_cmd_s*)vc_command;
1287
1288         *domain = cmd->domain;
1289
1290         SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1291
1292         return 0;
1293 }
1294
1295 /**
1296 * @brief Sets key value of command.
1297 *
1298 * @param[in] vc_command Command handle
1299 * @param[in] key key value
1300 * @param[in] modifier modifier value
1301 *
1302 * @return 0 on success, otherwise a negative error value
1303 * @retval #VC_ERROR_NONE Successful
1304 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1305 *
1306 * @see vc_cmd_get_result_key()
1307 */
1308 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1309 {
1310         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Set result key");
1311
1312         if (NULL == vc_command) {
1313                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1314                 return VC_ERROR_INVALID_PARAMETER;
1315         }
1316
1317         vc_cmd_s* cmd = NULL;
1318         cmd = (vc_cmd_s*)vc_command;
1319
1320         SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1321
1322         cmd->key = key;
1323         cmd->modifier = modifier;
1324
1325         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1326
1327         return 0;
1328 }
1329
1330 /**
1331 * @brief Gets key value of command.
1332 *
1333 * @param[in] vc_command Command handle
1334 * @param[out] key key value
1335 * @param[out] modifier modifier value
1336 *
1337 * @return 0 on success, otherwise a negative error value
1338 * @retval #VC_ERROR_NONE Successful
1339 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1340 *
1341 * @see vc_cmd_add_result_key()
1342 */
1343 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1344 {
1345         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get result key");
1346
1347         if (NULL == vc_command || NULL == key || NULL == modifier) {
1348                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1349                 return VC_ERROR_INVALID_PARAMETER;
1350         }
1351
1352         vc_cmd_s* cmd = NULL;
1353         cmd = (vc_cmd_s*)vc_command;
1354
1355         *key = cmd->key;
1356         *modifier = cmd->modifier;
1357
1358         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1359
1360         return 0;
1361 }
1362
1363 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1364 {
1365         if (NULL == vc_cmd_list) {
1366                 return -1;
1367         }
1368
1369         vc_cmd_list_s* list = NULL;
1370         list = (vc_cmd_list_s*)vc_cmd_list;
1371
1372         SLOG(LOG_DEBUG, TAG_VCCMD, "@ Command List @");
1373         SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1374
1375         int count = g_slist_length(list->list);
1376
1377         int i;
1378         vc_cmd_s *cmd = NULL;
1379
1380         for (i = 0; i < count ; i++) {
1381                 cmd = g_slist_nth_data(list->list, i);
1382
1383                 if (NULL != cmd) {
1384                         SLOG(LOG_DEBUG, TAG_VCCMD, "  [%d][%p] PID(%d) ID(%d) Type(%d) Format(%d) Command(%s) Param(%s) Appid(%s) Invocation(%s) Fixed(%s)",
1385                          i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1386                 }
1387         }
1388
1389         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1390
1391         return 0;
1392 }
1393
1394 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1395 {
1396         if (0 != __vc_cmd_get_feature_enabled()) {
1397                 return VC_ERROR_NOT_SUPPORTED;
1398         }
1399
1400         if (NULL == vc_cmd || NULL == json) {
1401                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1402                 return VC_ERROR_INVALID_PARAMETER;
1403         }
1404
1405         vc_cmd_s* cmd = NULL;
1406         cmd = (vc_cmd_s*)vc_cmd;
1407
1408         if (VC_CMD_FORMAT_ACTION != cmd->format) {
1409                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1410                 return VC_ERROR_INVALID_PARAMETER;
1411         }
1412
1413         if (0 != vc_info_parser_get_nlu_result(json)) {
1414                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1415                 return VC_ERROR_OPERATION_FAILED;
1416         }
1417
1418         return 0;
1419 }
1420
1421 static void __vc_cmd_regex_deinit(int num_regex)
1422 {
1423         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start Deinitialize regex @@@");
1424         int i;
1425
1426         for (i = 0; num_regex > i; i++) {
1427                 regfree(&reg[i]);
1428         }
1429
1430         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1431 }
1432
1433 static int __vc_cmd_regex_init()
1434 {
1435         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Initialize regular expression @@@");
1436
1437         int cflags = REG_EXTENDED | REG_ICASE;
1438         int ret;
1439         char errStr[128];
1440         char *lang = NULL;
1441         int lang_type = 1;
1442
1443         vc_config_mgr_get_default_language(&lang);
1444         if (NULL == lang) {
1445                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1446                 return VC_ERROR_OPERATION_FAILED;
1447         }
1448
1449         if (!strcmp("en_US", lang)) {
1450                 lang_type = 1;
1451         } else if (!strcmp("ko_KR", lang)) {
1452                 lang_type = 0;
1453         } else {
1454                 free(lang);
1455                 lang = NULL;
1456
1457                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1458                 return VC_ERROR_INVALID_LANGUAGE;
1459         }
1460
1461         free(lang);
1462         lang = NULL;
1463
1464         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ lang type > %d @@@", lang_type);
1465
1466         re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1467
1468         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1469         ret = regcomp(&reg[0], TIME_ABS1_REGEX[lang_type], cflags);
1470         if (0 != ret) {
1471                 regerror(ret, &reg[0], errStr, sizeof(errStr));
1472
1473                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1474                 return VC_ERROR_OPERATION_FAILED;
1475         }
1476
1477         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1478         ret = regcomp(&reg[1], TIME_ABS2_REGEX[lang_type], cflags);
1479         if (0 != ret) {
1480                 regerror(ret, &reg[1], errStr, sizeof(errStr));
1481                 __vc_cmd_regex_deinit(1);
1482
1483                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1484                 return VC_ERROR_OPERATION_FAILED;
1485         }
1486
1487         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1488         ret = regcomp(&reg[2], TIME_ABS3_REGEX[lang_type], cflags);
1489         if (0 != ret) {
1490                 regerror(ret, &reg[2], errStr, sizeof(errStr));
1491                 __vc_cmd_regex_deinit(2);
1492
1493                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1494                 return VC_ERROR_OPERATION_FAILED;
1495         }
1496
1497         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1498         ret = regcomp(&reg[3], TIME_REL1_REGEX[lang_type], cflags);
1499         if (0 != ret) {
1500                 regerror(ret, &reg[3], errStr, sizeof(errStr));
1501                 __vc_cmd_regex_deinit(3);
1502
1503                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1504                 return VC_ERROR_OPERATION_FAILED;
1505         }
1506
1507         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1508         ret = regcomp(&reg[4], TIME_REL2_REGEX[lang_type], cflags);
1509         if (0 != ret) {
1510                 regerror(ret, &reg[4], errStr, sizeof(errStr));
1511                 __vc_cmd_regex_deinit(4);
1512
1513                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1514                 return VC_ERROR_OPERATION_FAILED;
1515         }
1516
1517         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1518         ret = regcomp(&reg[5], TIME_REL3_REGEX[lang_type], cflags);
1519         if (0 != ret) {
1520                 regerror(ret, &reg[5], errStr, sizeof(errStr));
1521                 __vc_cmd_regex_deinit(5);
1522
1523                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1524                 return VC_ERROR_OPERATION_FAILED;
1525         }
1526
1527         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1528         ret = regcomp(&reg[6], TIME_PHR_REGEX[lang_type], cflags);
1529         if (0 != ret) {
1530                 regerror(ret, &reg[6], errStr, sizeof(errStr));
1531                 __vc_cmd_regex_deinit(6);
1532
1533                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1534                 return VC_ERROR_OPERATION_FAILED;
1535         }
1536
1537         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1538         ret = regcomp(&reg[7], DATE_ABS1_REGEX[lang_type], cflags);
1539         if (0 != ret) {
1540                 regerror(ret, &reg[7], errStr, sizeof(errStr));
1541                 __vc_cmd_regex_deinit(7);
1542
1543                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1544                 return VC_ERROR_OPERATION_FAILED;
1545         }
1546
1547         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1548         ret = regcomp(&reg[8], DATE_ABS2_REGEX[lang_type], cflags);
1549         if (0 != ret) {
1550                 regerror(ret, &reg[8], errStr, sizeof(errStr));
1551                 __vc_cmd_regex_deinit(8);
1552
1553                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1554                 return VC_ERROR_OPERATION_FAILED;
1555         }
1556
1557         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1558         ret = regcomp(&reg[9], DATE_ABS3_REGEX[lang_type], cflags);
1559         if (0 != ret) {
1560                 regerror(ret, &reg[9], errStr, sizeof(errStr));
1561                 __vc_cmd_regex_deinit(9);
1562
1563                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1564                 return VC_ERROR_OPERATION_FAILED;
1565         }
1566
1567         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1568         ret = regcomp(&reg[10], DATE_PHR1_REGEX[lang_type], cflags);
1569         if (0 != ret) {
1570                 regerror(ret, &reg[10], errStr, sizeof(errStr));
1571                 __vc_cmd_regex_deinit(10);
1572
1573                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1574                 return VC_ERROR_OPERATION_FAILED;
1575         }
1576
1577         SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1578         ret = regcomp(&reg[11], DATE_PHR2_REGEX[lang_type], cflags);
1579         if (0 != ret) {
1580                 regerror(ret, &reg[11], errStr, sizeof(errStr));
1581                 __vc_cmd_regex_deinit(11);
1582
1583                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1584                 return VC_ERROR_OPERATION_FAILED;
1585         }
1586
1587         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1588
1589         return VC_ERROR_NONE;
1590 }
1591
1592 static void __vc_cmd_add_year(struct tm *td, int year)
1593 {
1594         td->tm_year += year;
1595 }
1596
1597 static void __vc_cmd_add_mon(struct tm *td, int mon)
1598 {
1599         int year = 0;
1600
1601         mon = td->tm_mon + mon;
1602         year = mon / 12;
1603
1604         if (0 < year) {
1605                 __vc_cmd_add_year(td, year);
1606         }
1607
1608         td->tm_mon = mon % 12;
1609 }
1610
1611 static void __vc_cmd_add_mday(struct tm *td, int mday)
1612 {
1613         int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1614         int year = td->tm_year + 1900;
1615
1616         int mon = 0;
1617
1618         if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1619
1620         mday = td->tm_mday + mday;
1621
1622         for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1623                 mday -= max_day[mon % 12];
1624
1625                 if (11 == mon % 12) {
1626                         year++;
1627
1628                         if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1629                                 max_day[1] = 29;
1630                         } else {
1631                                 max_day[1] = 28;
1632                         }
1633                 }
1634         }
1635
1636         mon = mon - td->tm_mon;
1637
1638         if (0 < mon) {
1639                 __vc_cmd_add_mon(td, mon);
1640         }
1641
1642         td->tm_mday = mday;
1643 }
1644
1645 static void __vc_cmd_add_hour(struct tm *td, int hour)
1646 {
1647         int day = 0;
1648
1649         hour = td->tm_hour + hour;
1650         day = hour / 24;
1651
1652         if (0 < day) {
1653                 __vc_cmd_add_mday(td, day);
1654         }
1655
1656         td->tm_hour = hour % 24;
1657 }
1658
1659 static void __vc_cmd_add_min(struct tm *td, int min)
1660 {
1661         int hour = 0;
1662
1663         min = td->tm_min + min;
1664         hour = min / 60;
1665
1666         if (0 < hour) {
1667                 __vc_cmd_add_hour(td, hour);
1668         }
1669
1670         td->tm_min = min % 60;
1671 }
1672
1673 static void __copy_struct_tm(struct tm *des, struct tm *src)
1674 {
1675         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start to copy struct tm @@@");
1676
1677         des->tm_sec     = src->tm_sec;
1678         des->tm_min     = src->tm_min;
1679         des->tm_hour    = src->tm_hour;
1680         des->tm_mday    = src->tm_mday;
1681         des->tm_mon     = src->tm_mon;
1682         des->tm_year    = src->tm_year;
1683         des->tm_wday    = src->tm_wday;
1684         des->tm_yday    = src->tm_yday;
1685         des->tm_isdst   = src->tm_isdst;
1686
1687         des->tm_gmtoff  = src->tm_gmtoff;
1688         des->tm_zone    = src->tm_zone;
1689 }
1690
1691 static void __update_data_sidx(int idx)
1692 {
1693         if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1694 }
1695
1696 static void __update_data_eidx(int idx)
1697 {
1698         if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1699 }
1700
1701 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1702 {
1703         regmatch_t pmatch[3];
1704         int ret;
1705         int len;
1706         int idx;
1707
1708         *exist = 0;
1709         ret = regexec(&reg[6], str, 3, pmatch, 0);
1710         if (0 == ret) {
1711                 idx = 1;
1712                 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1713                 if (0 < len) {
1714                         if (12 < td->tm_hour) {
1715                                 __vc_cmd_add_mday(td, 1);
1716                         }
1717
1718                         td->tm_hour = 12;
1719                 } else {
1720                         idx = 2;
1721                         len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1722
1723                         __vc_cmd_add_mday(td, 1);
1724                 }
1725
1726                 td->tm_min = 0;
1727                 td->tm_sec = 0;
1728                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1729
1730                 __update_data_sidx(pmatch[0].rm_so);
1731                 __update_data_eidx(pmatch[0].rm_eo);
1732
1733                 *exist = 1;
1734                 return VC_ERROR_NONE;
1735         }
1736
1737         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1738         return VC_ERROR_NONE;
1739 }
1740
1741 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1742 {
1743         regmatch_t pmatch[2];
1744         int ret;
1745         int len;
1746         int sidx = -1;
1747         int eidx = -1;
1748         int hour = -1;
1749         int min = -1;
1750
1751         char *tempstr = NULL;
1752
1753         *exist = 0;
1754         ret = regexec(&reg[3], str, 1, pmatch, 0);
1755         if (0 == ret) {
1756                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1757                 hour = min = -1;
1758
1759                 sidx = pmatch[0].rm_so;
1760                 eidx = pmatch[0].rm_eo;
1761
1762                 ret = regexec(&reg[4], str, 2, pmatch, 0);
1763                 if (0 == ret) {
1764                         len = pmatch[1].rm_eo - pmatch[1].rm_so;
1765
1766                         if (0 > len) {
1767                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1768                                 return VC_ERROR_OPERATION_FAILED;
1769                         }
1770                         tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1771
1772                         if (NULL == tempstr) {
1773                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1774                                 return VC_ERROR_OUT_OF_MEMORY;
1775                         }
1776
1777                         hour = atoi(tempstr);
1778
1779                         free(tempstr);
1780                         tempstr = NULL;
1781
1782                         SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1783
1784                         if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1785                         if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1786                 }
1787
1788                 ret = regexec(&reg[5], str, 2, pmatch, 0);
1789                 if (0 == ret) {
1790                         len = pmatch[1].rm_eo - pmatch[1].rm_so;
1791
1792                         if (0 > len) {
1793                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1794                                 return VC_ERROR_OPERATION_FAILED;
1795                         }
1796                         tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1797
1798                         if (NULL == tempstr) {
1799                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1800                                 return VC_ERROR_OUT_OF_MEMORY;
1801                         }
1802
1803                         min = atoi(tempstr);
1804
1805                         free(tempstr);
1806                         tempstr = NULL;
1807
1808                         SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1809
1810                         if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1811                         if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1812                 }
1813
1814                 if (hour < 0 && min < 0) {
1815                         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1816                         return VC_ERROR_NONE;
1817                 }
1818
1819                 hour = 0 > hour ? 0 : hour;
1820                 min = 0 > min ? 0 : min;
1821
1822                 min = min + (hour * 60);
1823
1824                 __vc_cmd_add_min(td, min);
1825                 td->tm_sec = 0;
1826
1827                 __update_data_sidx(sidx);
1828                 __update_data_eidx(eidx);
1829
1830                 *exist = 1;
1831                 return VC_ERROR_NONE;
1832         }
1833
1834         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1835         return VC_ERROR_NONE;
1836 }
1837
1838 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1839 {
1840         regmatch_t pmatch[5];
1841         int ret;
1842         int len;
1843         int idx;
1844         int flag = -1;
1845         int hour = -1;
1846         int min = -1;
1847         int sidx = -1;
1848         int eidx = -1;
1849         char *tempstr = NULL;
1850
1851         *exist = 0;
1852         ret = regexec(&reg[0], str, 5, pmatch, 0);
1853         if (0 == ret) {
1854                 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1855
1856                 flag = idx & 1;
1857
1858                 sidx = pmatch[0].rm_so;
1859                 eidx = pmatch[0].rm_eo;
1860         }
1861
1862         ret = regexec(&reg[1], str, 2, pmatch, 0);
1863         if (0 == ret) {
1864                 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1865
1866                 if (0 > len) {
1867                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1868                         return VC_ERROR_OPERATION_FAILED;
1869                 }
1870                 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1871
1872                 if (NULL == tempstr) {
1873                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1874                         return VC_ERROR_OUT_OF_MEMORY;
1875                 }
1876
1877                 hour = atoi(tempstr);
1878
1879                 if (0 <= flag) {
1880                         hour = hour + 12 * flag;
1881
1882                         if (12 == hour) hour = 0;
1883                         else if (24 == hour) hour = 12;
1884                 }
1885
1886                 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1887                         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1888                         return VC_ERROR_NONE;
1889                 }
1890
1891                 free(tempstr);
1892                 tempstr = NULL;
1893
1894                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1895
1896                 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1897                 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1898         } else if (0 < flag) {
1899                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1900                 return VC_ERROR_NONE;
1901         }
1902
1903         ret = regexec(&reg[2], str, 2, pmatch, 0);
1904         if (0 == ret) {
1905                 idx = 1;
1906                 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1907                 if (0 < len) {
1908                         tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
1909
1910                         if (NULL == tempstr) {
1911                                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1912                                 return VC_ERROR_OUT_OF_MEMORY;
1913                         }
1914
1915                         min = atoi(tempstr);
1916
1917                         if (0 > min || 60 <= min) {
1918                                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1919                                 return VC_ERROR_NONE;
1920                         }
1921
1922                         td->tm_sec = 0;
1923
1924                         free(tempstr);
1925                         tempstr = NULL;
1926                 } else {
1927                         idx = 0;
1928                         min = 30;
1929                 }
1930
1931                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1932                 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1933                 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1934         }
1935
1936         if (0 > hour && 0 > min) {
1937                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1938                 return VC_ERROR_NONE;
1939         }
1940
1941         if (0 <= min && 0 <= hour) {
1942                 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1943
1944                 td->tm_hour = hour;
1945                 td->tm_min = min;
1946         } else if (0 <= min) {
1947                 char *lang = NULL;
1948                 vc_config_mgr_get_default_language(&lang);
1949                 if (NULL == lang) {
1950                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1951                         return VC_ERROR_OPERATION_FAILED;
1952                 }
1953
1954                 if (!strcmp("en_US", lang)) {
1955                         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1956                         free(lang);
1957                         lang = NULL;
1958                         return VC_ERROR_NONE;
1959                 }
1960                 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1961
1962                 td->tm_min = min;
1963
1964                 free(lang);
1965                 lang = NULL;
1966         } else {
1967                 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1968
1969                 td->tm_hour = hour;
1970                 td->tm_min = 0;
1971         }
1972
1973         td->tm_sec = 0;
1974
1975         __update_data_sidx(sidx);
1976         __update_data_eidx(eidx);
1977
1978         *exist = 1;
1979         return VC_ERROR_NONE;
1980 }
1981
1982 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
1983 {
1984         regmatch_t pmatch[10];
1985         int ret;
1986         int len;
1987         int idx;
1988
1989         *exist = 0;
1990         ret = regexec(&reg[10], str, 5, pmatch, 0);
1991         if (0 == ret) {
1992                 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1993
1994                 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1995
1996                 td->tm_year = td_now.tm_year;
1997                 td->tm_mon = td_now.tm_mon;
1998                 td->tm_mday = td_now.tm_mday;
1999
2000                 __vc_cmd_add_mday(td, idx - 1);
2001
2002                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2003
2004                 __update_data_sidx(pmatch[0].rm_so);
2005                 __update_data_eidx(pmatch[0].rm_eo);
2006
2007                 *exist = 1;
2008                 return VC_ERROR_NONE;
2009         }
2010
2011         ret = regexec(&reg[11], str, 10, pmatch, 0);
2012         if (0 == ret) {
2013                 for (idx = 1; 10 > idx; idx++) {
2014                         len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2015
2016                         if (0 < len) break;
2017                 }
2018
2019                 td->tm_year = td_now.tm_year;
2020                 td->tm_mon = td_now.tm_mon;
2021                 td->tm_mday = td_now.tm_mday;
2022
2023                 __vc_cmd_add_mday(td, idx + 1);
2024
2025                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2026
2027                 __update_data_sidx(pmatch[0].rm_so);
2028                 __update_data_eidx(pmatch[0].rm_eo);
2029
2030                 *exist = 1;
2031                 return VC_ERROR_NONE;
2032         }
2033
2034         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
2035         return VC_ERROR_NONE;
2036 }
2037
2038 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
2039 {
2040         regmatch_t pmatch[13];
2041         int ret;
2042         int len;
2043         int idx;
2044         int sidx = -1;
2045         int eidx = -1;
2046         int y_flag = 0;
2047         int m_flag = 0;
2048         int year = 0;
2049         int mon = 0;
2050         int day = 0;
2051         char *tempstr = NULL;
2052
2053         *exist = 0;
2054         ret = regexec(&reg[9], str, 2, pmatch, 0);
2055         if (0 == ret) {
2056                 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2057
2058                 if (0 > len) {
2059                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2060                         return VC_ERROR_OPERATION_FAILED;
2061                 }
2062                 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
2063
2064                 if (NULL == tempstr) {
2065                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2066                         return VC_ERROR_OUT_OF_MEMORY;
2067                 }
2068
2069                 day = atoi(tempstr);
2070
2071                 free(tempstr);
2072                 tempstr = NULL;
2073
2074                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2075
2076                 sidx = pmatch[0].rm_so;
2077                 eidx = pmatch[0].rm_eo;
2078         } else {
2079                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2080                 return VC_ERROR_NONE;
2081         }
2082
2083         ret = regexec(&reg[8], str, 13, pmatch, 0);
2084         if (0 == ret) {
2085                 for (idx = 1; 13 > idx; idx++) {
2086                         len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2087
2088                         if (0 < len) {
2089                                 mon = idx - 1;
2090                                 break;
2091                         }
2092                 }
2093
2094                 m_flag = 1;
2095
2096                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2097
2098                 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2099                 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2100         } else {
2101                 char *lang = NULL;
2102                 vc_config_mgr_get_default_language(&lang);
2103                 if (NULL == lang) {
2104                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2105                         return VC_ERROR_OPERATION_FAILED;
2106                 }
2107
2108                 if (!strcmp("en_US", lang)) {
2109                         SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2110                         free(lang);
2111                         lang = NULL;
2112                         return VC_ERROR_NONE;
2113                 }
2114
2115                 free(lang);
2116                 lang = NULL;
2117
2118                 mon = td->tm_mon;
2119         }
2120
2121         ret = regexec(&reg[7], str, 3, pmatch, 0);
2122         if (0 == ret) {
2123                 if (!m_flag) return -1;
2124
2125                 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2126
2127                 if (0 > len) {
2128                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2129                         return VC_ERROR_OPERATION_FAILED;
2130                 }
2131                 tempstr = strndup(str + pmatch[2].rm_so, (size_t)len);
2132
2133                 if (NULL == tempstr) {
2134                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2135                         return VC_ERROR_OUT_OF_MEMORY;
2136                 }
2137
2138                 year = atoi(tempstr);
2139                 year = 1900 < year ? year - 1900 : year + 100;
2140
2141                 free(tempstr);
2142                 tempstr = NULL;
2143
2144                 y_flag = 1;
2145                 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2146
2147                 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2148                 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2149         } else {
2150                 year = td->tm_year;
2151         }
2152
2153         if (0 > g_time_flag) {
2154                 td->tm_hour = 0;
2155                 td->tm_min = 0;
2156                 td->tm_sec = 0;
2157         } else if (2 == g_time_flag) {
2158                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2159                 return VC_ERROR_NONE;
2160         }
2161
2162         int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2163         if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2164
2165         if (max_day[mon] < day || 1 > day) {
2166                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2167                 return VC_ERROR_NONE;
2168         }
2169
2170         td->tm_year = year;
2171         td->tm_mon = mon;
2172         td->tm_mday = day;
2173
2174         if (!y_flag) {
2175                 if (!m_flag) {
2176                         if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2177                 } else {
2178                         if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2179                         else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2180                 }
2181         }
2182
2183         __update_data_sidx(sidx);
2184         __update_data_eidx(eidx);
2185
2186         *exist = 1;
2187         return VC_ERROR_NONE;
2188 }
2189
2190 static int __vc_cmd_time_check(const char *str, struct tm *td)
2191 {
2192         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check time value in string \"%s\"", str);
2193
2194         vc_error_e ret;
2195         int exist = 0;
2196
2197         ret = __vc_cmd_tphrase_check(str, td, &exist);
2198         if (1 == exist) {
2199                 g_time_flag = 1;
2200
2201                 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2202                 return ret;
2203         } else if (VC_ERROR_NONE != ret) {
2204                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2205                 return ret;
2206         }
2207
2208         ret = __vc_cmd_trelative_check(str, td, &exist);
2209         if (1 == exist) {
2210                 g_time_flag = 2;
2211
2212                 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2213                 return ret;
2214         } else if (VC_ERROR_NONE != ret) {
2215                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2216                 return ret;
2217         }
2218
2219         ret = __vc_cmd_tabsolute_check(str, td, &exist);
2220         if (1 == exist) {
2221                 g_time_flag = 3;
2222
2223                 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2224                 return ret;
2225         } else if (VC_ERROR_NONE != ret) {
2226                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2227                 return ret;
2228         }
2229
2230         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no time value");
2231         return VC_ERROR_NONE;
2232 }
2233
2234 static int __vc_cmd_date_check(const char *str, struct tm *td)
2235 {
2236         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check date value in string \"%s\"", str);
2237
2238         vc_error_e ret;
2239         int exist = 0;
2240
2241         ret = __vc_cmd_dphrase_check(str, td, &exist);
2242         if (1 == exist) {
2243                 g_date_flag = 1;
2244
2245                 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2246                 return ret;
2247         } else if (VC_ERROR_NONE != ret) {
2248                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2249                 return ret;
2250         }
2251
2252         ret = __vc_cmd_dabsolute_check(str, td, &exist);
2253         if (1 == exist) {
2254                 g_date_flag = 1;
2255
2256                 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2257                 return ret;
2258         } else if (VC_ERROR_NONE != ret) {
2259                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2260                 return ret;
2261         }
2262
2263         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no date value");
2264         return VC_ERROR_NONE;
2265 }
2266
2267 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2268 {
2269         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get timestamp data");
2270
2271         struct tm td;
2272         const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2273         vc_error_e ret;
2274
2275         if (NULL == text || NULL == result || NULL == remain) {
2276                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2277                 return VC_ERROR_INVALID_PARAMETER;
2278         }
2279
2280         *result = -1;
2281         ret = __vc_cmd_regex_init();
2282         if (VC_ERROR_NONE != ret) {
2283                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2284                 return ret;
2285         }
2286
2287         g_data_sidx = g_data_eidx = -1;
2288
2289         t_now = time(NULL);
2290         localtime_r(&t_now, &td_now);
2291         SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2292
2293         __copy_struct_tm(&td, &td_now);
2294         SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s),  %d:%d:%d",
2295                 td.tm_year + 1900, td.tm_mon + 1, td.tm_mday, day_name[td.tm_wday], td.tm_hour, td.tm_min, td.tm_sec);
2296
2297         g_time_flag = g_date_flag = -1;
2298
2299         ret = __vc_cmd_time_check(text, &td);
2300         if (VC_ERROR_NONE != ret) {
2301                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2302                 return ret;
2303         }
2304
2305         ret = __vc_cmd_date_check(text, &td);
2306         if (VC_ERROR_NONE != ret) {
2307                 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2308                 return ret;
2309         }
2310
2311         __vc_cmd_regex_deinit(12);
2312
2313         if (g_time_flag > 0 || g_date_flag > 0) {
2314                 *result = mktime(&td);
2315
2316                 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %ld", *result);
2317                 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s),  %d:%d:%d",
2318                         td.tm_year + 1900, td.tm_mon + 1, td.tm_mday, day_name[td.tm_wday], td.tm_hour, td.tm_min, td.tm_sec);
2319
2320                 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2321
2322                 if (NULL == *remain) {
2323                         SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2324                         return VC_ERROR_OUT_OF_MEMORY;
2325                 }
2326
2327                 strncpy(*remain, text, g_data_sidx);
2328                 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2329         } else {
2330                 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2331         }
2332
2333         SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
2334
2335         return VC_ERROR_NONE;
2336 }