2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <cynara-client.h>
20 #include <cynara-error.h>
21 #include <cynara-session.h>
24 #include <system_info.h>
26 #include "vc_command.h"
27 #include "vc_info_parser.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"
36 static pthread_mutex_t g_cmd_mutex = PTHREAD_MUTEX_INITIALIZER;
37 static pthread_mutex_t g_cmd_list_mutex = PTHREAD_MUTEX_INITIALIZER;
38 #define CMD_MUTEX_LOCK() pthread_mutex_lock(&g_cmd_mutex)
39 #define CMD_MUTEX_UNLOCK() pthread_mutex_unlock(&g_cmd_mutex)
40 #define CMD_LIST_MUTEX_LOCK() pthread_mutex_lock(&g_cmd_list_mutex)
41 #define CMD_LIST_MUTEX_UNLOCK() pthread_mutex_unlock(&g_cmd_list_mutex)
43 static int g_feature_enabled = -1;
44 static bool g_privilege_allowed = false;
46 static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER;
47 static cynara *p_cynara = NULL;
48 static GList *g_cmd_list = NULL;
49 static GList *g_cmdlist_list = NULL;
52 // For getting timestamp using regular expression
53 static regex_t reg[MAX_NUM_REGEX];
54 static time_t t_now; //time_t is based on UTC
55 static struct tm td_now; //if use localtime function, the value follows the local time zone, otherwise it follows the UTC.
57 static int g_time_flag;
58 static int g_date_flag;
60 static int g_data_sidx;
61 static int g_data_eidx;
63 static int __vc_cmd_get_feature_enabled()
65 if (0 == g_feature_enabled) {
67 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
68 return VC_ERROR_NOT_SUPPORTED;
70 } else if (-1 == g_feature_enabled) {
71 bool vc_supported = false;
72 bool mic_supported = false;
73 if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
75 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
76 return VC_ERROR_NOT_SUPPORTED;
80 if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
82 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
83 return VC_ERROR_NOT_SUPPORTED;
87 if (false == vc_supported || false == mic_supported) {
89 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
90 g_feature_enabled = 0;
91 return VC_ERROR_NOT_SUPPORTED;
95 g_feature_enabled = 1;
101 static int __check_privilege_initialize()
103 int ret = cynara_initialize(&p_cynara, NULL);
104 if (CYNARA_API_SUCCESS != ret)
105 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
107 return ret == CYNARA_API_SUCCESS;
110 static int __check_privilege(const char* uid, const char * privilege)
113 char label_path[1024] = "/proc/self/attr/current";
114 char smack_label[1024] = {'\0',};
120 fp = fopen(label_path, "r");
122 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
123 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
128 pid_t pid = getpid();
129 char *session = cynara_session_from_pid(pid);
130 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
131 SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
135 if (ret != CYNARA_API_ACCESS_ALLOWED)
140 static void __check_privilege_deinitialize()
144 int ret = cynara_finish(p_cynara);
145 if (ret != CYNARA_API_SUCCESS)
146 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] cynara finish %d", ret);
151 static int __vc_cmd_check_privilege()
153 if (true == g_privilege_allowed)
154 return VC_ERROR_NONE;
156 pthread_mutex_lock(&g_cynara_mutex);
158 if (false == g_privilege_allowed) {
160 ret = __check_privilege_initialize();
162 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
163 g_privilege_allowed = false;
164 pthread_mutex_unlock(&g_cynara_mutex);
165 return VC_ERROR_PERMISSION_DENIED;
169 snprintf(uid, 32, "%d", getuid());
171 ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
174 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
175 __check_privilege_deinitialize();
176 g_privilege_allowed = false;
177 pthread_mutex_unlock(&g_cynara_mutex);
178 return VC_ERROR_PERMISSION_DENIED;
182 __check_privilege_deinitialize();
185 g_privilege_allowed = true;
186 pthread_mutex_unlock(&g_cynara_mutex);
187 return VC_ERROR_NONE;
190 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
192 if (0 != __vc_cmd_get_feature_enabled()) {
193 return VC_ERROR_NOT_SUPPORTED;
195 if (0 != __vc_cmd_check_privilege()) {
196 return VC_ERROR_PERMISSION_DENIED;
199 CMD_LIST_MUTEX_LOCK();
201 if (NULL == vc_cmd_list) {
202 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
203 CMD_LIST_MUTEX_UNLOCK();
204 return VC_ERROR_INVALID_PARAMETER;
207 vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
210 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
211 CMD_LIST_MUTEX_UNLOCK();
212 return VC_ERROR_OUT_OF_MEMORY;
218 *vc_cmd_list = (vc_cmd_list_h)list;
220 g_cmdlist_list = g_list_append(g_cmdlist_list, list);
222 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
224 CMD_LIST_MUTEX_UNLOCK();
225 return VC_ERROR_NONE;
228 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
230 if (0 != __vc_cmd_get_feature_enabled()) {
231 return VC_ERROR_NOT_SUPPORTED;
233 if (0 != __vc_cmd_check_privilege()) {
234 return VC_ERROR_PERMISSION_DENIED;
237 CMD_LIST_MUTEX_LOCK();
239 if (NULL == vc_cmd_list) {
240 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
241 CMD_LIST_MUTEX_UNLOCK();
242 return VC_ERROR_INVALID_PARAMETER;
246 vc_cmd_list_s* list = NULL;
247 list = (vc_cmd_list_s*)vc_cmd_list;
249 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
252 iter = g_list_find(g_cmdlist_list, list);
254 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
255 CMD_LIST_MUTEX_UNLOCK();
256 return VC_ERROR_INVALID_PARAMETER;
259 g_cmdlist_list = g_list_delete_link(g_cmdlist_list, iter);
261 vc_cmd_list_remove_all((vc_cmd_list_h)list, release_command);
265 SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
267 CMD_LIST_MUTEX_UNLOCK();
268 return VC_ERROR_NONE;
271 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
273 if (0 != __vc_cmd_get_feature_enabled()) {
274 return VC_ERROR_NOT_SUPPORTED;
276 if (0 != __vc_cmd_check_privilege()) {
277 return VC_ERROR_PERMISSION_DENIED;
280 if (NULL == vc_cmd_list || NULL == count) {
281 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
282 return VC_ERROR_INVALID_PARAMETER;
285 vc_cmd_list_s* list = NULL;
286 list = (vc_cmd_list_s*)vc_cmd_list;
288 *count = g_slist_length(list->list);
290 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
292 return VC_ERROR_NONE;
295 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
297 if (0 != __vc_cmd_get_feature_enabled()) {
298 return VC_ERROR_NOT_SUPPORTED;
300 if (0 != __vc_cmd_check_privilege()) {
301 return VC_ERROR_PERMISSION_DENIED;
304 if (NULL == vc_cmd_list || NULL == vc_command) {
305 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
306 return VC_ERROR_INVALID_PARAMETER;
309 vc_cmd_list_s* list = NULL;
310 list = (vc_cmd_list_s*)vc_cmd_list;
312 vc_cmd_s* cmd = NULL;
313 cmd = (vc_cmd_s*)vc_command;
315 list->list = g_slist_append(list->list, cmd);
317 if (1 == g_slist_length(list->list)) {
321 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
323 return VC_ERROR_NONE;
326 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
328 if (0 != __vc_cmd_get_feature_enabled()) {
329 return VC_ERROR_NOT_SUPPORTED;
331 if (0 != __vc_cmd_check_privilege()) {
332 return VC_ERROR_PERMISSION_DENIED;
335 if (NULL == vc_cmd_list || NULL == vc_command) {
336 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
337 return VC_ERROR_INVALID_PARAMETER;
340 vc_cmd_list_s* list = NULL;
341 list = (vc_cmd_list_s*)vc_cmd_list;
343 vc_cmd_s* cmd = NULL;
344 cmd = (vc_cmd_s*)vc_command;
346 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
349 iter = g_slist_find(list->list, cmd);
351 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy command : handle is not valid");
352 return VC_ERROR_INVALID_PARAMETER;
355 list->list = g_slist_remove_link(list->list, iter);
356 SLOG(LOG_DEBUG, TAG_VCCMD, "destroy command");
358 int len = g_slist_length(list->list);
361 else if (list->index == len)
362 list->index = len - 1;
364 return VC_ERROR_NONE;
367 static void __vc_cmd_list_remove_all_foreach(gpointer data)
369 vc_cmd_s *temp = (vc_cmd_s *)data;
371 SECURE_SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
372 vc_cmd_destroy((vc_cmd_h)temp);
376 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
378 if (0 != __vc_cmd_get_feature_enabled()) {
379 return VC_ERROR_NOT_SUPPORTED;
381 if (0 != __vc_cmd_check_privilege()) {
382 return VC_ERROR_PERMISSION_DENIED;
385 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Destroy all command");
387 if (NULL == vc_cmd_list) {
388 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
389 return VC_ERROR_INVALID_PARAMETER;
392 vc_cmd_list_s* cmd_list = (vc_cmd_list_s*)vc_cmd_list;
394 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
395 , cmd_list, release_command ? "true" : "false");
397 if (NULL == cmd_list->list) {
398 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ List is already empty.");
399 return VC_ERROR_NONE;
402 if (true == release_command) {
403 g_slist_free_full(cmd_list->list, __vc_cmd_list_remove_all_foreach);
405 g_slist_free(cmd_list->list);
408 cmd_list->list = NULL;
409 cmd_list->index = -1;
411 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
413 return VC_ERROR_NONE;
416 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
418 if (0 != __vc_cmd_get_feature_enabled()) {
419 return VC_ERROR_NOT_SUPPORTED;
421 if (0 != __vc_cmd_check_privilege()) {
422 return VC_ERROR_PERMISSION_DENIED;
425 if (NULL == vc_cmd_list || NULL == callback) {
426 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
427 return VC_ERROR_INVALID_PARAMETER;
430 vc_cmd_list_s* list = NULL;
431 list = (vc_cmd_list_s*)vc_cmd_list;
434 iter = g_slist_nth(list->list, 0);
435 while (NULL != iter) {
436 vc_cmd_s *temp_cmd = NULL;
437 temp_cmd = iter->data;
438 if (NULL == temp_cmd) {
439 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
440 return VC_ERROR_OPERATION_FAILED;
442 if (false == callback((vc_cmd_h)temp_cmd, user_data))
445 iter = g_slist_next(iter);
448 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Foreach commands Done");
450 return VC_ERROR_NONE;
453 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
455 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Filter by type");
457 if (0 != __vc_cmd_get_feature_enabled()) {
458 return VC_ERROR_NOT_SUPPORTED;
460 if (0 != __vc_cmd_check_privilege()) {
461 return VC_ERROR_PERMISSION_DENIED;
464 if (NULL == original || NULL == filtered) {
465 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
466 return VC_ERROR_INVALID_PARAMETER;
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;
474 vc_cmd_list_s* list = NULL;
475 list = (vc_cmd_list_s*)original;
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;
484 iter = g_slist_nth(list->list, 0);
485 while (NULL != iter) {
486 vc_cmd_s *iter_cmd = NULL;
487 iter_cmd = iter->data;
488 if (NULL == iter_cmd) {
489 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
490 return VC_ERROR_OPERATION_FAILED;
494 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
495 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
499 if (iter_type == type) {
501 if (0 != vc_cmd_create(&temp_cmd)) {
502 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
506 memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
507 if (NULL != iter_cmd->command)
508 ((vc_cmd_s *)temp_cmd)->command = strdup(iter_cmd->command);
509 if (NULL != iter_cmd->parameter)
510 ((vc_cmd_s *)temp_cmd)->parameter = strdup(iter_cmd->parameter);
512 if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
513 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
514 vc_cmd_destroy(temp_cmd);
518 iter = g_slist_next(iter);
522 if (0 != vc_cmd_list_get_count(temp_list, &count)) {
523 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
525 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
528 *filtered = temp_list;
530 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
532 return VC_ERROR_NONE;
535 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
537 if (0 != __vc_cmd_get_feature_enabled()) {
538 return VC_ERROR_NOT_SUPPORTED;
540 if (0 != __vc_cmd_check_privilege()) {
541 return VC_ERROR_PERMISSION_DENIED;
544 if (NULL == vc_cmd_list) {
545 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
546 return VC_ERROR_INVALID_PARAMETER;
549 vc_cmd_list_s* list = NULL;
550 list = (vc_cmd_list_s*)vc_cmd_list;
552 if (0 == g_slist_length(list->list)) {
553 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
554 return VC_ERROR_EMPTY;
559 return VC_ERROR_NONE;
562 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
564 if (0 != __vc_cmd_get_feature_enabled()) {
565 return VC_ERROR_NOT_SUPPORTED;
567 if (0 != __vc_cmd_check_privilege()) {
568 return VC_ERROR_PERMISSION_DENIED;
571 if (NULL == vc_cmd_list) {
572 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
573 return VC_ERROR_INVALID_PARAMETER;
576 vc_cmd_list_s* list = NULL;
577 list = (vc_cmd_list_s*)vc_cmd_list;
579 int count = g_slist_length(list->list);
582 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
583 return VC_ERROR_EMPTY;
585 list->index = count - 1;
586 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
589 return VC_ERROR_NONE;
592 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
594 if (0 != __vc_cmd_get_feature_enabled()) {
595 return VC_ERROR_NOT_SUPPORTED;
597 if (0 != __vc_cmd_check_privilege()) {
598 return VC_ERROR_PERMISSION_DENIED;
601 if (NULL == vc_cmd_list) {
602 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
603 return VC_ERROR_INVALID_PARAMETER;
606 vc_cmd_list_s* list = NULL;
607 list = (vc_cmd_list_s*)vc_cmd_list;
609 int count = g_slist_length(list->list);
611 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
612 return VC_ERROR_EMPTY;
615 if (list->index < count - 1) {
616 list->index = list->index + 1;
617 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
619 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
620 return VC_ERROR_ITERATION_END;
623 return VC_ERROR_NONE;
626 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
628 if (0 != __vc_cmd_get_feature_enabled()) {
629 return VC_ERROR_NOT_SUPPORTED;
631 if (0 != __vc_cmd_check_privilege()) {
632 return VC_ERROR_PERMISSION_DENIED;
635 if (NULL == vc_cmd_list) {
636 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
637 return VC_ERROR_INVALID_PARAMETER;
640 vc_cmd_list_s* list = NULL;
641 list = (vc_cmd_list_s*)vc_cmd_list;
643 if (0 == g_slist_length(list->list)) {
644 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
645 return VC_ERROR_EMPTY;
648 if (list->index > 0) {
649 list->index = list->index - 1;
650 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
652 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
653 return VC_ERROR_ITERATION_END;
656 return VC_ERROR_NONE;
659 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
661 if (0 != __vc_cmd_get_feature_enabled()) {
662 return VC_ERROR_NOT_SUPPORTED;
664 if (0 != __vc_cmd_check_privilege()) {
665 return VC_ERROR_PERMISSION_DENIED;
668 if (NULL == vc_cmd_list || NULL == vc_command) {
669 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
670 return VC_ERROR_INVALID_PARAMETER;
673 vc_cmd_list_s* list = NULL;
674 list = (vc_cmd_list_s*)vc_cmd_list;
676 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
678 if (0 == g_slist_length(list->list)) {
679 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
681 return VC_ERROR_EMPTY;
684 vc_cmd_s *temp_cmd = NULL;
685 temp_cmd = g_slist_nth_data(list->list, list->index);
687 *vc_command = (vc_cmd_h)temp_cmd;
689 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
691 return VC_ERROR_NONE;
695 int vc_cmd_create(vc_cmd_h* vc_command)
697 if (0 != __vc_cmd_get_feature_enabled()) {
698 return VC_ERROR_NOT_SUPPORTED;
700 if (0 != __vc_cmd_check_privilege()) {
701 return VC_ERROR_PERMISSION_DENIED;
706 if (NULL == vc_command) {
707 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
709 return VC_ERROR_INVALID_PARAMETER;
712 vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
714 if (NULL == command) {
715 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
717 return VC_ERROR_OUT_OF_MEMORY;
723 command->type = VC_COMMAND_TYPE_NONE;
724 command->format = VC_CMD_FORMAT_FIXED;
725 command->command = NULL;
726 command->parameter = NULL;
728 command->priority = 0;
729 command->key = VC_KEY_NONE;
730 command->modifier = VC_MODIFIER_NONE;
731 command->invocation_name = NULL;
732 command->appid = NULL;
733 command->fixed = NULL;
734 command->coordinates = NULL;
736 *vc_command = (vc_cmd_h)command;
738 g_cmd_list = g_list_append(g_cmd_list, command);
740 SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
743 return VC_ERROR_NONE;
746 int vc_cmd_destroy(vc_cmd_h vc_command)
748 if (0 != __vc_cmd_get_feature_enabled()) {
749 return VC_ERROR_NOT_SUPPORTED;
751 if (0 != __vc_cmd_check_privilege()) {
752 return VC_ERROR_PERMISSION_DENIED;
757 if (NULL == vc_command) {
758 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
760 return VC_ERROR_INVALID_PARAMETER;
763 vc_cmd_s* command = NULL;
764 command = (vc_cmd_s*)vc_command;
766 SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
769 iter = g_list_find(g_cmd_list, command);
771 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to command destroy : handle is not valid");
773 return VC_ERROR_INVALID_PARAMETER;
776 g_cmd_list = g_list_delete_link(g_cmd_list, iter);
778 if (command->command)
779 free(command->command);
780 command->command = NULL;
781 if (command->parameter)
782 free(command->parameter);
783 command->parameter = NULL;
784 if (command->invocation_name)
785 free(command->invocation_name);
786 command->invocation_name = NULL;
788 free(command->appid);
789 command->appid = NULL;
791 free(command->fixed);
792 command->fixed = NULL;
793 if (command->coordinates)
794 free(command->coordinates);
795 command->coordinates = NULL;
800 return VC_ERROR_NONE;
803 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
805 if (0 != __vc_cmd_get_feature_enabled()) {
806 return VC_ERROR_NOT_SUPPORTED;
808 if (0 != __vc_cmd_check_privilege()) {
809 return VC_ERROR_PERMISSION_DENIED;
812 if (NULL == vc_command) {
813 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
814 return VC_ERROR_INVALID_PARAMETER;
817 vc_cmd_s* cmd = NULL;
818 cmd = (vc_cmd_s*)vc_command;
821 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
823 return VC_ERROR_NONE;
827 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
829 if (0 != __vc_cmd_get_feature_enabled()) {
830 return VC_ERROR_NOT_SUPPORTED;
832 if (0 != __vc_cmd_check_privilege()) {
833 return VC_ERROR_PERMISSION_DENIED;
836 if (NULL == vc_command || NULL == id) {
837 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
838 return VC_ERROR_INVALID_PARAMETER;
841 vc_cmd_s* cmd = NULL;
842 cmd = (vc_cmd_s*)vc_command;
845 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
847 return VC_ERROR_NONE;
851 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
853 if (0 != __vc_cmd_get_feature_enabled()) {
854 return VC_ERROR_NOT_SUPPORTED;
857 if (NULL == vc_command) {
858 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
859 return VC_ERROR_INVALID_PARAMETER;
863 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
864 return VC_ERROR_INVALID_PARAMETER;
867 vc_cmd_s* cmd = NULL;
868 cmd = (vc_cmd_s*)vc_command;
873 cmd->appid = strdup(appid);
875 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
876 return VC_ERROR_NONE;
879 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
881 if (0 != __vc_cmd_get_feature_enabled()) {
882 return VC_ERROR_NOT_SUPPORTED;
885 if (NULL == vc_command || NULL == appid) {
886 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
887 return VC_ERROR_INVALID_PARAMETER;
890 vc_cmd_s* cmd = NULL;
891 cmd = (vc_cmd_s*)vc_command;
894 *appid = strdup(gettext(cmd->appid));
898 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
900 return VC_ERROR_NONE;
903 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
905 if (0 != __vc_cmd_get_feature_enabled()) {
906 return VC_ERROR_NOT_SUPPORTED;
908 if (0 != __vc_cmd_check_privilege()) {
909 return VC_ERROR_PERMISSION_DENIED;
912 if (NULL == vc_command || NULL == command) {
913 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
914 return VC_ERROR_INVALID_PARAMETER;
917 vc_cmd_s* cmd = NULL;
918 cmd = (vc_cmd_s*)vc_command;
923 cmd->command = strdup(command);
925 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
927 return VC_ERROR_NONE;
930 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
932 if (0 != __vc_cmd_get_feature_enabled()) {
933 return VC_ERROR_NOT_SUPPORTED;
935 if (0 != __vc_cmd_check_privilege()) {
936 return VC_ERROR_PERMISSION_DENIED;
939 if (NULL == vc_command || NULL == command) {
940 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
941 return VC_ERROR_INVALID_PARAMETER;
944 vc_cmd_s* cmd = NULL;
945 cmd = (vc_cmd_s*)vc_command;
948 *command = strdup(gettext(cmd->command));
952 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
954 return VC_ERROR_NONE;
957 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
959 if (0 != __vc_cmd_get_feature_enabled()) {
960 return VC_ERROR_NOT_SUPPORTED;
962 if (0 != __vc_cmd_check_privilege()) {
963 return VC_ERROR_PERMISSION_DENIED;
966 if (NULL == vc_command || NULL == command) {
967 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
968 return VC_ERROR_INVALID_PARAMETER;
971 vc_cmd_s* cmd = NULL;
972 cmd = (vc_cmd_s*)vc_command;
975 free(cmd->parameter);
976 cmd->parameter = NULL;
977 cmd->parameter = strdup(command);
978 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
980 return VC_ERROR_NONE;
983 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
985 if (0 != __vc_cmd_get_feature_enabled()) {
986 return VC_ERROR_NOT_SUPPORTED;
989 if (NULL == vc_command || NULL == command) {
990 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
991 return VC_ERROR_INVALID_PARAMETER;
994 vc_cmd_s* cmd = NULL;
995 cmd = (vc_cmd_s*)vc_command;
998 *command = strdup(gettext(cmd->parameter));
1002 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
1004 return VC_ERROR_NONE;
1008 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
1010 if (0 != __vc_cmd_get_feature_enabled()) {
1011 return VC_ERROR_NOT_SUPPORTED;
1014 if (NULL == vc_command) {
1015 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1016 return VC_ERROR_INVALID_PARAMETER;
1019 if (NULL == fixed) {
1020 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
1021 return VC_ERROR_INVALID_PARAMETER;
1024 vc_cmd_s* cmd = NULL;
1025 cmd = (vc_cmd_s*)vc_command;
1030 cmd->fixed = strdup(fixed);
1032 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
1033 return VC_ERROR_NONE;
1036 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
1038 if (0 != __vc_cmd_get_feature_enabled()) {
1039 return VC_ERROR_NOT_SUPPORTED;
1042 if (NULL == vc_command || NULL == fixed) {
1043 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1044 return VC_ERROR_INVALID_PARAMETER;
1047 vc_cmd_s* cmd = NULL;
1048 cmd = (vc_cmd_s*)vc_command;
1051 *fixed = strdup(gettext(cmd->fixed));
1055 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1057 return VC_ERROR_NONE;
1061 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1063 if (0 != __vc_cmd_get_feature_enabled()) {
1064 return VC_ERROR_NOT_SUPPORTED;
1067 if (NULL == vc_command) {
1068 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1069 return VC_ERROR_INVALID_PARAMETER;
1072 if (NULL == invocation_name) {
1073 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1074 return VC_ERROR_INVALID_PARAMETER;
1077 vc_cmd_s* cmd = NULL;
1078 cmd = (vc_cmd_s*)vc_command;
1080 if (cmd->invocation_name)
1081 free(cmd->invocation_name);
1082 cmd->invocation_name = NULL;
1083 cmd->invocation_name = strdup(invocation_name);
1085 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1086 return VC_ERROR_NONE;
1090 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1092 if (0 != __vc_cmd_get_feature_enabled()) {
1093 return VC_ERROR_NOT_SUPPORTED;
1096 if (NULL == vc_command || NULL == invocation_name) {
1097 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1098 return VC_ERROR_INVALID_PARAMETER;
1101 vc_cmd_s* cmd = NULL;
1102 cmd = (vc_cmd_s*)vc_command;
1104 if (cmd->invocation_name)
1105 *invocation_name = strdup(gettext(cmd->invocation_name));
1107 *invocation_name = NULL;
1109 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1110 return VC_ERROR_NONE;
1114 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1116 if (0 != __vc_cmd_get_feature_enabled()) {
1117 return VC_ERROR_NOT_SUPPORTED;
1119 if (0 != __vc_cmd_check_privilege()) {
1120 return VC_ERROR_PERMISSION_DENIED;
1123 if (NULL == vc_command) {
1124 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1125 return VC_ERROR_INVALID_PARAMETER;
1128 if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
1129 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type(%d)", type);
1130 return VC_ERROR_INVALID_PARAMETER;
1133 vc_cmd_s* cmd = NULL;
1134 cmd = (vc_cmd_s*)vc_command;
1138 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1140 return VC_ERROR_NONE;
1143 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1145 if (0 != __vc_cmd_get_feature_enabled()) {
1146 return VC_ERROR_NOT_SUPPORTED;
1148 if (0 != __vc_cmd_check_privilege()) {
1149 return VC_ERROR_PERMISSION_DENIED;
1152 if (NULL == vc_command || NULL == type) {
1153 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1154 return VC_ERROR_INVALID_PARAMETER;
1157 vc_cmd_s* cmd = NULL;
1158 cmd = (vc_cmd_s*)vc_command;
1162 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1164 return VC_ERROR_NONE;
1167 int vc_cmd_set_format(vc_cmd_h vc_command, int format)
1169 if (0 != __vc_cmd_get_feature_enabled()) {
1170 return VC_ERROR_NOT_SUPPORTED;
1173 if (NULL == vc_command) {
1174 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1175 return VC_ERROR_INVALID_PARAMETER;
1178 if (VC_COMMAND_FORMAT_FIXED > format || VC_COMMAND_FORMAT_NONFIXED_AND_FIXED < format) {
1179 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid format(%d)", format);
1180 return VC_ERROR_INVALID_PARAMETER;
1183 vc_cmd_s* cmd = NULL;
1184 cmd = (vc_cmd_s*)vc_command;
1186 cmd->format = format;
1188 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1190 return VC_ERROR_NONE;
1193 int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
1195 if (0 != __vc_cmd_get_feature_enabled()) {
1196 return VC_ERROR_NOT_SUPPORTED;
1199 if (NULL == vc_command || NULL == format) {
1200 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1201 return VC_ERROR_INVALID_PARAMETER;
1204 vc_cmd_s* cmd = NULL;
1205 cmd = (vc_cmd_s*)vc_command;
1207 *format = cmd->format;
1209 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1211 return VC_ERROR_NONE;
1214 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1216 if (0 != __vc_cmd_get_feature_enabled()) {
1217 return VC_ERROR_NOT_SUPPORTED;
1219 if (0 != __vc_cmd_check_privilege()) {
1220 return VC_ERROR_PERMISSION_DENIED;
1223 if (NULL == vc_command) {
1224 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1225 return VC_ERROR_INVALID_PARAMETER;
1229 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid pid (%d)", pid);
1230 return VC_ERROR_INVALID_PARAMETER;
1233 vc_cmd_s* cmd = NULL;
1234 cmd = (vc_cmd_s*)vc_command;
1238 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1240 return VC_ERROR_NONE;
1243 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1245 if (0 != __vc_cmd_get_feature_enabled()) {
1246 return VC_ERROR_NOT_SUPPORTED;
1248 if (0 != __vc_cmd_check_privilege()) {
1249 return VC_ERROR_PERMISSION_DENIED;
1252 if (NULL == vc_command || NULL == pid) {
1253 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1254 return VC_ERROR_INVALID_PARAMETER;
1257 vc_cmd_s* cmd = NULL;
1258 cmd = (vc_cmd_s*)vc_command;
1262 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1264 return VC_ERROR_NONE;
1267 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1269 if (0 != __vc_cmd_get_feature_enabled()) {
1270 return VC_ERROR_NOT_SUPPORTED;
1272 if (0 != __vc_cmd_check_privilege()) {
1273 return VC_ERROR_PERMISSION_DENIED;
1276 if (NULL == vc_command) {
1277 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1278 return VC_ERROR_INVALID_PARAMETER;
1281 vc_cmd_s* cmd = NULL;
1282 cmd = (vc_cmd_s*)vc_command;
1284 cmd->domain = domain;
1286 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1288 return VC_ERROR_NONE;
1291 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1293 if (0 != __vc_cmd_get_feature_enabled()) {
1294 return VC_ERROR_NOT_SUPPORTED;
1296 if (0 != __vc_cmd_check_privilege()) {
1297 return VC_ERROR_PERMISSION_DENIED;
1300 if (NULL == vc_command || NULL == domain) {
1301 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1302 return VC_ERROR_INVALID_PARAMETER;
1305 vc_cmd_s* cmd = NULL;
1306 cmd = (vc_cmd_s*)vc_command;
1308 *domain = cmd->domain;
1310 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1312 return VC_ERROR_NONE;
1317 * @brief Sets key value of command.
1319 * @param[in] vc_command Command handle
1320 * @param[in] key key value
1321 * @param[in] modifier modifier value
1323 * @return 0 on success, otherwise a negative error value
1324 * @retval #VC_ERROR_NONE Successful
1325 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1327 * @see vc_cmd_get_result_key()
1329 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1331 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Set result key");
1333 if (NULL == vc_command) {
1334 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1335 return VC_ERROR_INVALID_PARAMETER;
1338 vc_cmd_s* cmd = NULL;
1339 cmd = (vc_cmd_s*)vc_command;
1341 SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1344 cmd->modifier = modifier;
1346 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1348 return VC_ERROR_NONE;
1352 * @brief Gets key value of command.
1354 * @param[in] vc_command Command handle
1355 * @param[out] key key value
1356 * @param[out] modifier modifier value
1358 * @return 0 on success, otherwise a negative error value
1359 * @retval #VC_ERROR_NONE Successful
1360 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1362 * @see vc_cmd_add_result_key()
1364 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1366 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get result key");
1368 if (NULL == vc_command || NULL == key || NULL == modifier) {
1369 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1370 return VC_ERROR_INVALID_PARAMETER;
1373 vc_cmd_s* cmd = NULL;
1374 cmd = (vc_cmd_s*)vc_command;
1377 *modifier = cmd->modifier;
1379 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1381 return VC_ERROR_NONE;
1384 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1386 if (NULL == vc_cmd_list) {
1390 vc_cmd_list_s* list = NULL;
1391 list = (vc_cmd_list_s*)vc_cmd_list;
1393 SLOG(LOG_DEBUG, TAG_VCCMD, "@ Command List @");
1394 SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1397 GSList *iter = NULL;
1398 iter = g_slist_nth(list->list, 0);
1399 while (NULL != iter) {
1400 vc_cmd_s *cmd = NULL;
1403 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
1404 return VC_ERROR_OPERATION_FAILED;
1406 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)",
1407 i++, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1409 iter = g_slist_next(iter);
1412 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1414 return VC_ERROR_NONE;
1417 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1419 if (0 != __vc_cmd_get_feature_enabled()) {
1420 return VC_ERROR_NOT_SUPPORTED;
1423 if (NULL == vc_cmd || NULL == json) {
1424 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1425 return VC_ERROR_INVALID_PARAMETER;
1428 vc_cmd_s* cmd = NULL;
1429 cmd = (vc_cmd_s*)vc_cmd;
1431 if (VC_CMD_FORMAT_ACTION != cmd->format) {
1432 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1433 return VC_ERROR_INVALID_PARAMETER;
1436 if (0 != vc_info_parser_get_nlu_result(json)) {
1437 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1438 return VC_ERROR_OPERATION_FAILED;
1441 return VC_ERROR_NONE;
1444 static void __vc_cmd_regex_deinit(int num_regex)
1446 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start Deinitialize regex @@@");
1449 for (i = 0; num_regex > i; i++) {
1453 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1456 static int __vc_cmd_regex_init()
1458 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Initialize regular expression @@@");
1460 int cflags = REG_EXTENDED | REG_ICASE;
1466 vc_config_mgr_get_default_language(&lang);
1468 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1469 return VC_ERROR_OPERATION_FAILED;
1472 if (!strcmp("en_US", lang)) {
1474 } else if (!strcmp("ko_KR", lang)) {
1480 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1481 return VC_ERROR_INVALID_LANGUAGE;
1487 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ lang type > %d @@@", lang_type);
1489 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1491 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1492 ret = regcomp(®[0], TIME_ABS1_REGEX[lang_type], cflags);
1494 regerror(ret, ®[0], errStr, sizeof(errStr));
1496 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1497 return VC_ERROR_OPERATION_FAILED;
1500 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1501 ret = regcomp(®[1], TIME_ABS2_REGEX[lang_type], cflags);
1503 regerror(ret, ®[1], errStr, sizeof(errStr));
1504 __vc_cmd_regex_deinit(1);
1506 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1507 return VC_ERROR_OPERATION_FAILED;
1510 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1511 ret = regcomp(®[2], TIME_ABS3_REGEX[lang_type], cflags);
1513 regerror(ret, ®[2], errStr, sizeof(errStr));
1514 __vc_cmd_regex_deinit(2);
1516 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1517 return VC_ERROR_OPERATION_FAILED;
1520 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1521 ret = regcomp(®[3], TIME_REL1_REGEX[lang_type], cflags);
1523 regerror(ret, ®[3], errStr, sizeof(errStr));
1524 __vc_cmd_regex_deinit(3);
1526 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1527 return VC_ERROR_OPERATION_FAILED;
1530 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1531 ret = regcomp(®[4], TIME_REL2_REGEX[lang_type], cflags);
1533 regerror(ret, ®[4], errStr, sizeof(errStr));
1534 __vc_cmd_regex_deinit(4);
1536 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1537 return VC_ERROR_OPERATION_FAILED;
1540 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1541 ret = regcomp(®[5], TIME_REL3_REGEX[lang_type], cflags);
1543 regerror(ret, ®[5], errStr, sizeof(errStr));
1544 __vc_cmd_regex_deinit(5);
1546 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1547 return VC_ERROR_OPERATION_FAILED;
1550 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1551 ret = regcomp(®[6], TIME_PHR_REGEX[lang_type], cflags);
1553 regerror(ret, ®[6], errStr, sizeof(errStr));
1554 __vc_cmd_regex_deinit(6);
1556 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1557 return VC_ERROR_OPERATION_FAILED;
1560 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1561 ret = regcomp(®[7], DATE_ABS1_REGEX[lang_type], cflags);
1563 regerror(ret, ®[7], errStr, sizeof(errStr));
1564 __vc_cmd_regex_deinit(7);
1566 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1567 return VC_ERROR_OPERATION_FAILED;
1570 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1571 ret = regcomp(®[8], DATE_ABS2_REGEX[lang_type], cflags);
1573 regerror(ret, ®[8], errStr, sizeof(errStr));
1574 __vc_cmd_regex_deinit(8);
1576 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1577 return VC_ERROR_OPERATION_FAILED;
1580 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1581 ret = regcomp(®[9], DATE_ABS3_REGEX[lang_type], cflags);
1583 regerror(ret, ®[9], errStr, sizeof(errStr));
1584 __vc_cmd_regex_deinit(9);
1586 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1587 return VC_ERROR_OPERATION_FAILED;
1590 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1591 ret = regcomp(®[10], DATE_PHR1_REGEX[lang_type], cflags);
1593 regerror(ret, ®[10], errStr, sizeof(errStr));
1594 __vc_cmd_regex_deinit(10);
1596 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1597 return VC_ERROR_OPERATION_FAILED;
1600 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1601 ret = regcomp(®[11], DATE_PHR2_REGEX[lang_type], cflags);
1603 regerror(ret, ®[11], errStr, sizeof(errStr));
1604 __vc_cmd_regex_deinit(11);
1606 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1607 return VC_ERROR_OPERATION_FAILED;
1610 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1612 return VC_ERROR_NONE;
1615 static void __vc_cmd_add_year(struct tm *td, int year)
1617 td->tm_year += year;
1620 static void __vc_cmd_add_mon(struct tm *td, int mon)
1624 mon = td->tm_mon + mon;
1628 __vc_cmd_add_year(td, year);
1631 td->tm_mon = mon % 12;
1634 static void __vc_cmd_add_mday(struct tm *td, int mday)
1636 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1637 int year = td->tm_year + 1900;
1641 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1643 mday = td->tm_mday + mday;
1645 for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1646 mday -= max_day[mon % 12];
1648 if (11 == mon % 12) {
1651 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1659 mon = mon - td->tm_mon;
1662 __vc_cmd_add_mon(td, mon);
1668 static void __vc_cmd_add_hour(struct tm *td, int hour)
1672 hour = td->tm_hour + hour;
1676 __vc_cmd_add_mday(td, day);
1679 td->tm_hour = hour % 24;
1682 static void __vc_cmd_add_min(struct tm *td, int min)
1686 min = td->tm_min + min;
1690 __vc_cmd_add_hour(td, hour);
1693 td->tm_min = min % 60;
1696 static void __copy_struct_tm(struct tm *des, struct tm *src)
1698 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start to copy struct tm @@@");
1700 des->tm_sec = src->tm_sec;
1701 des->tm_min = src->tm_min;
1702 des->tm_hour = src->tm_hour;
1703 des->tm_mday = src->tm_mday;
1704 des->tm_mon = src->tm_mon;
1705 des->tm_year = src->tm_year;
1706 des->tm_wday = src->tm_wday;
1707 des->tm_yday = src->tm_yday;
1708 des->tm_isdst = src->tm_isdst;
1710 des->tm_gmtoff = src->tm_gmtoff;
1711 des->tm_zone = src->tm_zone;
1714 static void __update_data_sidx(int idx)
1716 if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1719 static void __update_data_eidx(int idx)
1721 if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1724 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1726 regmatch_t pmatch[3];
1732 ret = regexec(®[6], str, 3, pmatch, 0);
1735 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1737 if (12 < td->tm_hour) {
1738 __vc_cmd_add_mday(td, 1);
1744 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1746 __vc_cmd_add_mday(td, 1);
1751 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1753 __update_data_sidx(pmatch[0].rm_so);
1754 __update_data_eidx(pmatch[0].rm_eo);
1757 return VC_ERROR_NONE;
1760 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1761 return VC_ERROR_NONE;
1764 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1766 regmatch_t pmatch[2];
1775 ret = regexec(®[3], str, 1, pmatch, 0);
1777 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1780 sidx = pmatch[0].rm_so;
1781 eidx = pmatch[0].rm_eo;
1783 ret = regexec(®[4], str, 2, pmatch, 0);
1785 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1788 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1789 return VC_ERROR_OPERATION_FAILED;
1791 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1793 if (NULL == tempstr) {
1794 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1795 return VC_ERROR_OUT_OF_MEMORY;
1798 hour = atoi(tempstr);
1803 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1805 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1806 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1809 ret = regexec(®[5], str, 2, pmatch, 0);
1811 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1814 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1815 return VC_ERROR_OPERATION_FAILED;
1817 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1819 if (NULL == tempstr) {
1820 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1821 return VC_ERROR_OUT_OF_MEMORY;
1824 min = atoi(tempstr);
1829 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1831 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1832 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1835 if (hour < 0 && min < 0) {
1836 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1837 return VC_ERROR_NONE;
1840 hour = 0 > hour ? 0 : hour;
1841 min = 0 > min ? 0 : min;
1843 min = min + (hour * 60);
1845 __vc_cmd_add_min(td, min);
1848 __update_data_sidx(sidx);
1849 __update_data_eidx(eidx);
1852 return VC_ERROR_NONE;
1855 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1856 return VC_ERROR_NONE;
1859 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1861 regmatch_t pmatch[5];
1872 ret = regexec(®[0], str, 5, pmatch, 0);
1874 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1878 sidx = pmatch[0].rm_so;
1879 eidx = pmatch[0].rm_eo;
1882 ret = regexec(®[1], str, 2, pmatch, 0);
1884 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1887 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1888 return VC_ERROR_OPERATION_FAILED;
1890 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1892 if (NULL == tempstr) {
1893 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1894 return VC_ERROR_OUT_OF_MEMORY;
1897 hour = atoi(tempstr);
1900 hour = hour + 12 * flag;
1902 if (12 == hour) hour = 0;
1903 else if (24 == hour) hour = 12;
1906 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1907 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1910 return VC_ERROR_NONE;
1916 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1918 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1919 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1920 } else if (0 < flag) {
1921 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1922 return VC_ERROR_NONE;
1925 ret = regexec(®[2], str, 2, pmatch, 0);
1928 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1930 char *tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
1932 if (NULL == tempstr) {
1933 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1934 return VC_ERROR_OUT_OF_MEMORY;
1937 min = atoi(tempstr);
1939 if (0 > min || 60 <= min) {
1940 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1943 return VC_ERROR_NONE;
1955 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1956 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1957 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1960 if (0 > hour && 0 > min) {
1961 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1962 return VC_ERROR_NONE;
1965 if (0 <= min && 0 <= hour) {
1966 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1970 } else if (0 <= min) {
1972 vc_config_mgr_get_default_language(&lang);
1974 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1975 return VC_ERROR_OPERATION_FAILED;
1978 if (!strcmp("en_US", lang)) {
1979 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1982 return VC_ERROR_NONE;
1984 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1991 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1999 __update_data_sidx(sidx);
2000 __update_data_eidx(eidx);
2003 return VC_ERROR_NONE;
2006 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
2008 regmatch_t pmatch[10];
2014 ret = regexec(®[10], str, 5, pmatch, 0);
2016 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
2018 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2020 td->tm_year = td_now.tm_year;
2021 td->tm_mon = td_now.tm_mon;
2022 td->tm_mday = td_now.tm_mday;
2024 __vc_cmd_add_mday(td, idx - 1);
2026 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2028 __update_data_sidx(pmatch[0].rm_so);
2029 __update_data_eidx(pmatch[0].rm_eo);
2032 return VC_ERROR_NONE;
2035 ret = regexec(®[11], str, 10, pmatch, 0);
2037 for (idx = 1; 10 > idx; idx++) {
2038 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2043 td->tm_year = td_now.tm_year;
2044 td->tm_mon = td_now.tm_mon;
2045 td->tm_mday = td_now.tm_mday;
2047 __vc_cmd_add_mday(td, idx + 1);
2049 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2051 __update_data_sidx(pmatch[0].rm_so);
2052 __update_data_eidx(pmatch[0].rm_eo);
2055 return VC_ERROR_NONE;
2058 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
2059 return VC_ERROR_NONE;
2062 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
2064 regmatch_t pmatch[13];
2075 char *tempstr = NULL;
2078 ret = regexec(®[9], str, 2, pmatch, 0);
2080 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2083 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2084 return VC_ERROR_OPERATION_FAILED;
2086 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
2088 if (NULL == tempstr) {
2089 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2090 return VC_ERROR_OUT_OF_MEMORY;
2093 day = atoi(tempstr);
2098 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2100 sidx = pmatch[0].rm_so;
2101 eidx = pmatch[0].rm_eo;
2103 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2104 return VC_ERROR_NONE;
2107 ret = regexec(®[8], str, 13, pmatch, 0);
2109 for (idx = 1; 13 > idx; idx++) {
2110 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2120 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2122 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2123 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2126 vc_config_mgr_get_default_language(&lang);
2128 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2129 return VC_ERROR_OPERATION_FAILED;
2132 if (!strcmp("en_US", lang)) {
2133 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2136 return VC_ERROR_NONE;
2145 ret = regexec(®[7], str, 3, pmatch, 0);
2147 if (!m_flag) return -1;
2149 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2152 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2153 return VC_ERROR_OPERATION_FAILED;
2155 tempstr = strndup(str + pmatch[2].rm_so, (size_t)len);
2157 if (NULL == tempstr) {
2158 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2159 return VC_ERROR_OUT_OF_MEMORY;
2162 year = atoi(tempstr);
2163 year = 1900 < year ? year - 1900 : year + 100;
2169 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2171 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2172 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2177 if (0 > g_time_flag) {
2181 } else if (2 == g_time_flag) {
2182 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2183 return VC_ERROR_NONE;
2186 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2187 if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2189 if (max_day[mon] < day || 1 > day) {
2190 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2191 return VC_ERROR_NONE;
2200 if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2202 if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2203 else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2207 __update_data_sidx(sidx);
2208 __update_data_eidx(eidx);
2211 return VC_ERROR_NONE;
2214 static int __vc_cmd_time_check(const char *str, struct tm *td)
2216 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check time value in string \"%s\"", str);
2221 ret = __vc_cmd_tphrase_check(str, td, &exist);
2225 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2227 } else if (VC_ERROR_NONE != ret) {
2228 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2232 ret = __vc_cmd_trelative_check(str, td, &exist);
2236 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2238 } else if (VC_ERROR_NONE != ret) {
2239 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2243 ret = __vc_cmd_tabsolute_check(str, td, &exist);
2247 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2249 } else if (VC_ERROR_NONE != ret) {
2250 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2254 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no time value");
2255 return VC_ERROR_NONE;
2258 static int __vc_cmd_date_check(const char *str, struct tm *td)
2260 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check date value in string \"%s\"", str);
2265 ret = __vc_cmd_dphrase_check(str, td, &exist);
2269 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2271 } else if (VC_ERROR_NONE != ret) {
2272 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2276 ret = __vc_cmd_dabsolute_check(str, td, &exist);
2280 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2282 } else if (VC_ERROR_NONE != ret) {
2283 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2287 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no date value");
2288 return VC_ERROR_NONE;
2291 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2293 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get timestamp data");
2296 const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2299 if (NULL == text || NULL == result || NULL == remain) {
2300 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2301 return VC_ERROR_INVALID_PARAMETER;
2305 ret = __vc_cmd_regex_init();
2306 if (VC_ERROR_NONE != ret) {
2307 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2311 g_data_sidx = g_data_eidx = -1;
2314 localtime_r(&t_now, &td_now);
2315 SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2317 __copy_struct_tm(&td, &td_now);
2318 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2319 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);
2321 g_time_flag = g_date_flag = -1;
2323 ret = __vc_cmd_time_check(text, &td);
2324 if (VC_ERROR_NONE != ret) {
2325 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2329 ret = __vc_cmd_date_check(text, &td);
2330 if (VC_ERROR_NONE != ret) {
2331 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2335 __vc_cmd_regex_deinit(12);
2337 if (g_time_flag > 0 || g_date_flag > 0) {
2338 *result = mktime(&td);
2340 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %ld", *result);
2341 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2342 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);
2344 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2346 if (NULL == *remain) {
2347 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2348 return VC_ERROR_OUT_OF_MEMORY;
2351 strncpy(*remain, text, g_data_sidx);
2352 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2354 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2357 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
2359 return VC_ERROR_NONE;