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 int g_feature_enabled = -1;
38 static int g_privilege_allowed = 1; /* Always True */
39 static cynara *p_cynara = NULL;
41 // For getting timestamp using regular expression
42 static regex_t reg[MAX_NUM_REGEX];
43 static time_t t_now; //time_t is based on UTC
44 static struct tm td_now; //if use localtime function, the value follows the local time zone, otherwise it follows the UTC.
46 static int g_time_flag;
47 static int g_date_flag;
49 static int g_data_sidx;
50 static int g_data_eidx;
52 static int __vc_cmd_get_feature_enabled()
54 if (0 == g_feature_enabled) {
55 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
56 return VC_ERROR_NOT_SUPPORTED;
57 } else if (-1 == g_feature_enabled) {
58 bool vc_supported = false;
59 bool mic_supported = false;
60 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
61 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
62 if (false == vc_supported || false == mic_supported) {
63 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
64 g_feature_enabled = 0;
65 return VC_ERROR_NOT_SUPPORTED;
68 g_feature_enabled = 1;
70 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
71 return VC_ERROR_NOT_SUPPORTED;
74 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
75 return VC_ERROR_NOT_SUPPORTED;
82 static int __check_privilege_initialize()
84 int ret = cynara_initialize(&p_cynara, NULL);
85 if (CYNARA_API_SUCCESS != ret)
86 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
88 return ret == CYNARA_API_SUCCESS;
91 static int __check_privilege(const char* uid, const char * privilege)
94 char label_path[1024] = "/proc/self/attr/current";
95 char smack_label[1024] = {'\0',};
101 fp = fopen(label_path, "r");
103 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
104 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
109 pid_t pid = getpid();
110 char *session = cynara_session_from_pid(pid);
111 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
112 SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
116 if (ret != CYNARA_API_ACCESS_ALLOWED)
121 static void __check_privilege_deinitialize()
124 cynara_finish(p_cynara);
128 static int __vc_cmd_check_privilege()
132 if (0 == g_privilege_allowed) {
133 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
134 return VC_ERROR_PERMISSION_DENIED;
135 } else if (-1 == g_privilege_allowed) {
136 if (false == __check_privilege_initialize()) {
137 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
138 return VC_ERROR_PERMISSION_DENIED;
140 snprintf(uid, 16, "%d", getuid());
141 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
142 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
143 g_privilege_allowed = 0;
144 __check_privilege_deinitialize();
145 return VC_ERROR_PERMISSION_DENIED;
147 __check_privilege_deinitialize();
150 g_privilege_allowed = 1;
152 return VC_ERROR_NONE;
155 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
157 if (0 != __vc_cmd_get_feature_enabled()) {
158 return VC_ERROR_NOT_SUPPORTED;
160 if (0 != __vc_cmd_check_privilege()) {
161 return VC_ERROR_PERMISSION_DENIED;
164 if (NULL == vc_cmd_list) {
165 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
166 return VC_ERROR_INVALID_PARAMETER;
169 vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
172 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
173 return VC_ERROR_OUT_OF_MEMORY;
179 *vc_cmd_list = (vc_cmd_list_h)list;
181 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
183 return VC_ERROR_NONE;
186 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
188 if (0 != __vc_cmd_get_feature_enabled()) {
189 return VC_ERROR_NOT_SUPPORTED;
191 if (0 != __vc_cmd_check_privilege()) {
192 return VC_ERROR_PERMISSION_DENIED;
195 if (NULL == vc_cmd_list) {
196 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
197 return VC_ERROR_INVALID_PARAMETER;
200 vc_cmd_list_remove_all(vc_cmd_list, release_command);
202 vc_cmd_list_s* list = NULL;
203 list = (vc_cmd_list_s*)vc_cmd_list;
205 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
212 return VC_ERROR_NONE;
215 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
217 if (0 != __vc_cmd_get_feature_enabled()) {
218 return VC_ERROR_NOT_SUPPORTED;
220 if (0 != __vc_cmd_check_privilege()) {
221 return VC_ERROR_PERMISSION_DENIED;
224 if (NULL == vc_cmd_list || NULL == count) {
225 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
226 return VC_ERROR_INVALID_PARAMETER;
229 vc_cmd_list_s* list = NULL;
230 list = (vc_cmd_list_s*)vc_cmd_list;
232 *count = g_slist_length(list->list);
234 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
236 return VC_ERROR_NONE;
239 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
241 if (0 != __vc_cmd_get_feature_enabled()) {
242 return VC_ERROR_NOT_SUPPORTED;
244 if (0 != __vc_cmd_check_privilege()) {
245 return VC_ERROR_PERMISSION_DENIED;
248 if (NULL == vc_cmd_list || NULL == vc_command) {
249 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
250 return VC_ERROR_INVALID_PARAMETER;
253 vc_cmd_list_s* list = NULL;
254 list = (vc_cmd_list_s*)vc_cmd_list;
256 vc_cmd_s* cmd = NULL;
257 cmd = (vc_cmd_s*)vc_command;
259 list->list = g_slist_append(list->list, cmd);
261 if (1 == g_slist_length(list->list)) {
265 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
267 return VC_ERROR_NONE;
270 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
272 if (0 != __vc_cmd_get_feature_enabled()) {
273 return VC_ERROR_NOT_SUPPORTED;
275 if (0 != __vc_cmd_check_privilege()) {
276 return VC_ERROR_PERMISSION_DENIED;
279 if (NULL == vc_cmd_list || NULL == vc_command) {
280 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
281 return VC_ERROR_INVALID_PARAMETER;
284 vc_cmd_list_s* list = NULL;
285 list = (vc_cmd_list_s*)vc_cmd_list;
287 vc_cmd_s* cmd = NULL;
288 cmd = (vc_cmd_s*)vc_command;
290 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
292 vc_cmd_s* temp_cmd = NULL;
295 iter = g_slist_nth(list->list, 0);
297 while (NULL != iter) {
298 temp_cmd = iter->data;
300 if (NULL != temp_cmd && cmd == temp_cmd) {
301 list->list = g_slist_remove(list->list, temp_cmd);
303 if (true == release_command) {
304 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
305 if (NULL != temp_cmd->command) free(temp_cmd->command);
306 if (NULL != temp_cmd->parameter) free(temp_cmd->parameter);
313 iter = g_slist_next(iter);
316 int count = g_slist_length(list->list);
320 } else if (list->index == count) {
321 list->index = count - 1;
324 return VC_ERROR_NONE;
327 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
329 if (0 != __vc_cmd_get_feature_enabled()) {
330 return VC_ERROR_NOT_SUPPORTED;
332 if (0 != __vc_cmd_check_privilege()) {
333 return VC_ERROR_PERMISSION_DENIED;
336 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Destroy all command");
338 if (NULL == vc_cmd_list) {
339 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
340 return VC_ERROR_INVALID_PARAMETER;
343 vc_cmd_list_s* list = NULL;
344 list = (vc_cmd_list_s*)vc_cmd_list;
346 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
347 , list, release_command ? "true" : "false");
349 int count = g_slist_length(list->list);
354 for (i = 0; i < count ; i++) {
355 temp_cmd = g_slist_nth_data(list->list, 0);
357 if (NULL != temp_cmd) {
358 list->list = g_slist_remove(list->list, temp_cmd);
360 if (true == release_command) {
361 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
362 if (NULL != temp_cmd->command) free(temp_cmd->command);
363 if (NULL != temp_cmd->parameter) free(temp_cmd->parameter);
372 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
373 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
375 return VC_ERROR_NONE;
378 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
380 if (0 != __vc_cmd_get_feature_enabled()) {
381 return VC_ERROR_NOT_SUPPORTED;
383 if (0 != __vc_cmd_check_privilege()) {
384 return VC_ERROR_PERMISSION_DENIED;
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* list = NULL;
393 list = (vc_cmd_list_s*)vc_cmd_list;
395 int count = g_slist_length(list->list);
401 iter = g_slist_nth(list->list, 0);
403 for (i = 0; i < count; i++) {
405 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
406 return VC_ERROR_OPERATION_FAILED;
409 temp_cmd = iter->data;
411 if (NULL != temp_cmd) {
412 if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
417 iter = g_slist_next(iter);
420 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Foreach commands Done");
422 return VC_ERROR_NONE;
425 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
427 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Filter by type");
429 if (0 != __vc_cmd_get_feature_enabled()) {
430 return VC_ERROR_NOT_SUPPORTED;
432 if (0 != __vc_cmd_check_privilege()) {
433 return VC_ERROR_PERMISSION_DENIED;
436 if (NULL == original) {
437 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
438 return VC_ERROR_INVALID_PARAMETER;
441 if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
442 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
443 return VC_ERROR_INVALID_PARAMETER;
446 vc_cmd_list_s* list = NULL;
447 list = (vc_cmd_list_s*)original;
449 vc_cmd_list_h temp_list;
450 if (0 != vc_cmd_list_create(&temp_list)) {
451 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
452 return VC_ERROR_OPERATION_FAILED;
455 int count = g_slist_length(list->list);
461 iter = g_slist_nth(list->list, 0);
463 for (i = 0; i < count; i++) {
465 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
466 return VC_ERROR_OPERATION_FAILED;
468 if (NULL != iter->data) {
469 iter_cmd = iter->data;
471 if (NULL != iter_cmd) {
473 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
474 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
478 if (iter_type == type) {
480 if (0 != vc_cmd_create(&temp_cmd)) {
481 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
485 memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
486 if (NULL != iter_cmd->command) {
487 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
489 if (NULL != iter_cmd->parameter) {
490 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
493 if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
494 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
495 vc_cmd_destroy(temp_cmd);
501 iter = g_slist_next(iter);
505 if (0 != vc_cmd_list_get_count(temp_list, &count)) {
506 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
508 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
511 *filtered = temp_list;
513 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
515 return VC_ERROR_NONE;
518 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
520 if (0 != __vc_cmd_get_feature_enabled()) {
521 return VC_ERROR_NOT_SUPPORTED;
523 if (0 != __vc_cmd_check_privilege()) {
524 return VC_ERROR_PERMISSION_DENIED;
527 if (NULL == vc_cmd_list) {
528 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
529 return VC_ERROR_INVALID_PARAMETER;
532 vc_cmd_list_s* list = NULL;
533 list = (vc_cmd_list_s*)vc_cmd_list;
535 if (0 == g_slist_length(list->list)) {
536 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
537 return VC_ERROR_EMPTY;
542 return VC_ERROR_NONE;
545 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
547 if (0 != __vc_cmd_get_feature_enabled()) {
548 return VC_ERROR_NOT_SUPPORTED;
550 if (0 != __vc_cmd_check_privilege()) {
551 return VC_ERROR_PERMISSION_DENIED;
554 if (NULL == vc_cmd_list) {
555 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
556 return VC_ERROR_INVALID_PARAMETER;
559 vc_cmd_list_s* list = NULL;
560 list = (vc_cmd_list_s*)vc_cmd_list;
562 int count = g_slist_length(list->list);
565 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
566 return VC_ERROR_EMPTY;
568 list->index = count - 1;
569 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
572 return VC_ERROR_NONE;
575 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
577 if (0 != __vc_cmd_get_feature_enabled()) {
578 return VC_ERROR_NOT_SUPPORTED;
580 if (0 != __vc_cmd_check_privilege()) {
581 return VC_ERROR_PERMISSION_DENIED;
584 if (NULL == vc_cmd_list) {
585 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
586 return VC_ERROR_INVALID_PARAMETER;
589 vc_cmd_list_s* list = NULL;
590 list = (vc_cmd_list_s*)vc_cmd_list;
592 int count = g_slist_length(list->list);
594 if (list->index < count - 1) {
595 list->index = list->index + 1;
596 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
598 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
599 return VC_ERROR_ITERATION_END;
602 return VC_ERROR_NONE;
605 int vc_cmd_list_prev(vc_cmd_list_h vc_cmd_list)
607 if (0 != __vc_cmd_get_feature_enabled()) {
608 return VC_ERROR_NOT_SUPPORTED;
610 if (0 != __vc_cmd_check_privilege()) {
611 return VC_ERROR_PERMISSION_DENIED;
614 if (NULL == vc_cmd_list) {
615 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
616 return VC_ERROR_INVALID_PARAMETER;
619 vc_cmd_list_s* list = NULL;
620 list = (vc_cmd_list_s*)vc_cmd_list;
622 if (list->index > 0) {
623 list->index = list->index - 1;
624 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
626 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
627 return VC_ERROR_ITERATION_END;
630 return VC_ERROR_NONE;
633 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
635 if (0 != __vc_cmd_get_feature_enabled()) {
636 return VC_ERROR_NOT_SUPPORTED;
638 if (0 != __vc_cmd_check_privilege()) {
639 return VC_ERROR_PERMISSION_DENIED;
642 if (NULL == vc_cmd_list || NULL == vc_command) {
643 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
644 return VC_ERROR_INVALID_PARAMETER;
647 vc_cmd_list_s* list = NULL;
648 list = (vc_cmd_list_s*)vc_cmd_list;
650 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
652 if (0 == g_slist_length(list->list)) {
653 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
655 return VC_ERROR_EMPTY;
658 vc_cmd_s *temp_cmd = NULL;
659 temp_cmd = g_slist_nth_data(list->list, list->index);
661 *vc_command = (vc_cmd_h)temp_cmd;
663 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
665 return VC_ERROR_NONE;
669 int vc_cmd_create(vc_cmd_h* vc_command)
671 if (0 != __vc_cmd_get_feature_enabled()) {
672 return VC_ERROR_NOT_SUPPORTED;
674 if (0 != __vc_cmd_check_privilege()) {
675 return VC_ERROR_PERMISSION_DENIED;
678 if (NULL == vc_command) {
679 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
680 return VC_ERROR_INVALID_PARAMETER;
683 vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
685 if (NULL == command) {
686 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
687 return VC_ERROR_OUT_OF_MEMORY;
693 command->type = VC_COMMAND_TYPE_NONE;
694 command->format = VC_CMD_FORMAT_FIXED;
695 command->command = NULL;
696 command->parameter = NULL;
698 command->priority = 0;
699 command->key = VC_KEY_NONE;
700 command->modifier = VC_MODIFIER_NONE;
702 *vc_command = (vc_cmd_h)command;
704 SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
706 return VC_ERROR_NONE;
709 int vc_cmd_destroy(vc_cmd_h vc_command)
711 if (0 != __vc_cmd_get_feature_enabled()) {
712 return VC_ERROR_NOT_SUPPORTED;
714 if (0 != __vc_cmd_check_privilege()) {
715 return VC_ERROR_PERMISSION_DENIED;
718 if (NULL == vc_command) {
719 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
720 return VC_ERROR_INVALID_PARAMETER;
723 vc_cmd_s* command = NULL;
724 command = (vc_cmd_s*)vc_command;
726 SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
728 if (NULL != command) {
729 if (NULL != command->command) free(command->command);
730 if (NULL != command->parameter) free(command->parameter);
735 return VC_ERROR_NONE;
738 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
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;
747 if (NULL == vc_command) {
748 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
749 return VC_ERROR_INVALID_PARAMETER;
752 vc_cmd_s* cmd = NULL;
753 cmd = (vc_cmd_s*)vc_command;
757 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
763 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
765 if (0 != __vc_cmd_get_feature_enabled()) {
766 return VC_ERROR_NOT_SUPPORTED;
768 if (0 != __vc_cmd_check_privilege()) {
769 return VC_ERROR_PERMISSION_DENIED;
772 if (NULL == vc_command || NULL == id) {
773 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
774 return VC_ERROR_INVALID_PARAMETER;
777 vc_cmd_s* cmd = NULL;
778 cmd = (vc_cmd_s*)vc_command;
782 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
788 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
790 if (0 != __vc_cmd_get_feature_enabled()) {
791 return VC_ERROR_NOT_SUPPORTED;
794 if (NULL == vc_command) {
795 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
796 return VC_ERROR_INVALID_PARAMETER;
800 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
801 return VC_ERROR_INVALID_PARAMETER;
804 vc_cmd_s* cmd = NULL;
805 cmd = (vc_cmd_s*)vc_command;
807 if (NULL != cmd->appid) {
812 cmd->appid = strdup(appid);
814 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
818 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
820 if (0 != __vc_cmd_get_feature_enabled()) {
821 return VC_ERROR_NOT_SUPPORTED;
824 if (NULL == vc_command || NULL == appid) {
825 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
826 return VC_ERROR_INVALID_PARAMETER;
829 vc_cmd_s* cmd = NULL;
830 cmd = (vc_cmd_s*)vc_command;
832 if (NULL != cmd->appid) {
833 *appid = strdup(gettext(cmd->appid));
836 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
840 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
842 if (0 != __vc_cmd_get_feature_enabled()) {
843 return VC_ERROR_NOT_SUPPORTED;
845 if (0 != __vc_cmd_check_privilege()) {
846 return VC_ERROR_PERMISSION_DENIED;
849 if (NULL == vc_command) {
850 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
851 return VC_ERROR_INVALID_PARAMETER;
854 vc_cmd_s* cmd = NULL;
855 cmd = (vc_cmd_s*)vc_command;
857 if (NULL != cmd->command) {
863 if (NULL != command) {
864 cmd->command = strdup(command);
867 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
872 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
874 if (0 != __vc_cmd_get_feature_enabled()) {
875 return VC_ERROR_NOT_SUPPORTED;
877 if (0 != __vc_cmd_check_privilege()) {
878 return VC_ERROR_PERMISSION_DENIED;
881 if (NULL == vc_command || NULL == command) {
882 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
883 return VC_ERROR_INVALID_PARAMETER;
886 vc_cmd_s* cmd = NULL;
887 cmd = (vc_cmd_s*)vc_command;
889 if (NULL != cmd->command) {
890 *command = strdup(gettext(cmd->command));
893 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
898 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
900 if (0 != __vc_cmd_get_feature_enabled()) {
901 return VC_ERROR_NOT_SUPPORTED;
903 if (0 != __vc_cmd_check_privilege()) {
904 return VC_ERROR_PERMISSION_DENIED;
907 if (NULL == vc_command) {
908 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
909 return VC_ERROR_INVALID_PARAMETER;
912 vc_cmd_s* cmd = NULL;
913 cmd = (vc_cmd_s*)vc_command;
915 if (NULL != cmd->parameter) {
916 free(cmd->parameter);
919 cmd->parameter = NULL;
921 if (NULL != command) {
922 cmd->parameter = strdup(command);
923 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
929 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
931 if (0 != __vc_cmd_get_feature_enabled()) {
932 return VC_ERROR_NOT_SUPPORTED;
934 if (0 != __vc_cmd_check_privilege()) {
935 return VC_ERROR_PERMISSION_DENIED;
938 if (NULL == vc_command || NULL == command) {
939 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
940 return VC_ERROR_INVALID_PARAMETER;
943 vc_cmd_s* cmd = NULL;
944 cmd = (vc_cmd_s*)vc_command;
946 if (NULL != cmd->parameter) {
947 *command = strdup(gettext(cmd->parameter));
948 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
954 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
956 if (0 != __vc_cmd_get_feature_enabled()) {
957 return VC_ERROR_NOT_SUPPORTED;
960 if (NULL == vc_command) {
961 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
962 return VC_ERROR_INVALID_PARAMETER;
966 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
967 return VC_ERROR_INVALID_PARAMETER;
970 vc_cmd_s* cmd = NULL;
971 cmd = (vc_cmd_s*)vc_command;
973 if (NULL != cmd->fixed) {
978 cmd->fixed = strdup(fixed);
980 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
984 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
986 if (0 != __vc_cmd_get_feature_enabled()) {
987 return VC_ERROR_NOT_SUPPORTED;
990 if (NULL == vc_command || NULL == fixed) {
991 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
992 return VC_ERROR_INVALID_PARAMETER;
995 vc_cmd_s* cmd = NULL;
996 cmd = (vc_cmd_s*)vc_command;
998 if (NULL != cmd->fixed) {
999 *fixed = strdup(gettext(cmd->fixed));
1000 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1006 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1008 if (0 != __vc_cmd_get_feature_enabled()) {
1009 return VC_ERROR_NOT_SUPPORTED;
1012 if (NULL == vc_command) {
1013 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1014 return VC_ERROR_INVALID_PARAMETER;
1017 if (NULL == invocation_name) {
1018 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1019 return VC_ERROR_INVALID_PARAMETER;
1022 vc_cmd_s* cmd = NULL;
1023 cmd = (vc_cmd_s*)vc_command;
1025 if (NULL != cmd->invocation_name) {
1026 free(cmd->invocation_name);
1027 cmd->invocation_name = NULL;
1030 cmd->invocation_name = strdup(invocation_name);
1032 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1036 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1038 if (0 != __vc_cmd_get_feature_enabled()) {
1039 return VC_ERROR_NOT_SUPPORTED;
1042 if (NULL == vc_command || NULL == invocation_name) {
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;
1050 if (NULL != cmd->invocation_name) {
1051 *invocation_name = strdup(gettext(cmd->invocation_name));
1054 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1058 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1060 if (0 != __vc_cmd_get_feature_enabled()) {
1061 return VC_ERROR_NOT_SUPPORTED;
1063 if (0 != __vc_cmd_check_privilege()) {
1064 return VC_ERROR_PERMISSION_DENIED;
1067 if (NULL == vc_command) {
1068 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1069 return VC_ERROR_INVALID_PARAMETER;
1072 vc_cmd_s* cmd = NULL;
1073 cmd = (vc_cmd_s*)vc_command;
1077 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1082 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1084 if (0 != __vc_cmd_get_feature_enabled()) {
1085 return VC_ERROR_NOT_SUPPORTED;
1087 if (0 != __vc_cmd_check_privilege()) {
1088 return VC_ERROR_PERMISSION_DENIED;
1091 if (NULL == vc_command || NULL == type) {
1092 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1093 return VC_ERROR_INVALID_PARAMETER;
1096 vc_cmd_s* cmd = NULL;
1097 cmd = (vc_cmd_s*)vc_command;
1101 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1106 int vc_cmd_set_format(vc_cmd_h vc_command, vc_cmd_format_e format)
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 vc_cmd_s* cmd = NULL;
1121 cmd = (vc_cmd_s*)vc_command;
1123 cmd->format = format;
1125 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1130 int vc_cmd_get_format(vc_cmd_h vc_command, vc_cmd_format_e* format)
1132 if (0 != __vc_cmd_get_feature_enabled()) {
1133 return VC_ERROR_NOT_SUPPORTED;
1135 if (0 != __vc_cmd_check_privilege()) {
1136 return VC_ERROR_PERMISSION_DENIED;
1139 if (NULL == vc_command || NULL == format) {
1140 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1141 return VC_ERROR_INVALID_PARAMETER;
1144 vc_cmd_s* cmd = NULL;
1145 cmd = (vc_cmd_s*)vc_command;
1147 *format = cmd->format;
1149 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1154 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1156 if (0 != __vc_cmd_get_feature_enabled()) {
1157 return VC_ERROR_NOT_SUPPORTED;
1159 if (0 != __vc_cmd_check_privilege()) {
1160 return VC_ERROR_PERMISSION_DENIED;
1163 if (NULL == vc_command) {
1164 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1165 return VC_ERROR_INVALID_PARAMETER;
1168 vc_cmd_s* cmd = NULL;
1169 cmd = (vc_cmd_s*)vc_command;
1173 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1178 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1180 if (0 != __vc_cmd_get_feature_enabled()) {
1181 return VC_ERROR_NOT_SUPPORTED;
1183 if (0 != __vc_cmd_check_privilege()) {
1184 return VC_ERROR_PERMISSION_DENIED;
1187 if (NULL == vc_command || NULL == pid) {
1188 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1189 return VC_ERROR_INVALID_PARAMETER;
1192 vc_cmd_s* cmd = NULL;
1193 cmd = (vc_cmd_s*)vc_command;
1197 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1202 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1204 if (0 != __vc_cmd_get_feature_enabled()) {
1205 return VC_ERROR_NOT_SUPPORTED;
1207 if (0 != __vc_cmd_check_privilege()) {
1208 return VC_ERROR_PERMISSION_DENIED;
1211 if (NULL == vc_command) {
1212 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1213 return VC_ERROR_INVALID_PARAMETER;
1216 vc_cmd_s* cmd = NULL;
1217 cmd = (vc_cmd_s*)vc_command;
1219 cmd->domain = domain;
1221 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1226 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1228 if (0 != __vc_cmd_get_feature_enabled()) {
1229 return VC_ERROR_NOT_SUPPORTED;
1231 if (0 != __vc_cmd_check_privilege()) {
1232 return VC_ERROR_PERMISSION_DENIED;
1235 if (NULL == vc_command || NULL == domain) {
1236 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1237 return VC_ERROR_INVALID_PARAMETER;
1240 vc_cmd_s* cmd = NULL;
1241 cmd = (vc_cmd_s*)vc_command;
1243 *domain = cmd->domain;
1245 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1251 * @brief Sets key value of command.
1253 * @param[in] vc_command Command handle
1254 * @param[in] key key value
1255 * @param[in] modifier modifier value
1257 * @return 0 on success, otherwise a negative error value
1258 * @retval #VC_ERROR_NONE Successful
1259 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1261 * @see vc_cmd_get_result_key()
1263 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1265 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
1267 if (NULL == vc_command) {
1268 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1269 return VC_ERROR_INVALID_PARAMETER;
1272 vc_cmd_s* cmd = NULL;
1273 cmd = (vc_cmd_s*)vc_command;
1275 SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1278 cmd->modifier = modifier;
1280 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1281 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1287 * @brief Gets key value of command.
1289 * @param[in] vc_command Command handle
1290 * @param[out] key key value
1291 * @param[out] modifier modifier value
1293 * @return 0 on success, otherwise a negative error value
1294 * @retval #VC_ERROR_NONE Successful
1295 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1297 * @see vc_cmd_add_result_key()
1299 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1301 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
1303 if (NULL == vc_command || NULL == key || NULL == modifier) {
1304 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1305 return VC_ERROR_INVALID_PARAMETER;
1308 vc_cmd_s* cmd = NULL;
1309 cmd = (vc_cmd_s*)vc_command;
1312 *modifier = cmd->modifier;
1314 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1315 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1320 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1322 if (NULL == vc_cmd_list) {
1326 vc_cmd_list_s* list = NULL;
1327 list = (vc_cmd_list_s*)vc_cmd_list;
1329 SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
1330 SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1332 int count = g_slist_length(list->list);
1335 vc_cmd_s *cmd = NULL;
1337 for (i = 0; i < count ; i++) {
1338 cmd = g_slist_nth_data(list->list, i);
1341 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)",
1342 i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1346 SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1347 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1352 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1354 if (0 != __vc_cmd_get_feature_enabled()) {
1355 return VC_ERROR_NOT_SUPPORTED;
1358 if (NULL == vc_cmd || NULL == json) {
1359 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1360 return VC_ERROR_INVALID_PARAMETER;
1363 vc_cmd_s* cmd = NULL;
1364 cmd = (vc_cmd_s*)vc_cmd;
1366 if (VC_CMD_FORMAT_ACTION != cmd->format) {
1367 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1368 return VC_ERROR_INVALID_PARAMETER;
1371 if (0 != vc_info_parser_get_nlu_result(json)) {
1372 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1373 return VC_ERROR_OPERATION_FAILED;
1379 static void __vc_cmd_regex_deinit(int num_regex)
1381 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Start Deinitialize regex ====");
1384 for (i = 0; num_regex > i; i++) {
1388 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
1389 SLOG(LOG_DEBUG, TAG_VCCMD, "");
1392 static int __vc_cmd_regex_init()
1394 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Initialize regular expression ====");
1396 int cflags = REG_EXTENDED | REG_ICASE;
1402 vc_config_mgr_get_default_language(&lang);
1404 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1405 return VC_ERROR_OPERATION_FAILED;
1408 if (!strcmp("en_US", lang)) {
1410 } else if (!strcmp("ko_KR", lang)) {
1416 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1417 return VC_ERROR_INVALID_LANGUAGE;
1423 SLOG(LOG_DEBUG, TAG_VCCMD, "==== lang type > %d ====", lang_type);
1425 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1427 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1428 ret = regcomp(®[0], TIME_ABS1_REGEX[lang_type], cflags);
1430 regerror(ret, ®[0], errStr, sizeof(errStr));
1432 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1433 return VC_ERROR_OPERATION_FAILED;
1436 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1437 ret = regcomp(®[1], TIME_ABS2_REGEX[lang_type], cflags);
1439 regerror(ret, ®[1], errStr, sizeof(errStr));
1440 __vc_cmd_regex_deinit(1);
1442 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1443 return VC_ERROR_OPERATION_FAILED;
1446 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1447 ret = regcomp(®[2], TIME_ABS3_REGEX[lang_type], cflags);
1449 regerror(ret, ®[2], errStr, sizeof(errStr));
1450 __vc_cmd_regex_deinit(2);
1452 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1453 return VC_ERROR_OPERATION_FAILED;
1456 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1457 ret = regcomp(®[3], TIME_REL1_REGEX[lang_type], cflags);
1459 regerror(ret, ®[3], errStr, sizeof(errStr));
1460 __vc_cmd_regex_deinit(3);
1462 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1463 return VC_ERROR_OPERATION_FAILED;
1466 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1467 ret = regcomp(®[4], TIME_REL2_REGEX[lang_type], cflags);
1469 regerror(ret, ®[4], errStr, sizeof(errStr));
1470 __vc_cmd_regex_deinit(4);
1472 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1473 return VC_ERROR_OPERATION_FAILED;
1476 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1477 ret = regcomp(®[5], TIME_REL3_REGEX[lang_type], cflags);
1479 regerror(ret, ®[5], errStr, sizeof(errStr));
1480 __vc_cmd_regex_deinit(5);
1482 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1483 return VC_ERROR_OPERATION_FAILED;
1486 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1487 ret = regcomp(®[6], TIME_PHR_REGEX[lang_type], cflags);
1489 regerror(ret, ®[6], errStr, sizeof(errStr));
1490 __vc_cmd_regex_deinit(6);
1492 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1493 return VC_ERROR_OPERATION_FAILED;
1496 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1497 ret = regcomp(®[7], DATE_ABS1_REGEX[lang_type], cflags);
1499 regerror(ret, ®[7], errStr, sizeof(errStr));
1500 __vc_cmd_regex_deinit(7);
1502 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1503 return VC_ERROR_OPERATION_FAILED;
1506 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1507 ret = regcomp(®[8], DATE_ABS2_REGEX[lang_type], cflags);
1509 regerror(ret, ®[8], errStr, sizeof(errStr));
1510 __vc_cmd_regex_deinit(8);
1512 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1513 return VC_ERROR_OPERATION_FAILED;
1516 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1517 ret = regcomp(®[9], DATE_ABS3_REGEX[lang_type], cflags);
1519 regerror(ret, ®[9], errStr, sizeof(errStr));
1520 __vc_cmd_regex_deinit(9);
1522 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1523 return VC_ERROR_OPERATION_FAILED;
1526 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1527 ret = regcomp(®[10], DATE_PHR1_REGEX[lang_type], cflags);
1529 regerror(ret, ®[10], errStr, sizeof(errStr));
1530 __vc_cmd_regex_deinit(10);
1532 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1533 return VC_ERROR_OPERATION_FAILED;
1536 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1537 ret = regcomp(®[11], DATE_PHR2_REGEX[lang_type], cflags);
1539 regerror(ret, ®[11], errStr, sizeof(errStr));
1540 __vc_cmd_regex_deinit(11);
1542 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1543 return VC_ERROR_OPERATION_FAILED;
1546 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
1547 SLOG(LOG_DEBUG, TAG_VCCMD, "");
1549 return VC_ERROR_NONE;
1552 static void __vc_cmd_add_year(struct tm *td, int year)
1554 td->tm_year += year;
1557 static void __vc_cmd_add_mon(struct tm *td, int mon)
1561 mon = td->tm_mon + mon;
1565 __vc_cmd_add_year(td, year);
1568 td->tm_mon = mon % 12;
1571 static void __vc_cmd_add_mday(struct tm *td, int mday)
1573 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1574 int year = td->tm_year + 1900;
1578 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1580 mday = td->tm_mday + mday;
1582 for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1583 mday -= max_day[mon % 12];
1585 if (11 == mon % 12) {
1588 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1596 mon = mon - td->tm_mon;
1599 __vc_cmd_add_mon(td, mon);
1605 static void __vc_cmd_add_hour(struct tm *td, int hour)
1609 hour = td->tm_hour + hour;
1613 __vc_cmd_add_mday(td, day);
1616 td->tm_hour = hour % 24;
1619 static void __vc_cmd_add_min(struct tm *td, int min)
1623 min = td->tm_min + min;
1627 __vc_cmd_add_hour(td, hour);
1630 td->tm_min = min % 60;
1633 static void __copy_struct_tm(struct tm *des, struct tm *src)
1635 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Start to copy struct tm ====");
1637 des->tm_sec = src->tm_sec;
1638 des->tm_min = src->tm_min;
1639 des->tm_hour = src->tm_hour;
1640 des->tm_mday = src->tm_mday;
1641 des->tm_mon = src->tm_mon;
1642 des->tm_year = src->tm_year;
1643 des->tm_wday = src->tm_wday;
1644 des->tm_yday = src->tm_yday;
1645 des->tm_isdst = src->tm_isdst;
1647 des->tm_gmtoff = src->tm_gmtoff;
1648 des->tm_zone = src->tm_zone;
1651 static void __update_data_sidx(int idx)
1653 if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1656 static void __update_data_eidx(int idx)
1658 if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1661 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1663 regmatch_t pmatch[3];
1669 ret = regexec(®[6], str, 3, pmatch, 0);
1672 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1674 if (12 < td->tm_hour) {
1675 __vc_cmd_add_mday(td, 1);
1681 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1683 __vc_cmd_add_mday(td, 1);
1688 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1690 __update_data_sidx(pmatch[0].rm_so);
1691 __update_data_eidx(pmatch[0].rm_eo);
1694 return VC_ERROR_NONE;
1697 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1698 return VC_ERROR_NONE;
1701 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1703 regmatch_t pmatch[2];
1711 char *tempstr = NULL;
1714 ret = regexec(®[3], str, 1, pmatch, 0);
1716 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1719 sidx = pmatch[0].rm_so;
1720 eidx = pmatch[0].rm_eo;
1722 ret = regexec(®[4], str, 2, pmatch, 0);
1724 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1725 tempstr = strndup(str + pmatch[1].rm_so, len);
1727 if (NULL == tempstr) {
1728 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1729 return VC_ERROR_OUT_OF_MEMORY;
1732 hour = atoi(tempstr);
1737 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1739 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1740 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1743 ret = regexec(®[5], str, 2, pmatch, 0);
1745 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1746 tempstr = strndup(str + pmatch[1].rm_so, len);
1748 if (NULL == tempstr) {
1749 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1750 return VC_ERROR_OUT_OF_MEMORY;
1753 min = atoi(tempstr);
1758 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1760 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1761 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1764 if (hour < 0 && min < 0) {
1765 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1766 return VC_ERROR_NONE;
1769 hour = 0 > hour ? 0 : hour;
1770 min = 0 > min ? 0 : min;
1772 min = min + (hour * 60);
1774 __vc_cmd_add_min(td, min);
1777 __update_data_sidx(sidx);
1778 __update_data_eidx(eidx);
1781 return VC_ERROR_NONE;
1784 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1785 return VC_ERROR_NONE;
1788 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1790 regmatch_t pmatch[5];
1799 char *tempstr = NULL;
1802 ret = regexec(®[0], str, 5, pmatch, 0);
1804 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1808 sidx = pmatch[0].rm_so;
1809 eidx = pmatch[0].rm_eo;
1812 ret = regexec(®[1], str, 2, pmatch, 0);
1814 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1815 tempstr = strndup(str + pmatch[1].rm_so, len);
1817 if (NULL == tempstr) {
1818 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1819 return VC_ERROR_OUT_OF_MEMORY;
1822 hour = atoi(tempstr);
1825 hour = hour + 12 * flag;
1827 if (12 == hour) hour = 0;
1828 else if(24 == hour) hour = 12;
1831 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1832 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1833 return VC_ERROR_NONE;
1839 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1841 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1842 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1843 } else if (0 < flag) {
1844 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1845 return VC_ERROR_NONE;
1848 ret = regexec(®[2], str, 2, pmatch, 0);
1851 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1853 tempstr = strndup(str + pmatch[idx].rm_so, len);
1855 if (NULL == tempstr) {
1856 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1857 return VC_ERROR_OUT_OF_MEMORY;
1860 min = atoi(tempstr);
1862 if (0 > min || 60 <= min) {
1863 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1864 return VC_ERROR_NONE;
1876 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1877 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1878 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1881 if (0 > hour && 0 > min) {
1882 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1883 return VC_ERROR_NONE;
1886 if (0 <= min && 0 <= hour) {
1887 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1891 } else if (0 <= min) {
1893 vc_config_mgr_get_default_language(&lang);
1895 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1896 return VC_ERROR_OPERATION_FAILED;
1899 if (!strcmp("en_US", lang)) {
1900 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1903 return VC_ERROR_NONE;
1905 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1912 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1920 __update_data_sidx(sidx);
1921 __update_data_eidx(eidx);
1924 return VC_ERROR_NONE;
1927 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
1929 regmatch_t pmatch[10];
1935 ret = regexec(®[10], str, 5, pmatch, 0);
1937 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1939 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1941 td->tm_year = td_now.tm_year;
1942 td->tm_mon = td_now.tm_mon;
1943 td->tm_mday = td_now.tm_mday;
1945 __vc_cmd_add_mday(td, idx - 1);
1947 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1949 __update_data_sidx(pmatch[0].rm_so);
1950 __update_data_eidx(pmatch[0].rm_eo);
1953 return VC_ERROR_NONE;
1956 ret = regexec(®[11], str, 10, pmatch, 0);
1958 for (idx = 1; 10 > idx; idx++) {
1959 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1964 td->tm_year = td_now.tm_year;
1965 td->tm_mon = td_now.tm_mon;
1966 td->tm_mday = td_now.tm_mday;
1968 __vc_cmd_add_mday(td, idx + 1);
1970 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1972 __update_data_sidx(pmatch[0].rm_so);
1973 __update_data_eidx(pmatch[0].rm_eo);
1976 return VC_ERROR_NONE;
1979 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1980 return VC_ERROR_NONE;
1983 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
1985 regmatch_t pmatch[13];
1996 char *tempstr = NULL;
1999 ret = regexec(®[9], str, 2, pmatch, 0);
2001 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2002 tempstr = strndup(str + pmatch[1].rm_so, len);
2004 if (NULL == tempstr) {
2005 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2006 return VC_ERROR_OUT_OF_MEMORY;
2009 day = atoi(tempstr);
2014 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2016 sidx = pmatch[0].rm_so;
2017 eidx = pmatch[0].rm_eo;
2019 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2020 return VC_ERROR_NONE;
2023 ret = regexec(®[8], str, 13, pmatch, 0);
2025 for (idx = 1; 13 > idx; idx++) {
2026 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2036 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2038 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2039 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2042 vc_config_mgr_get_default_language(&lang);
2044 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2045 return VC_ERROR_OPERATION_FAILED;
2048 if (!strcmp("en_US", lang)) {
2049 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2052 return VC_ERROR_NONE;
2061 ret = regexec(®[7], str, 3, pmatch, 0);
2063 if (!m_flag) return -1;
2065 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2066 tempstr = strndup(str + pmatch[2].rm_so, len);
2068 if (NULL == tempstr) {
2069 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2070 return VC_ERROR_OUT_OF_MEMORY;
2073 year = atoi(tempstr);
2074 year = 1900 < year ? year - 1900 : year + 100;
2080 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2082 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2083 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2088 if (0 > g_time_flag) {
2092 } else if (2 == g_time_flag) {
2093 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2094 return VC_ERROR_NONE;
2097 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2098 if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2100 if (max_day[mon] < day || 1 > day) {
2101 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2102 return VC_ERROR_NONE;
2111 if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2113 if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2114 else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2118 __update_data_sidx(sidx);
2119 __update_data_eidx(eidx);
2122 return VC_ERROR_NONE;
2125 static int __vc_cmd_time_check(const char *str, struct tm *td)
2127 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Check time value in string \"%s\"", str);
2132 ret = __vc_cmd_tphrase_check(str, td, &exist);
2136 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2138 } else if (VC_ERROR_NONE != ret) {
2139 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2143 ret = __vc_cmd_trelative_check(str, td, &exist);
2147 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2149 } else if (VC_ERROR_NONE != ret) {
2150 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2154 ret = __vc_cmd_tabsolute_check(str, td, &exist);
2158 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2160 } else if (VC_ERROR_NONE != ret) {
2161 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2165 SLOG(LOG_DEBUG, TAG_VCCMD, "==== There is no time value");
2166 return VC_ERROR_NONE;
2169 static int __vc_cmd_date_check(const char *str, struct tm *td)
2171 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Check date value in string \"%s\"", str);
2176 ret = __vc_cmd_dphrase_check(str, td, &exist);
2180 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Date value is exist");
2182 } else if (VC_ERROR_NONE != ret) {
2183 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2187 ret = __vc_cmd_dabsolute_check(str, td, &exist);
2191 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Date value is exist");
2193 } else if (VC_ERROR_NONE != ret) {
2194 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2198 SLOG(LOG_DEBUG, TAG_VCCMD, "==== There is no date value");
2199 return VC_ERROR_NONE;
2202 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2204 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Get timestamp data");
2207 const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2210 if (NULL == text || NULL == result || NULL == remain) {
2211 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2212 return VC_ERROR_INVALID_PARAMETER;
2216 ret = __vc_cmd_regex_init();
2217 if (VC_ERROR_NONE != ret) {
2218 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2222 g_data_sidx = g_data_eidx = -1;
2225 localtime_r(&t_now, &td_now);
2226 SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2228 __copy_struct_tm(&td, &td_now);
2229 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2230 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);
2232 g_time_flag = g_date_flag = -1;
2234 ret = __vc_cmd_time_check(text, &td);
2235 if (VC_ERROR_NONE != ret) {
2236 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2240 ret = __vc_cmd_date_check(text, &td);
2241 if (VC_ERROR_NONE != ret) {
2242 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2246 __vc_cmd_regex_deinit(12);
2248 if (g_time_flag > 0 || g_date_flag > 0) {
2249 *result = mktime(&td);
2251 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %d", *result);
2252 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2253 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, td.tm_yday);
2255 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2257 if (NULL == *remain) {
2258 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2259 return VC_ERROR_OUT_OF_MEMORY;
2262 strncpy(*remain, text, g_data_sidx);
2263 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2265 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2268 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
2269 SLOG(LOG_DEBUG, TAG_VCCMD, "");
2271 return VC_ERROR_NONE;