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) {
66 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
67 return VC_ERROR_NOT_SUPPORTED;
68 } else if (-1 == g_feature_enabled) {
69 bool vc_supported = false;
70 bool mic_supported = false;
71 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
72 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
73 if (false == vc_supported || false == mic_supported) {
74 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
75 g_feature_enabled = 0;
76 return VC_ERROR_NOT_SUPPORTED;
79 g_feature_enabled = 1;
81 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
82 return VC_ERROR_NOT_SUPPORTED;
85 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
86 return VC_ERROR_NOT_SUPPORTED;
93 static int __check_privilege_initialize()
95 int ret = cynara_initialize(&p_cynara, NULL);
96 if (CYNARA_API_SUCCESS != ret)
97 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
99 return ret == CYNARA_API_SUCCESS;
102 static int __check_privilege(const char* uid, const char * privilege)
105 char label_path[1024] = "/proc/self/attr/current";
106 char smack_label[1024] = {'\0',};
112 fp = fopen(label_path, "r");
114 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
115 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
120 pid_t pid = getpid();
121 char *session = cynara_session_from_pid(pid);
122 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
123 SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
127 if (ret != CYNARA_API_ACCESS_ALLOWED)
132 static void __check_privilege_deinitialize()
136 int ret = cynara_finish(p_cynara);
137 if (ret != CYNARA_API_SUCCESS)
138 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] cynara finish %d", ret);
143 static int __vc_cmd_check_privilege()
145 if (true == g_privilege_allowed)
146 return VC_ERROR_NONE;
148 pthread_mutex_lock(&g_cynara_mutex);
150 if (false == g_privilege_allowed) {
152 ret = __check_privilege_initialize();
154 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
155 g_privilege_allowed = false;
156 pthread_mutex_unlock(&g_cynara_mutex);
157 return VC_ERROR_PERMISSION_DENIED;
161 snprintf(uid, 32, "%d", getuid());
163 ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
166 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
167 __check_privilege_deinitialize();
168 g_privilege_allowed = false;
169 pthread_mutex_unlock(&g_cynara_mutex);
170 return VC_ERROR_PERMISSION_DENIED;
174 __check_privilege_deinitialize();
177 g_privilege_allowed = true;
178 pthread_mutex_unlock(&g_cynara_mutex);
179 return VC_ERROR_NONE;
182 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
184 if (0 != __vc_cmd_get_feature_enabled()) {
185 return VC_ERROR_NOT_SUPPORTED;
187 if (0 != __vc_cmd_check_privilege()) {
188 return VC_ERROR_PERMISSION_DENIED;
191 CMD_LIST_MUTEX_LOCK();
193 if (NULL == vc_cmd_list) {
194 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
195 CMD_LIST_MUTEX_UNLOCK();
196 return VC_ERROR_INVALID_PARAMETER;
199 vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
202 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
203 CMD_LIST_MUTEX_UNLOCK();
204 return VC_ERROR_OUT_OF_MEMORY;
210 *vc_cmd_list = (vc_cmd_list_h)list;
212 g_cmdlist_list = g_list_append(g_cmdlist_list, list);
214 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
216 CMD_LIST_MUTEX_UNLOCK();
217 return VC_ERROR_NONE;
220 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
222 if (0 != __vc_cmd_get_feature_enabled()) {
223 return VC_ERROR_NOT_SUPPORTED;
225 if (0 != __vc_cmd_check_privilege()) {
226 return VC_ERROR_PERMISSION_DENIED;
229 CMD_LIST_MUTEX_LOCK();
231 if (NULL == vc_cmd_list) {
232 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
233 CMD_LIST_MUTEX_UNLOCK();
234 return VC_ERROR_INVALID_PARAMETER;
238 vc_cmd_list_s* list = NULL;
239 list = (vc_cmd_list_s*)vc_cmd_list;
241 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
244 iter = g_list_find(g_cmdlist_list, list);
246 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
247 CMD_LIST_MUTEX_UNLOCK();
248 return VC_ERROR_INVALID_PARAMETER;
251 g_cmdlist_list = g_list_delete_link(g_cmdlist_list, iter);
253 vc_cmd_list_remove_all((vc_cmd_list_h)list, release_command);
257 SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
259 CMD_LIST_MUTEX_UNLOCK();
260 return VC_ERROR_NONE;
263 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
265 if (0 != __vc_cmd_get_feature_enabled()) {
266 return VC_ERROR_NOT_SUPPORTED;
268 if (0 != __vc_cmd_check_privilege()) {
269 return VC_ERROR_PERMISSION_DENIED;
272 if (NULL == vc_cmd_list || NULL == count) {
273 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
274 return VC_ERROR_INVALID_PARAMETER;
277 vc_cmd_list_s* list = NULL;
278 list = (vc_cmd_list_s*)vc_cmd_list;
280 *count = g_slist_length(list->list);
282 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
284 return VC_ERROR_NONE;
287 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
289 if (0 != __vc_cmd_get_feature_enabled()) {
290 return VC_ERROR_NOT_SUPPORTED;
292 if (0 != __vc_cmd_check_privilege()) {
293 return VC_ERROR_PERMISSION_DENIED;
296 if (NULL == vc_cmd_list || NULL == vc_command) {
297 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
298 return VC_ERROR_INVALID_PARAMETER;
301 vc_cmd_list_s* list = NULL;
302 list = (vc_cmd_list_s*)vc_cmd_list;
304 vc_cmd_s* cmd = NULL;
305 cmd = (vc_cmd_s*)vc_command;
307 list->list = g_slist_append(list->list, cmd);
309 if (1 == g_slist_length(list->list)) {
313 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
315 return VC_ERROR_NONE;
318 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
320 if (0 != __vc_cmd_get_feature_enabled()) {
321 return VC_ERROR_NOT_SUPPORTED;
323 if (0 != __vc_cmd_check_privilege()) {
324 return VC_ERROR_PERMISSION_DENIED;
327 if (NULL == vc_cmd_list || NULL == vc_command) {
328 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
329 return VC_ERROR_INVALID_PARAMETER;
332 vc_cmd_list_s* list = NULL;
333 list = (vc_cmd_list_s*)vc_cmd_list;
335 vc_cmd_s* cmd = NULL;
336 cmd = (vc_cmd_s*)vc_command;
338 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
341 iter = g_slist_find(list->list, cmd);
343 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy command : handle is not valid");
344 return VC_ERROR_INVALID_PARAMETER;
347 list->list = g_slist_remove_link(list->list, iter);
348 SLOG(LOG_DEBUG, TAG_VCCMD, "destroy command");
350 int len = g_slist_length(list->list);
353 else if (list->index == len)
354 list->index = len - 1;
356 return VC_ERROR_NONE;
359 static void __vc_cmd_list_remove_all_foreach(gpointer data)
361 vc_cmd_s *temp = (vc_cmd_s *)data;
363 SECURE_SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
364 vc_cmd_destroy((vc_cmd_h)temp);
368 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
370 if (0 != __vc_cmd_get_feature_enabled()) {
371 return VC_ERROR_NOT_SUPPORTED;
373 if (0 != __vc_cmd_check_privilege()) {
374 return VC_ERROR_PERMISSION_DENIED;
377 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Destroy all command");
379 if (NULL == vc_cmd_list) {
380 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
381 return VC_ERROR_INVALID_PARAMETER;
384 vc_cmd_list_s* cmd_list = (vc_cmd_list_s*)vc_cmd_list;
386 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
387 , cmd_list, release_command ? "true" : "false");
389 if (NULL == cmd_list->list) {
390 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ List is already empty.");
391 return VC_ERROR_NONE;
394 if (true == release_command) {
395 g_slist_free_full(cmd_list->list, __vc_cmd_list_remove_all_foreach);
397 g_slist_free(cmd_list->list);
400 cmd_list->list = NULL;
401 cmd_list->index = -1;
403 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
405 return VC_ERROR_NONE;
408 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
410 if (0 != __vc_cmd_get_feature_enabled()) {
411 return VC_ERROR_NOT_SUPPORTED;
413 if (0 != __vc_cmd_check_privilege()) {
414 return VC_ERROR_PERMISSION_DENIED;
417 if (NULL == vc_cmd_list || NULL == callback) {
418 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
419 return VC_ERROR_INVALID_PARAMETER;
422 vc_cmd_list_s* list = NULL;
423 list = (vc_cmd_list_s*)vc_cmd_list;
426 iter = g_slist_nth(list->list, 0);
427 while (NULL != iter) {
428 vc_cmd_s *temp_cmd = NULL;
429 temp_cmd = iter->data;
430 if (NULL == temp_cmd) {
431 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
432 return VC_ERROR_OPERATION_FAILED;
434 if (false == callback((vc_cmd_h)temp_cmd, user_data))
437 iter = g_slist_next(iter);
440 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Foreach commands Done");
442 return VC_ERROR_NONE;
445 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
447 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Filter by type");
449 if (0 != __vc_cmd_get_feature_enabled()) {
450 return VC_ERROR_NOT_SUPPORTED;
452 if (0 != __vc_cmd_check_privilege()) {
453 return VC_ERROR_PERMISSION_DENIED;
456 if (NULL == original || NULL == filtered) {
457 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
458 return VC_ERROR_INVALID_PARAMETER;
461 if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
462 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
463 return VC_ERROR_INVALID_PARAMETER;
466 vc_cmd_list_s* list = NULL;
467 list = (vc_cmd_list_s*)original;
469 vc_cmd_list_h temp_list;
470 if (0 != vc_cmd_list_create(&temp_list)) {
471 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
472 return VC_ERROR_OPERATION_FAILED;
476 iter = g_slist_nth(list->list, 0);
477 while (NULL != iter) {
478 vc_cmd_s *iter_cmd = NULL;
479 iter_cmd = iter->data;
480 if (NULL == iter_cmd) {
481 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
482 return VC_ERROR_OPERATION_FAILED;
486 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
487 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
491 if (iter_type == type) {
493 if (0 != vc_cmd_create(&temp_cmd)) {
494 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
498 memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
499 if (NULL != iter_cmd->command)
500 ((vc_cmd_s *)temp_cmd)->command = strdup(iter_cmd->command);
501 if (NULL != iter_cmd->parameter)
502 ((vc_cmd_s *)temp_cmd)->parameter = strdup(iter_cmd->parameter);
504 if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
505 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
506 vc_cmd_destroy(temp_cmd);
510 iter = g_slist_next(iter);
514 if (0 != vc_cmd_list_get_count(temp_list, &count)) {
515 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
517 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
520 *filtered = temp_list;
522 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
524 return VC_ERROR_NONE;
527 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
529 if (0 != __vc_cmd_get_feature_enabled()) {
530 return VC_ERROR_NOT_SUPPORTED;
532 if (0 != __vc_cmd_check_privilege()) {
533 return VC_ERROR_PERMISSION_DENIED;
536 if (NULL == vc_cmd_list) {
537 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
538 return VC_ERROR_INVALID_PARAMETER;
541 vc_cmd_list_s* list = NULL;
542 list = (vc_cmd_list_s*)vc_cmd_list;
544 if (0 == g_slist_length(list->list)) {
545 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
546 return VC_ERROR_EMPTY;
551 return VC_ERROR_NONE;
554 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
556 if (0 != __vc_cmd_get_feature_enabled()) {
557 return VC_ERROR_NOT_SUPPORTED;
559 if (0 != __vc_cmd_check_privilege()) {
560 return VC_ERROR_PERMISSION_DENIED;
563 if (NULL == vc_cmd_list) {
564 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
565 return VC_ERROR_INVALID_PARAMETER;
568 vc_cmd_list_s* list = NULL;
569 list = (vc_cmd_list_s*)vc_cmd_list;
571 int count = g_slist_length(list->list);
574 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
575 return VC_ERROR_EMPTY;
577 list->index = count - 1;
578 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
581 return VC_ERROR_NONE;
584 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
586 if (0 != __vc_cmd_get_feature_enabled()) {
587 return VC_ERROR_NOT_SUPPORTED;
589 if (0 != __vc_cmd_check_privilege()) {
590 return VC_ERROR_PERMISSION_DENIED;
593 if (NULL == vc_cmd_list) {
594 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
595 return VC_ERROR_INVALID_PARAMETER;
598 vc_cmd_list_s* list = NULL;
599 list = (vc_cmd_list_s*)vc_cmd_list;
601 int count = g_slist_length(list->list);
603 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
604 return VC_ERROR_EMPTY;
607 if (list->index < count - 1) {
608 list->index = list->index + 1;
609 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
611 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
612 return VC_ERROR_ITERATION_END;
615 return VC_ERROR_NONE;
618 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
620 if (0 != __vc_cmd_get_feature_enabled()) {
621 return VC_ERROR_NOT_SUPPORTED;
623 if (0 != __vc_cmd_check_privilege()) {
624 return VC_ERROR_PERMISSION_DENIED;
627 if (NULL == vc_cmd_list) {
628 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
629 return VC_ERROR_INVALID_PARAMETER;
632 vc_cmd_list_s* list = NULL;
633 list = (vc_cmd_list_s*)vc_cmd_list;
635 if (0 == g_slist_length(list->list)) {
636 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
637 return VC_ERROR_EMPTY;
640 if (list->index > 0) {
641 list->index = list->index - 1;
642 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
644 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
645 return VC_ERROR_ITERATION_END;
648 return VC_ERROR_NONE;
651 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
653 if (0 != __vc_cmd_get_feature_enabled()) {
654 return VC_ERROR_NOT_SUPPORTED;
656 if (0 != __vc_cmd_check_privilege()) {
657 return VC_ERROR_PERMISSION_DENIED;
660 if (NULL == vc_cmd_list || NULL == vc_command) {
661 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
662 return VC_ERROR_INVALID_PARAMETER;
665 vc_cmd_list_s* list = NULL;
666 list = (vc_cmd_list_s*)vc_cmd_list;
668 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
670 if (0 == g_slist_length(list->list)) {
671 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
673 return VC_ERROR_EMPTY;
676 vc_cmd_s *temp_cmd = NULL;
677 temp_cmd = g_slist_nth_data(list->list, list->index);
679 *vc_command = (vc_cmd_h)temp_cmd;
681 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
683 return VC_ERROR_NONE;
687 int vc_cmd_create(vc_cmd_h* vc_command)
689 if (0 != __vc_cmd_get_feature_enabled()) {
690 return VC_ERROR_NOT_SUPPORTED;
692 if (0 != __vc_cmd_check_privilege()) {
693 return VC_ERROR_PERMISSION_DENIED;
698 if (NULL == vc_command) {
699 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
701 return VC_ERROR_INVALID_PARAMETER;
704 vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
706 if (NULL == command) {
707 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
709 return VC_ERROR_OUT_OF_MEMORY;
715 command->type = VC_COMMAND_TYPE_NONE;
716 command->format = VC_CMD_FORMAT_FIXED;
717 command->command = NULL;
718 command->parameter = NULL;
720 command->priority = 0;
721 command->key = VC_KEY_NONE;
722 command->modifier = VC_MODIFIER_NONE;
723 command->invocation_name = NULL;
724 command->appid = NULL;
725 command->fixed = NULL;
726 command->coordinates = NULL;
728 *vc_command = (vc_cmd_h)command;
730 g_cmd_list = g_list_append(g_cmd_list, command);
732 SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
735 return VC_ERROR_NONE;
738 int vc_cmd_destroy(vc_cmd_h vc_command)
740 if (0 != __vc_cmd_get_feature_enabled()) {
741 return VC_ERROR_NOT_SUPPORTED;
743 if (0 != __vc_cmd_check_privilege()) {
744 return VC_ERROR_PERMISSION_DENIED;
749 if (NULL == vc_command) {
750 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
752 return VC_ERROR_INVALID_PARAMETER;
755 vc_cmd_s* command = NULL;
756 command = (vc_cmd_s*)vc_command;
758 SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
761 iter = g_list_find(g_cmd_list, command);
763 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to command destroy : handle is not valid");
765 return VC_ERROR_INVALID_PARAMETER;
768 g_cmd_list = g_list_delete_link(g_cmd_list, iter);
770 if (command->command)
771 free(command->command);
772 command->command = NULL;
773 if (command->parameter)
774 free(command->parameter);
775 command->parameter = NULL;
776 if (command->invocation_name)
777 free(command->invocation_name);
778 command->invocation_name = NULL;
780 free(command->appid);
781 command->appid = NULL;
783 free(command->fixed);
784 command->fixed = NULL;
785 if (command->coordinates)
786 free(command->coordinates);
787 command->coordinates = NULL;
792 return VC_ERROR_NONE;
795 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
797 if (0 != __vc_cmd_get_feature_enabled()) {
798 return VC_ERROR_NOT_SUPPORTED;
800 if (0 != __vc_cmd_check_privilege()) {
801 return VC_ERROR_PERMISSION_DENIED;
804 if (NULL == vc_command) {
805 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
806 return VC_ERROR_INVALID_PARAMETER;
809 vc_cmd_s* cmd = NULL;
810 cmd = (vc_cmd_s*)vc_command;
813 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
815 return VC_ERROR_NONE;
819 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
821 if (0 != __vc_cmd_get_feature_enabled()) {
822 return VC_ERROR_NOT_SUPPORTED;
824 if (0 != __vc_cmd_check_privilege()) {
825 return VC_ERROR_PERMISSION_DENIED;
828 if (NULL == vc_command || NULL == id) {
829 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
830 return VC_ERROR_INVALID_PARAMETER;
833 vc_cmd_s* cmd = NULL;
834 cmd = (vc_cmd_s*)vc_command;
837 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
839 return VC_ERROR_NONE;
843 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
845 if (0 != __vc_cmd_get_feature_enabled()) {
846 return VC_ERROR_NOT_SUPPORTED;
849 if (NULL == vc_command) {
850 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
851 return VC_ERROR_INVALID_PARAMETER;
855 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
856 return VC_ERROR_INVALID_PARAMETER;
859 vc_cmd_s* cmd = NULL;
860 cmd = (vc_cmd_s*)vc_command;
865 cmd->appid = strdup(appid);
867 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
868 return VC_ERROR_NONE;
871 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
873 if (0 != __vc_cmd_get_feature_enabled()) {
874 return VC_ERROR_NOT_SUPPORTED;
877 if (NULL == vc_command || NULL == appid) {
878 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
879 return VC_ERROR_INVALID_PARAMETER;
882 vc_cmd_s* cmd = NULL;
883 cmd = (vc_cmd_s*)vc_command;
886 *appid = strdup(gettext(cmd->appid));
890 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
892 return VC_ERROR_NONE;
895 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
897 if (0 != __vc_cmd_get_feature_enabled()) {
898 return VC_ERROR_NOT_SUPPORTED;
900 if (0 != __vc_cmd_check_privilege()) {
901 return VC_ERROR_PERMISSION_DENIED;
904 if (NULL == vc_command || NULL == command) {
905 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
906 return VC_ERROR_INVALID_PARAMETER;
909 vc_cmd_s* cmd = NULL;
910 cmd = (vc_cmd_s*)vc_command;
915 cmd->command = strdup(command);
917 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
919 return VC_ERROR_NONE;
922 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
924 if (0 != __vc_cmd_get_feature_enabled()) {
925 return VC_ERROR_NOT_SUPPORTED;
927 if (0 != __vc_cmd_check_privilege()) {
928 return VC_ERROR_PERMISSION_DENIED;
931 if (NULL == vc_command || NULL == command) {
932 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
933 return VC_ERROR_INVALID_PARAMETER;
936 vc_cmd_s* cmd = NULL;
937 cmd = (vc_cmd_s*)vc_command;
940 *command = strdup(gettext(cmd->command));
944 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
946 return VC_ERROR_NONE;
949 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
951 if (0 != __vc_cmd_get_feature_enabled()) {
952 return VC_ERROR_NOT_SUPPORTED;
954 if (0 != __vc_cmd_check_privilege()) {
955 return VC_ERROR_PERMISSION_DENIED;
958 if (NULL == vc_command || NULL == command) {
959 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
960 return VC_ERROR_INVALID_PARAMETER;
963 vc_cmd_s* cmd = NULL;
964 cmd = (vc_cmd_s*)vc_command;
967 free(cmd->parameter);
968 cmd->parameter = NULL;
969 cmd->parameter = strdup(command);
970 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
972 return VC_ERROR_NONE;
975 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
977 if (0 != __vc_cmd_get_feature_enabled()) {
978 return VC_ERROR_NOT_SUPPORTED;
981 if (NULL == vc_command || NULL == command) {
982 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
983 return VC_ERROR_INVALID_PARAMETER;
986 vc_cmd_s* cmd = NULL;
987 cmd = (vc_cmd_s*)vc_command;
990 *command = strdup(gettext(cmd->parameter));
994 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
996 return VC_ERROR_NONE;
1000 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
1002 if (0 != __vc_cmd_get_feature_enabled()) {
1003 return VC_ERROR_NOT_SUPPORTED;
1006 if (NULL == vc_command) {
1007 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1008 return VC_ERROR_INVALID_PARAMETER;
1011 if (NULL == fixed) {
1012 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
1013 return VC_ERROR_INVALID_PARAMETER;
1016 vc_cmd_s* cmd = NULL;
1017 cmd = (vc_cmd_s*)vc_command;
1022 cmd->fixed = strdup(fixed);
1024 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
1025 return VC_ERROR_NONE;
1028 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
1030 if (0 != __vc_cmd_get_feature_enabled()) {
1031 return VC_ERROR_NOT_SUPPORTED;
1034 if (NULL == vc_command || NULL == fixed) {
1035 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1036 return VC_ERROR_INVALID_PARAMETER;
1039 vc_cmd_s* cmd = NULL;
1040 cmd = (vc_cmd_s*)vc_command;
1043 *fixed = strdup(gettext(cmd->fixed));
1047 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1049 return VC_ERROR_NONE;
1053 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1055 if (0 != __vc_cmd_get_feature_enabled()) {
1056 return VC_ERROR_NOT_SUPPORTED;
1059 if (NULL == vc_command) {
1060 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1061 return VC_ERROR_INVALID_PARAMETER;
1064 if (NULL == invocation_name) {
1065 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1066 return VC_ERROR_INVALID_PARAMETER;
1069 vc_cmd_s* cmd = NULL;
1070 cmd = (vc_cmd_s*)vc_command;
1072 if (cmd->invocation_name)
1073 free(cmd->invocation_name);
1074 cmd->invocation_name = NULL;
1075 cmd->invocation_name = strdup(invocation_name);
1077 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1078 return VC_ERROR_NONE;
1082 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1084 if (0 != __vc_cmd_get_feature_enabled()) {
1085 return VC_ERROR_NOT_SUPPORTED;
1088 if (NULL == vc_command || NULL == invocation_name) {
1089 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1090 return VC_ERROR_INVALID_PARAMETER;
1093 vc_cmd_s* cmd = NULL;
1094 cmd = (vc_cmd_s*)vc_command;
1096 if (cmd->invocation_name)
1097 *invocation_name = strdup(gettext(cmd->invocation_name));
1099 *invocation_name = NULL;
1101 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1102 return VC_ERROR_NONE;
1106 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1108 if (0 != __vc_cmd_get_feature_enabled()) {
1109 return VC_ERROR_NOT_SUPPORTED;
1111 if (0 != __vc_cmd_check_privilege()) {
1112 return VC_ERROR_PERMISSION_DENIED;
1115 if (NULL == vc_command) {
1116 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1117 return VC_ERROR_INVALID_PARAMETER;
1120 if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
1121 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type(%d)", type);
1122 return VC_ERROR_INVALID_PARAMETER;
1125 vc_cmd_s* cmd = NULL;
1126 cmd = (vc_cmd_s*)vc_command;
1130 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1132 return VC_ERROR_NONE;
1135 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1137 if (0 != __vc_cmd_get_feature_enabled()) {
1138 return VC_ERROR_NOT_SUPPORTED;
1140 if (0 != __vc_cmd_check_privilege()) {
1141 return VC_ERROR_PERMISSION_DENIED;
1144 if (NULL == vc_command || NULL == type) {
1145 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1146 return VC_ERROR_INVALID_PARAMETER;
1149 vc_cmd_s* cmd = NULL;
1150 cmd = (vc_cmd_s*)vc_command;
1154 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1156 return VC_ERROR_NONE;
1159 int vc_cmd_set_format(vc_cmd_h vc_command, int format)
1161 if (0 != __vc_cmd_get_feature_enabled()) {
1162 return VC_ERROR_NOT_SUPPORTED;
1165 if (NULL == vc_command) {
1166 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1167 return VC_ERROR_INVALID_PARAMETER;
1170 if (VC_COMMAND_FORMAT_FIXED > format || VC_COMMAND_FORMAT_NONFIXED_AND_FIXED < format) {
1171 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid format(%d)", format);
1172 return VC_ERROR_INVALID_PARAMETER;
1175 vc_cmd_s* cmd = NULL;
1176 cmd = (vc_cmd_s*)vc_command;
1178 cmd->format = format;
1180 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1182 return VC_ERROR_NONE;
1185 int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
1187 if (0 != __vc_cmd_get_feature_enabled()) {
1188 return VC_ERROR_NOT_SUPPORTED;
1191 if (NULL == vc_command || NULL == format) {
1192 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1193 return VC_ERROR_INVALID_PARAMETER;
1196 vc_cmd_s* cmd = NULL;
1197 cmd = (vc_cmd_s*)vc_command;
1199 *format = cmd->format;
1201 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1203 return VC_ERROR_NONE;
1206 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1208 if (0 != __vc_cmd_get_feature_enabled()) {
1209 return VC_ERROR_NOT_SUPPORTED;
1211 if (0 != __vc_cmd_check_privilege()) {
1212 return VC_ERROR_PERMISSION_DENIED;
1215 if (NULL == vc_command) {
1216 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1217 return VC_ERROR_INVALID_PARAMETER;
1221 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid pid (%d)", pid);
1222 return VC_ERROR_INVALID_PARAMETER;
1225 vc_cmd_s* cmd = NULL;
1226 cmd = (vc_cmd_s*)vc_command;
1230 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1232 return VC_ERROR_NONE;
1235 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1237 if (0 != __vc_cmd_get_feature_enabled()) {
1238 return VC_ERROR_NOT_SUPPORTED;
1240 if (0 != __vc_cmd_check_privilege()) {
1241 return VC_ERROR_PERMISSION_DENIED;
1244 if (NULL == vc_command || NULL == pid) {
1245 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1246 return VC_ERROR_INVALID_PARAMETER;
1249 vc_cmd_s* cmd = NULL;
1250 cmd = (vc_cmd_s*)vc_command;
1254 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1256 return VC_ERROR_NONE;
1259 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1261 if (0 != __vc_cmd_get_feature_enabled()) {
1262 return VC_ERROR_NOT_SUPPORTED;
1264 if (0 != __vc_cmd_check_privilege()) {
1265 return VC_ERROR_PERMISSION_DENIED;
1268 if (NULL == vc_command) {
1269 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1270 return VC_ERROR_INVALID_PARAMETER;
1273 vc_cmd_s* cmd = NULL;
1274 cmd = (vc_cmd_s*)vc_command;
1276 cmd->domain = domain;
1278 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1280 return VC_ERROR_NONE;
1283 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1285 if (0 != __vc_cmd_get_feature_enabled()) {
1286 return VC_ERROR_NOT_SUPPORTED;
1288 if (0 != __vc_cmd_check_privilege()) {
1289 return VC_ERROR_PERMISSION_DENIED;
1292 if (NULL == vc_command || NULL == domain) {
1293 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1294 return VC_ERROR_INVALID_PARAMETER;
1297 vc_cmd_s* cmd = NULL;
1298 cmd = (vc_cmd_s*)vc_command;
1300 *domain = cmd->domain;
1302 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1304 return VC_ERROR_NONE;
1309 * @brief Sets key value of command.
1311 * @param[in] vc_command Command handle
1312 * @param[in] key key value
1313 * @param[in] modifier modifier value
1315 * @return 0 on success, otherwise a negative error value
1316 * @retval #VC_ERROR_NONE Successful
1317 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1319 * @see vc_cmd_get_result_key()
1321 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1323 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Set result key");
1325 if (NULL == vc_command) {
1326 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1327 return VC_ERROR_INVALID_PARAMETER;
1330 vc_cmd_s* cmd = NULL;
1331 cmd = (vc_cmd_s*)vc_command;
1333 SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1336 cmd->modifier = modifier;
1338 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1340 return VC_ERROR_NONE;
1344 * @brief Gets key value of command.
1346 * @param[in] vc_command Command handle
1347 * @param[out] key key value
1348 * @param[out] modifier modifier value
1350 * @return 0 on success, otherwise a negative error value
1351 * @retval #VC_ERROR_NONE Successful
1352 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1354 * @see vc_cmd_add_result_key()
1356 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1358 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get result key");
1360 if (NULL == vc_command || NULL == key || NULL == modifier) {
1361 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1362 return VC_ERROR_INVALID_PARAMETER;
1365 vc_cmd_s* cmd = NULL;
1366 cmd = (vc_cmd_s*)vc_command;
1369 *modifier = cmd->modifier;
1371 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1373 return VC_ERROR_NONE;
1376 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1378 if (NULL == vc_cmd_list) {
1382 vc_cmd_list_s* list = NULL;
1383 list = (vc_cmd_list_s*)vc_cmd_list;
1385 SLOG(LOG_DEBUG, TAG_VCCMD, "@ Command List @");
1386 SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1389 GSList *iter = NULL;
1390 iter = g_slist_nth(list->list, 0);
1391 while (NULL != iter) {
1392 vc_cmd_s *cmd = NULL;
1395 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
1396 return VC_ERROR_OPERATION_FAILED;
1398 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)",
1399 i++, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1401 iter = g_slist_next(iter);
1404 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1406 return VC_ERROR_NONE;
1409 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1411 if (0 != __vc_cmd_get_feature_enabled()) {
1412 return VC_ERROR_NOT_SUPPORTED;
1415 if (NULL == vc_cmd || NULL == json) {
1416 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1417 return VC_ERROR_INVALID_PARAMETER;
1420 vc_cmd_s* cmd = NULL;
1421 cmd = (vc_cmd_s*)vc_cmd;
1423 if (VC_CMD_FORMAT_ACTION != cmd->format) {
1424 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1425 return VC_ERROR_INVALID_PARAMETER;
1428 if (0 != vc_info_parser_get_nlu_result(json)) {
1429 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1430 return VC_ERROR_OPERATION_FAILED;
1433 return VC_ERROR_NONE;
1436 static void __vc_cmd_regex_deinit(int num_regex)
1438 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start Deinitialize regex @@@");
1441 for (i = 0; num_regex > i; i++) {
1445 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1448 static int __vc_cmd_regex_init()
1450 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Initialize regular expression @@@");
1452 int cflags = REG_EXTENDED | REG_ICASE;
1458 vc_config_mgr_get_default_language(&lang);
1460 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1461 return VC_ERROR_OPERATION_FAILED;
1464 if (!strcmp("en_US", lang)) {
1466 } else if (!strcmp("ko_KR", lang)) {
1472 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1473 return VC_ERROR_INVALID_LANGUAGE;
1479 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ lang type > %d @@@", lang_type);
1481 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1483 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1484 ret = regcomp(®[0], TIME_ABS1_REGEX[lang_type], cflags);
1486 regerror(ret, ®[0], errStr, sizeof(errStr));
1488 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1489 return VC_ERROR_OPERATION_FAILED;
1492 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1493 ret = regcomp(®[1], TIME_ABS2_REGEX[lang_type], cflags);
1495 regerror(ret, ®[1], errStr, sizeof(errStr));
1496 __vc_cmd_regex_deinit(1);
1498 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1499 return VC_ERROR_OPERATION_FAILED;
1502 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1503 ret = regcomp(®[2], TIME_ABS3_REGEX[lang_type], cflags);
1505 regerror(ret, ®[2], errStr, sizeof(errStr));
1506 __vc_cmd_regex_deinit(2);
1508 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1509 return VC_ERROR_OPERATION_FAILED;
1512 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1513 ret = regcomp(®[3], TIME_REL1_REGEX[lang_type], cflags);
1515 regerror(ret, ®[3], errStr, sizeof(errStr));
1516 __vc_cmd_regex_deinit(3);
1518 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1519 return VC_ERROR_OPERATION_FAILED;
1522 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1523 ret = regcomp(®[4], TIME_REL2_REGEX[lang_type], cflags);
1525 regerror(ret, ®[4], errStr, sizeof(errStr));
1526 __vc_cmd_regex_deinit(4);
1528 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1529 return VC_ERROR_OPERATION_FAILED;
1532 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1533 ret = regcomp(®[5], TIME_REL3_REGEX[lang_type], cflags);
1535 regerror(ret, ®[5], errStr, sizeof(errStr));
1536 __vc_cmd_regex_deinit(5);
1538 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1539 return VC_ERROR_OPERATION_FAILED;
1542 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1543 ret = regcomp(®[6], TIME_PHR_REGEX[lang_type], cflags);
1545 regerror(ret, ®[6], errStr, sizeof(errStr));
1546 __vc_cmd_regex_deinit(6);
1548 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1549 return VC_ERROR_OPERATION_FAILED;
1552 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1553 ret = regcomp(®[7], DATE_ABS1_REGEX[lang_type], cflags);
1555 regerror(ret, ®[7], errStr, sizeof(errStr));
1556 __vc_cmd_regex_deinit(7);
1558 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1559 return VC_ERROR_OPERATION_FAILED;
1562 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1563 ret = regcomp(®[8], DATE_ABS2_REGEX[lang_type], cflags);
1565 regerror(ret, ®[8], errStr, sizeof(errStr));
1566 __vc_cmd_regex_deinit(8);
1568 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1569 return VC_ERROR_OPERATION_FAILED;
1572 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1573 ret = regcomp(®[9], DATE_ABS3_REGEX[lang_type], cflags);
1575 regerror(ret, ®[9], errStr, sizeof(errStr));
1576 __vc_cmd_regex_deinit(9);
1578 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1579 return VC_ERROR_OPERATION_FAILED;
1582 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1583 ret = regcomp(®[10], DATE_PHR1_REGEX[lang_type], cflags);
1585 regerror(ret, ®[10], errStr, sizeof(errStr));
1586 __vc_cmd_regex_deinit(10);
1588 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1589 return VC_ERROR_OPERATION_FAILED;
1592 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1593 ret = regcomp(®[11], DATE_PHR2_REGEX[lang_type], cflags);
1595 regerror(ret, ®[11], errStr, sizeof(errStr));
1596 __vc_cmd_regex_deinit(11);
1598 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1599 return VC_ERROR_OPERATION_FAILED;
1602 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1604 return VC_ERROR_NONE;
1607 static void __vc_cmd_add_year(struct tm *td, int year)
1609 td->tm_year += year;
1612 static void __vc_cmd_add_mon(struct tm *td, int mon)
1616 mon = td->tm_mon + mon;
1620 __vc_cmd_add_year(td, year);
1623 td->tm_mon = mon % 12;
1626 static void __vc_cmd_add_mday(struct tm *td, int mday)
1628 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1629 int year = td->tm_year + 1900;
1633 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1635 mday = td->tm_mday + mday;
1637 for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1638 mday -= max_day[mon % 12];
1640 if (11 == mon % 12) {
1643 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1651 mon = mon - td->tm_mon;
1654 __vc_cmd_add_mon(td, mon);
1660 static void __vc_cmd_add_hour(struct tm *td, int hour)
1664 hour = td->tm_hour + hour;
1668 __vc_cmd_add_mday(td, day);
1671 td->tm_hour = hour % 24;
1674 static void __vc_cmd_add_min(struct tm *td, int min)
1678 min = td->tm_min + min;
1682 __vc_cmd_add_hour(td, hour);
1685 td->tm_min = min % 60;
1688 static void __copy_struct_tm(struct tm *des, struct tm *src)
1690 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start to copy struct tm @@@");
1692 des->tm_sec = src->tm_sec;
1693 des->tm_min = src->tm_min;
1694 des->tm_hour = src->tm_hour;
1695 des->tm_mday = src->tm_mday;
1696 des->tm_mon = src->tm_mon;
1697 des->tm_year = src->tm_year;
1698 des->tm_wday = src->tm_wday;
1699 des->tm_yday = src->tm_yday;
1700 des->tm_isdst = src->tm_isdst;
1702 des->tm_gmtoff = src->tm_gmtoff;
1703 des->tm_zone = src->tm_zone;
1706 static void __update_data_sidx(int idx)
1708 if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1711 static void __update_data_eidx(int idx)
1713 if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1716 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1718 regmatch_t pmatch[3];
1724 ret = regexec(®[6], str, 3, pmatch, 0);
1727 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1729 if (12 < td->tm_hour) {
1730 __vc_cmd_add_mday(td, 1);
1736 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1738 __vc_cmd_add_mday(td, 1);
1743 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1745 __update_data_sidx(pmatch[0].rm_so);
1746 __update_data_eidx(pmatch[0].rm_eo);
1749 return VC_ERROR_NONE;
1752 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1753 return VC_ERROR_NONE;
1756 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1758 regmatch_t pmatch[2];
1767 ret = regexec(®[3], str, 1, pmatch, 0);
1769 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1772 sidx = pmatch[0].rm_so;
1773 eidx = pmatch[0].rm_eo;
1775 ret = regexec(®[4], str, 2, pmatch, 0);
1777 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1780 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1781 return VC_ERROR_OPERATION_FAILED;
1783 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1785 if (NULL == tempstr) {
1786 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1787 return VC_ERROR_OUT_OF_MEMORY;
1790 hour = atoi(tempstr);
1795 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1797 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1798 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1801 ret = regexec(®[5], str, 2, pmatch, 0);
1803 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1806 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1807 return VC_ERROR_OPERATION_FAILED;
1809 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1811 if (NULL == tempstr) {
1812 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1813 return VC_ERROR_OUT_OF_MEMORY;
1816 min = atoi(tempstr);
1821 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1823 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1824 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1827 if (hour < 0 && min < 0) {
1828 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1829 return VC_ERROR_NONE;
1832 hour = 0 > hour ? 0 : hour;
1833 min = 0 > min ? 0 : min;
1835 min = min + (hour * 60);
1837 __vc_cmd_add_min(td, min);
1840 __update_data_sidx(sidx);
1841 __update_data_eidx(eidx);
1844 return VC_ERROR_NONE;
1847 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1848 return VC_ERROR_NONE;
1851 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1853 regmatch_t pmatch[5];
1864 ret = regexec(®[0], str, 5, pmatch, 0);
1866 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1870 sidx = pmatch[0].rm_so;
1871 eidx = pmatch[0].rm_eo;
1874 ret = regexec(®[1], str, 2, pmatch, 0);
1876 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1879 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1880 return VC_ERROR_OPERATION_FAILED;
1882 char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1884 if (NULL == tempstr) {
1885 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1886 return VC_ERROR_OUT_OF_MEMORY;
1889 hour = atoi(tempstr);
1892 hour = hour + 12 * flag;
1894 if (12 == hour) hour = 0;
1895 else if (24 == hour) hour = 12;
1898 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1899 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1902 return VC_ERROR_NONE;
1908 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1910 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1911 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1912 } else if (0 < flag) {
1913 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1914 return VC_ERROR_NONE;
1917 ret = regexec(®[2], str, 2, pmatch, 0);
1920 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1922 char *tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
1924 if (NULL == tempstr) {
1925 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1926 return VC_ERROR_OUT_OF_MEMORY;
1929 min = atoi(tempstr);
1931 if (0 > min || 60 <= min) {
1932 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1935 return VC_ERROR_NONE;
1947 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1948 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1949 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1952 if (0 > hour && 0 > min) {
1953 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1954 return VC_ERROR_NONE;
1957 if (0 <= min && 0 <= hour) {
1958 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1962 } else if (0 <= min) {
1964 vc_config_mgr_get_default_language(&lang);
1966 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1967 return VC_ERROR_OPERATION_FAILED;
1970 if (!strcmp("en_US", lang)) {
1971 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
1974 return VC_ERROR_NONE;
1976 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1983 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1991 __update_data_sidx(sidx);
1992 __update_data_eidx(eidx);
1995 return VC_ERROR_NONE;
1998 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
2000 regmatch_t pmatch[10];
2006 ret = regexec(®[10], str, 5, pmatch, 0);
2008 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
2010 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2012 td->tm_year = td_now.tm_year;
2013 td->tm_mon = td_now.tm_mon;
2014 td->tm_mday = td_now.tm_mday;
2016 __vc_cmd_add_mday(td, idx - 1);
2018 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2020 __update_data_sidx(pmatch[0].rm_so);
2021 __update_data_eidx(pmatch[0].rm_eo);
2024 return VC_ERROR_NONE;
2027 ret = regexec(®[11], str, 10, pmatch, 0);
2029 for (idx = 1; 10 > idx; idx++) {
2030 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2035 td->tm_year = td_now.tm_year;
2036 td->tm_mon = td_now.tm_mon;
2037 td->tm_mday = td_now.tm_mday;
2039 __vc_cmd_add_mday(td, idx + 1);
2041 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2043 __update_data_sidx(pmatch[0].rm_so);
2044 __update_data_eidx(pmatch[0].rm_eo);
2047 return VC_ERROR_NONE;
2050 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
2051 return VC_ERROR_NONE;
2054 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
2056 regmatch_t pmatch[13];
2067 char *tempstr = NULL;
2070 ret = regexec(®[9], str, 2, pmatch, 0);
2072 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2075 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2076 return VC_ERROR_OPERATION_FAILED;
2078 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
2080 if (NULL == tempstr) {
2081 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2082 return VC_ERROR_OUT_OF_MEMORY;
2085 day = atoi(tempstr);
2090 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2092 sidx = pmatch[0].rm_so;
2093 eidx = pmatch[0].rm_eo;
2095 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2096 return VC_ERROR_NONE;
2099 ret = regexec(®[8], str, 13, pmatch, 0);
2101 for (idx = 1; 13 > idx; idx++) {
2102 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2112 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2114 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2115 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2118 vc_config_mgr_get_default_language(&lang);
2120 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2121 return VC_ERROR_OPERATION_FAILED;
2124 if (!strcmp("en_US", lang)) {
2125 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2128 return VC_ERROR_NONE;
2137 ret = regexec(®[7], str, 3, pmatch, 0);
2139 if (!m_flag) return -1;
2141 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2144 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2145 return VC_ERROR_OPERATION_FAILED;
2147 tempstr = strndup(str + pmatch[2].rm_so, (size_t)len);
2149 if (NULL == tempstr) {
2150 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2151 return VC_ERROR_OUT_OF_MEMORY;
2154 year = atoi(tempstr);
2155 year = 1900 < year ? year - 1900 : year + 100;
2161 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2163 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2164 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2169 if (0 > g_time_flag) {
2173 } else if (2 == g_time_flag) {
2174 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2175 return VC_ERROR_NONE;
2178 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2179 if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2181 if (max_day[mon] < day || 1 > day) {
2182 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incoming sentence is weird");
2183 return VC_ERROR_NONE;
2192 if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2194 if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2195 else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2199 __update_data_sidx(sidx);
2200 __update_data_eidx(eidx);
2203 return VC_ERROR_NONE;
2206 static int __vc_cmd_time_check(const char *str, struct tm *td)
2208 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check time value in string \"%s\"", str);
2213 ret = __vc_cmd_tphrase_check(str, td, &exist);
2217 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2219 } else if (VC_ERROR_NONE != ret) {
2220 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2224 ret = __vc_cmd_trelative_check(str, td, &exist);
2228 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2230 } else if (VC_ERROR_NONE != ret) {
2231 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2235 ret = __vc_cmd_tabsolute_check(str, td, &exist);
2239 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2241 } else if (VC_ERROR_NONE != ret) {
2242 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2246 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no time value");
2247 return VC_ERROR_NONE;
2250 static int __vc_cmd_date_check(const char *str, struct tm *td)
2252 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check date value in string \"%s\"", str);
2257 ret = __vc_cmd_dphrase_check(str, td, &exist);
2261 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2263 } else if (VC_ERROR_NONE != ret) {
2264 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2268 ret = __vc_cmd_dabsolute_check(str, td, &exist);
2272 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2274 } else if (VC_ERROR_NONE != ret) {
2275 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred > (%d)", ret);
2279 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no date value");
2280 return VC_ERROR_NONE;
2283 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2285 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get timestamp data");
2288 const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2291 if (NULL == text || NULL == result || NULL == remain) {
2292 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2293 return VC_ERROR_INVALID_PARAMETER;
2297 ret = __vc_cmd_regex_init();
2298 if (VC_ERROR_NONE != ret) {
2299 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2303 g_data_sidx = g_data_eidx = -1;
2306 localtime_r(&t_now, &td_now);
2307 SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2309 __copy_struct_tm(&td, &td_now);
2310 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2311 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);
2313 g_time_flag = g_date_flag = -1;
2315 ret = __vc_cmd_time_check(text, &td);
2316 if (VC_ERROR_NONE != ret) {
2317 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2321 ret = __vc_cmd_date_check(text, &td);
2322 if (VC_ERROR_NONE != ret) {
2323 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occurred in the check > (%d)", ret);
2327 __vc_cmd_regex_deinit(12);
2329 if (g_time_flag > 0 || g_date_flag > 0) {
2330 *result = mktime(&td);
2332 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %ld", *result);
2333 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2334 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);
2336 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2338 if (NULL == *remain) {
2339 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2340 return VC_ERROR_OUT_OF_MEMORY;
2343 strncpy(*remain, text, g_data_sidx);
2344 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2346 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2349 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
2351 return VC_ERROR_NONE;