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