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) {
730 free(command->command);
731 command->command = NULL;
733 if (NULL != command->parameter) {
734 free(command->parameter);
735 command->parameter = NULL;
737 if (NULL != command->invocation_name) {
738 free(command->invocation_name);
739 command->invocation_name = NULL;
741 if (NULL != command->appid) {
742 free(command->appid);
743 command->appid = NULL;
745 if (NULL != command->fixed) {
746 free(command->fixed);
747 command->fixed = NULL;
753 return VC_ERROR_NONE;
756 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
758 if (0 != __vc_cmd_get_feature_enabled()) {
759 return VC_ERROR_NOT_SUPPORTED;
761 if (0 != __vc_cmd_check_privilege()) {
762 return VC_ERROR_PERMISSION_DENIED;
765 if (NULL == vc_command) {
766 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
767 return VC_ERROR_INVALID_PARAMETER;
770 vc_cmd_s* cmd = NULL;
771 cmd = (vc_cmd_s*)vc_command;
775 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
781 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
783 if (0 != __vc_cmd_get_feature_enabled()) {
784 return VC_ERROR_NOT_SUPPORTED;
786 if (0 != __vc_cmd_check_privilege()) {
787 return VC_ERROR_PERMISSION_DENIED;
790 if (NULL == vc_command || NULL == id) {
791 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
792 return VC_ERROR_INVALID_PARAMETER;
795 vc_cmd_s* cmd = NULL;
796 cmd = (vc_cmd_s*)vc_command;
800 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
806 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
808 if (0 != __vc_cmd_get_feature_enabled()) {
809 return VC_ERROR_NOT_SUPPORTED;
812 if (NULL == vc_command) {
813 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
814 return VC_ERROR_INVALID_PARAMETER;
818 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
819 return VC_ERROR_INVALID_PARAMETER;
822 vc_cmd_s* cmd = NULL;
823 cmd = (vc_cmd_s*)vc_command;
825 if (NULL != cmd->appid) {
830 cmd->appid = strdup(appid);
832 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
836 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
838 if (0 != __vc_cmd_get_feature_enabled()) {
839 return VC_ERROR_NOT_SUPPORTED;
842 if (NULL == vc_command || NULL == appid) {
843 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
844 return VC_ERROR_INVALID_PARAMETER;
847 vc_cmd_s* cmd = NULL;
848 cmd = (vc_cmd_s*)vc_command;
850 if (NULL != cmd->appid) {
851 *appid = strdup(gettext(cmd->appid));
854 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
858 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
860 if (0 != __vc_cmd_get_feature_enabled()) {
861 return VC_ERROR_NOT_SUPPORTED;
863 if (0 != __vc_cmd_check_privilege()) {
864 return VC_ERROR_PERMISSION_DENIED;
867 if (NULL == vc_command) {
868 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
869 return VC_ERROR_INVALID_PARAMETER;
872 vc_cmd_s* cmd = NULL;
873 cmd = (vc_cmd_s*)vc_command;
875 if (NULL != cmd->command) {
881 if (NULL != command) {
882 cmd->command = strdup(command);
885 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
890 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
892 if (0 != __vc_cmd_get_feature_enabled()) {
893 return VC_ERROR_NOT_SUPPORTED;
895 if (0 != __vc_cmd_check_privilege()) {
896 return VC_ERROR_PERMISSION_DENIED;
899 if (NULL == vc_command || NULL == command) {
900 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
901 return VC_ERROR_INVALID_PARAMETER;
904 vc_cmd_s* cmd = NULL;
905 cmd = (vc_cmd_s*)vc_command;
907 if (NULL != cmd->command) {
908 *command = strdup(gettext(cmd->command));
911 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
916 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
918 if (0 != __vc_cmd_get_feature_enabled()) {
919 return VC_ERROR_NOT_SUPPORTED;
921 if (0 != __vc_cmd_check_privilege()) {
922 return VC_ERROR_PERMISSION_DENIED;
925 if (NULL == vc_command) {
926 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
927 return VC_ERROR_INVALID_PARAMETER;
930 vc_cmd_s* cmd = NULL;
931 cmd = (vc_cmd_s*)vc_command;
933 if (NULL != cmd->parameter) {
934 free(cmd->parameter);
937 cmd->parameter = NULL;
939 if (NULL != command) {
940 cmd->parameter = strdup(command);
941 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
947 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
949 if (0 != __vc_cmd_get_feature_enabled()) {
950 return VC_ERROR_NOT_SUPPORTED;
953 if (NULL == vc_command || NULL == command) {
954 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
955 return VC_ERROR_INVALID_PARAMETER;
958 vc_cmd_s* cmd = NULL;
959 cmd = (vc_cmd_s*)vc_command;
961 if (NULL != cmd->parameter) {
962 *command = strdup(gettext(cmd->parameter));
963 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
969 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
971 if (0 != __vc_cmd_get_feature_enabled()) {
972 return VC_ERROR_NOT_SUPPORTED;
975 if (NULL == vc_command) {
976 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
977 return VC_ERROR_INVALID_PARAMETER;
981 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
982 return VC_ERROR_INVALID_PARAMETER;
985 vc_cmd_s* cmd = NULL;
986 cmd = (vc_cmd_s*)vc_command;
988 if (NULL != cmd->fixed) {
993 cmd->fixed = strdup(fixed);
995 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
999 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
1001 if (0 != __vc_cmd_get_feature_enabled()) {
1002 return VC_ERROR_NOT_SUPPORTED;
1005 if (NULL == vc_command || NULL == fixed) {
1006 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1007 return VC_ERROR_INVALID_PARAMETER;
1010 vc_cmd_s* cmd = NULL;
1011 cmd = (vc_cmd_s*)vc_command;
1013 if (NULL != cmd->fixed) {
1014 *fixed = strdup(gettext(cmd->fixed));
1015 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1021 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1023 if (0 != __vc_cmd_get_feature_enabled()) {
1024 return VC_ERROR_NOT_SUPPORTED;
1027 if (NULL == vc_command) {
1028 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1029 return VC_ERROR_INVALID_PARAMETER;
1032 if (NULL == invocation_name) {
1033 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1034 return VC_ERROR_INVALID_PARAMETER;
1037 vc_cmd_s* cmd = NULL;
1038 cmd = (vc_cmd_s*)vc_command;
1040 if (NULL != cmd->invocation_name) {
1041 free(cmd->invocation_name);
1042 cmd->invocation_name = NULL;
1045 cmd->invocation_name = strdup(invocation_name);
1047 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1051 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1053 if (0 != __vc_cmd_get_feature_enabled()) {
1054 return VC_ERROR_NOT_SUPPORTED;
1057 if (NULL == vc_command || NULL == invocation_name) {
1058 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1059 return VC_ERROR_INVALID_PARAMETER;
1062 vc_cmd_s* cmd = NULL;
1063 cmd = (vc_cmd_s*)vc_command;
1065 if (NULL != cmd->invocation_name) {
1066 *invocation_name = strdup(gettext(cmd->invocation_name));
1069 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1073 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1075 if (0 != __vc_cmd_get_feature_enabled()) {
1076 return VC_ERROR_NOT_SUPPORTED;
1078 if (0 != __vc_cmd_check_privilege()) {
1079 return VC_ERROR_PERMISSION_DENIED;
1082 if (NULL == vc_command) {
1083 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1084 return VC_ERROR_INVALID_PARAMETER;
1087 vc_cmd_s* cmd = NULL;
1088 cmd = (vc_cmd_s*)vc_command;
1092 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1097 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1099 if (0 != __vc_cmd_get_feature_enabled()) {
1100 return VC_ERROR_NOT_SUPPORTED;
1102 if (0 != __vc_cmd_check_privilege()) {
1103 return VC_ERROR_PERMISSION_DENIED;
1106 if (NULL == vc_command || NULL == type) {
1107 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1108 return VC_ERROR_INVALID_PARAMETER;
1111 vc_cmd_s* cmd = NULL;
1112 cmd = (vc_cmd_s*)vc_command;
1116 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1121 int vc_cmd_set_format(vc_cmd_h vc_command, int format)
1123 if (0 != __vc_cmd_get_feature_enabled()) {
1124 return VC_ERROR_NOT_SUPPORTED;
1127 if (NULL == vc_command) {
1128 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1129 return VC_ERROR_INVALID_PARAMETER;
1132 vc_cmd_s* cmd = NULL;
1133 cmd = (vc_cmd_s*)vc_command;
1135 cmd->format = format;
1137 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1142 int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
1144 if (0 != __vc_cmd_get_feature_enabled()) {
1145 return VC_ERROR_NOT_SUPPORTED;
1148 if (NULL == vc_command || NULL == format) {
1149 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1150 return VC_ERROR_INVALID_PARAMETER;
1153 vc_cmd_s* cmd = NULL;
1154 cmd = (vc_cmd_s*)vc_command;
1156 *format = cmd->format;
1158 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1163 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1165 if (0 != __vc_cmd_get_feature_enabled()) {
1166 return VC_ERROR_NOT_SUPPORTED;
1168 if (0 != __vc_cmd_check_privilege()) {
1169 return VC_ERROR_PERMISSION_DENIED;
1172 if (NULL == vc_command) {
1173 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1174 return VC_ERROR_INVALID_PARAMETER;
1177 vc_cmd_s* cmd = NULL;
1178 cmd = (vc_cmd_s*)vc_command;
1182 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1187 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1189 if (0 != __vc_cmd_get_feature_enabled()) {
1190 return VC_ERROR_NOT_SUPPORTED;
1192 if (0 != __vc_cmd_check_privilege()) {
1193 return VC_ERROR_PERMISSION_DENIED;
1196 if (NULL == vc_command || NULL == pid) {
1197 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1198 return VC_ERROR_INVALID_PARAMETER;
1201 vc_cmd_s* cmd = NULL;
1202 cmd = (vc_cmd_s*)vc_command;
1206 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1211 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1213 if (0 != __vc_cmd_get_feature_enabled()) {
1214 return VC_ERROR_NOT_SUPPORTED;
1216 if (0 != __vc_cmd_check_privilege()) {
1217 return VC_ERROR_PERMISSION_DENIED;
1220 if (NULL == vc_command) {
1221 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1222 return VC_ERROR_INVALID_PARAMETER;
1225 vc_cmd_s* cmd = NULL;
1226 cmd = (vc_cmd_s*)vc_command;
1228 cmd->domain = domain;
1230 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1235 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
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 == domain) {
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;
1252 *domain = cmd->domain;
1254 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1260 * @brief Sets key value of command.
1262 * @param[in] vc_command Command handle
1263 * @param[in] key key value
1264 * @param[in] modifier modifier value
1266 * @return 0 on success, otherwise a negative error value
1267 * @retval #VC_ERROR_NONE Successful
1268 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1270 * @see vc_cmd_get_result_key()
1272 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1274 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Set result key");
1276 if (NULL == vc_command) {
1277 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1278 return VC_ERROR_INVALID_PARAMETER;
1281 vc_cmd_s* cmd = NULL;
1282 cmd = (vc_cmd_s*)vc_command;
1284 SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1287 cmd->modifier = modifier;
1289 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1290 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1296 * @brief Gets key value of command.
1298 * @param[in] vc_command Command handle
1299 * @param[out] key key value
1300 * @param[out] modifier modifier value
1302 * @return 0 on success, otherwise a negative error value
1303 * @retval #VC_ERROR_NONE Successful
1304 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1306 * @see vc_cmd_add_result_key()
1308 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1310 SLOG(LOG_DEBUG, TAG_VCCMD, "===== Get result key");
1312 if (NULL == vc_command || NULL == key || NULL == modifier) {
1313 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1314 return VC_ERROR_INVALID_PARAMETER;
1317 vc_cmd_s* cmd = NULL;
1318 cmd = (vc_cmd_s*)vc_command;
1321 *modifier = cmd->modifier;
1323 SLOG(LOG_DEBUG, TAG_VCCMD, "=====");
1324 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1329 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1331 if (NULL == vc_cmd_list) {
1335 vc_cmd_list_s* list = NULL;
1336 list = (vc_cmd_list_s*)vc_cmd_list;
1338 SLOG(LOG_DEBUG, TAG_VCCMD, "=== Command List ===");
1339 SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1341 int count = g_slist_length(list->list);
1344 vc_cmd_s *cmd = NULL;
1346 for (i = 0; i < count ; i++) {
1347 cmd = g_slist_nth_data(list->list, i);
1350 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)",
1351 i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1355 SLOG(LOG_DEBUG, TAG_VCCMD, "==================");
1356 SLOG(LOG_DEBUG, TAG_VCCMD, " ");
1361 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1363 if (0 != __vc_cmd_get_feature_enabled()) {
1364 return VC_ERROR_NOT_SUPPORTED;
1367 if (NULL == vc_cmd || NULL == json) {
1368 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1369 return VC_ERROR_INVALID_PARAMETER;
1372 vc_cmd_s* cmd = NULL;
1373 cmd = (vc_cmd_s*)vc_cmd;
1375 if (VC_CMD_FORMAT_ACTION != cmd->format) {
1376 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1377 return VC_ERROR_INVALID_PARAMETER;
1380 if (0 != vc_info_parser_get_nlu_result(json)) {
1381 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1382 return VC_ERROR_OPERATION_FAILED;
1388 static void __vc_cmd_regex_deinit(int num_regex)
1390 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Start Deinitialize regex ====");
1393 for (i = 0; num_regex > i; i++) {
1397 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
1398 SLOG(LOG_DEBUG, TAG_VCCMD, "");
1401 static int __vc_cmd_regex_init()
1403 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Initialize regular expression ====");
1405 int cflags = REG_EXTENDED | REG_ICASE;
1411 vc_config_mgr_get_default_language(&lang);
1413 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1414 return VC_ERROR_OPERATION_FAILED;
1417 if (!strcmp("en_US", lang)) {
1419 } else if (!strcmp("ko_KR", lang)) {
1425 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1426 return VC_ERROR_INVALID_LANGUAGE;
1432 SLOG(LOG_DEBUG, TAG_VCCMD, "==== lang type > %d ====", lang_type);
1434 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1436 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1437 ret = regcomp(®[0], TIME_ABS1_REGEX[lang_type], cflags);
1439 regerror(ret, ®[0], errStr, sizeof(errStr));
1441 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1442 return VC_ERROR_OPERATION_FAILED;
1445 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1446 ret = regcomp(®[1], TIME_ABS2_REGEX[lang_type], cflags);
1448 regerror(ret, ®[1], errStr, sizeof(errStr));
1449 __vc_cmd_regex_deinit(1);
1451 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1452 return VC_ERROR_OPERATION_FAILED;
1455 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1456 ret = regcomp(®[2], TIME_ABS3_REGEX[lang_type], cflags);
1458 regerror(ret, ®[2], errStr, sizeof(errStr));
1459 __vc_cmd_regex_deinit(2);
1461 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1462 return VC_ERROR_OPERATION_FAILED;
1465 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1466 ret = regcomp(®[3], TIME_REL1_REGEX[lang_type], cflags);
1468 regerror(ret, ®[3], errStr, sizeof(errStr));
1469 __vc_cmd_regex_deinit(3);
1471 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1472 return VC_ERROR_OPERATION_FAILED;
1475 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1476 ret = regcomp(®[4], TIME_REL2_REGEX[lang_type], cflags);
1478 regerror(ret, ®[4], errStr, sizeof(errStr));
1479 __vc_cmd_regex_deinit(4);
1481 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1482 return VC_ERROR_OPERATION_FAILED;
1485 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1486 ret = regcomp(®[5], TIME_REL3_REGEX[lang_type], cflags);
1488 regerror(ret, ®[5], errStr, sizeof(errStr));
1489 __vc_cmd_regex_deinit(5);
1491 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1492 return VC_ERROR_OPERATION_FAILED;
1495 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1496 ret = regcomp(®[6], TIME_PHR_REGEX[lang_type], cflags);
1498 regerror(ret, ®[6], errStr, sizeof(errStr));
1499 __vc_cmd_regex_deinit(6);
1501 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1502 return VC_ERROR_OPERATION_FAILED;
1505 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1506 ret = regcomp(®[7], DATE_ABS1_REGEX[lang_type], cflags);
1508 regerror(ret, ®[7], errStr, sizeof(errStr));
1509 __vc_cmd_regex_deinit(7);
1511 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1512 return VC_ERROR_OPERATION_FAILED;
1515 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1516 ret = regcomp(®[8], DATE_ABS2_REGEX[lang_type], cflags);
1518 regerror(ret, ®[8], errStr, sizeof(errStr));
1519 __vc_cmd_regex_deinit(8);
1521 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1522 return VC_ERROR_OPERATION_FAILED;
1525 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1526 ret = regcomp(®[9], DATE_ABS3_REGEX[lang_type], cflags);
1528 regerror(ret, ®[9], errStr, sizeof(errStr));
1529 __vc_cmd_regex_deinit(9);
1531 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1532 return VC_ERROR_OPERATION_FAILED;
1535 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1536 ret = regcomp(®[10], DATE_PHR1_REGEX[lang_type], cflags);
1538 regerror(ret, ®[10], errStr, sizeof(errStr));
1539 __vc_cmd_regex_deinit(10);
1541 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1542 return VC_ERROR_OPERATION_FAILED;
1545 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1546 ret = regcomp(®[11], DATE_PHR2_REGEX[lang_type], cflags);
1548 regerror(ret, ®[11], errStr, sizeof(errStr));
1549 __vc_cmd_regex_deinit(11);
1551 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1552 return VC_ERROR_OPERATION_FAILED;
1555 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
1556 SLOG(LOG_DEBUG, TAG_VCCMD, "");
1558 return VC_ERROR_NONE;
1561 static void __vc_cmd_add_year(struct tm *td, int year)
1563 td->tm_year += year;
1566 static void __vc_cmd_add_mon(struct tm *td, int mon)
1570 mon = td->tm_mon + mon;
1574 __vc_cmd_add_year(td, year);
1577 td->tm_mon = mon % 12;
1580 static void __vc_cmd_add_mday(struct tm *td, int mday)
1582 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1583 int year = td->tm_year + 1900;
1587 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1589 mday = td->tm_mday + mday;
1591 for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1592 mday -= max_day[mon % 12];
1594 if (11 == mon % 12) {
1597 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1605 mon = mon - td->tm_mon;
1608 __vc_cmd_add_mon(td, mon);
1614 static void __vc_cmd_add_hour(struct tm *td, int hour)
1618 hour = td->tm_hour + hour;
1622 __vc_cmd_add_mday(td, day);
1625 td->tm_hour = hour % 24;
1628 static void __vc_cmd_add_min(struct tm *td, int min)
1632 min = td->tm_min + min;
1636 __vc_cmd_add_hour(td, hour);
1639 td->tm_min = min % 60;
1642 static void __copy_struct_tm(struct tm *des, struct tm *src)
1644 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Start to copy struct tm ====");
1646 des->tm_sec = src->tm_sec;
1647 des->tm_min = src->tm_min;
1648 des->tm_hour = src->tm_hour;
1649 des->tm_mday = src->tm_mday;
1650 des->tm_mon = src->tm_mon;
1651 des->tm_year = src->tm_year;
1652 des->tm_wday = src->tm_wday;
1653 des->tm_yday = src->tm_yday;
1654 des->tm_isdst = src->tm_isdst;
1656 des->tm_gmtoff = src->tm_gmtoff;
1657 des->tm_zone = src->tm_zone;
1660 static void __update_data_sidx(int idx)
1662 if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1665 static void __update_data_eidx(int idx)
1667 if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1670 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1672 regmatch_t pmatch[3];
1678 ret = regexec(®[6], str, 3, pmatch, 0);
1681 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1683 if (12 < td->tm_hour) {
1684 __vc_cmd_add_mday(td, 1);
1690 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1692 __vc_cmd_add_mday(td, 1);
1697 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1699 __update_data_sidx(pmatch[0].rm_so);
1700 __update_data_eidx(pmatch[0].rm_eo);
1703 return VC_ERROR_NONE;
1706 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1707 return VC_ERROR_NONE;
1710 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1712 regmatch_t pmatch[2];
1720 char *tempstr = NULL;
1723 ret = regexec(®[3], str, 1, pmatch, 0);
1725 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1728 sidx = pmatch[0].rm_so;
1729 eidx = pmatch[0].rm_eo;
1731 ret = regexec(®[4], str, 2, pmatch, 0);
1733 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1734 tempstr = strndup(str + pmatch[1].rm_so, len);
1736 if (NULL == tempstr) {
1737 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1738 return VC_ERROR_OUT_OF_MEMORY;
1741 hour = atoi(tempstr);
1746 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1748 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1749 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1752 ret = regexec(®[5], str, 2, pmatch, 0);
1754 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1755 tempstr = strndup(str + pmatch[1].rm_so, len);
1757 if (NULL == tempstr) {
1758 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1759 return VC_ERROR_OUT_OF_MEMORY;
1762 min = atoi(tempstr);
1767 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1769 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1770 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1773 if (hour < 0 && min < 0) {
1774 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1775 return VC_ERROR_NONE;
1778 hour = 0 > hour ? 0 : hour;
1779 min = 0 > min ? 0 : min;
1781 min = min + (hour * 60);
1783 __vc_cmd_add_min(td, min);
1786 __update_data_sidx(sidx);
1787 __update_data_eidx(eidx);
1790 return VC_ERROR_NONE;
1793 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1794 return VC_ERROR_NONE;
1797 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1799 regmatch_t pmatch[5];
1808 char *tempstr = NULL;
1811 ret = regexec(®[0], str, 5, pmatch, 0);
1813 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1817 sidx = pmatch[0].rm_so;
1818 eidx = pmatch[0].rm_eo;
1821 ret = regexec(®[1], str, 2, pmatch, 0);
1823 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1824 tempstr = strndup(str + pmatch[1].rm_so, len);
1826 if (NULL == tempstr) {
1827 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1828 return VC_ERROR_OUT_OF_MEMORY;
1831 hour = atoi(tempstr);
1834 hour = hour + 12 * flag;
1836 if (12 == hour) hour = 0;
1837 else if (24 == hour) hour = 12;
1840 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1841 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1842 return VC_ERROR_NONE;
1848 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1850 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1851 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1852 } else if (0 < flag) {
1853 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1854 return VC_ERROR_NONE;
1857 ret = regexec(®[2], str, 2, pmatch, 0);
1860 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1862 tempstr = strndup(str + pmatch[idx].rm_so, len);
1864 if (NULL == tempstr) {
1865 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1866 return VC_ERROR_OUT_OF_MEMORY;
1869 min = atoi(tempstr);
1871 if (0 > min || 60 <= min) {
1872 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1873 return VC_ERROR_NONE;
1885 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1886 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1887 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1890 if (0 > hour && 0 > min) {
1891 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1892 return VC_ERROR_NONE;
1895 if (0 <= min && 0 <= hour) {
1896 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1900 } else if (0 <= min) {
1902 vc_config_mgr_get_default_language(&lang);
1904 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1905 return VC_ERROR_OPERATION_FAILED;
1908 if (!strcmp("en_US", lang)) {
1909 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1912 return VC_ERROR_NONE;
1914 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1921 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1929 __update_data_sidx(sidx);
1930 __update_data_eidx(eidx);
1933 return VC_ERROR_NONE;
1936 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
1938 regmatch_t pmatch[10];
1944 ret = regexec(®[10], str, 5, pmatch, 0);
1946 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1948 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1950 td->tm_year = td_now.tm_year;
1951 td->tm_mon = td_now.tm_mon;
1952 td->tm_mday = td_now.tm_mday;
1954 __vc_cmd_add_mday(td, idx - 1);
1956 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1958 __update_data_sidx(pmatch[0].rm_so);
1959 __update_data_eidx(pmatch[0].rm_eo);
1962 return VC_ERROR_NONE;
1965 ret = regexec(®[11], str, 10, pmatch, 0);
1967 for (idx = 1; 10 > idx; idx++) {
1968 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1973 td->tm_year = td_now.tm_year;
1974 td->tm_mon = td_now.tm_mon;
1975 td->tm_mday = td_now.tm_mday;
1977 __vc_cmd_add_mday(td, idx + 1);
1979 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1981 __update_data_sidx(pmatch[0].rm_so);
1982 __update_data_eidx(pmatch[0].rm_eo);
1985 return VC_ERROR_NONE;
1988 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1989 return VC_ERROR_NONE;
1992 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
1994 regmatch_t pmatch[13];
2005 char *tempstr = NULL;
2008 ret = regexec(®[9], str, 2, pmatch, 0);
2010 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2011 tempstr = strndup(str + pmatch[1].rm_so, len);
2013 if (NULL == tempstr) {
2014 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2015 return VC_ERROR_OUT_OF_MEMORY;
2018 day = atoi(tempstr);
2023 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2025 sidx = pmatch[0].rm_so;
2026 eidx = pmatch[0].rm_eo;
2028 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2029 return VC_ERROR_NONE;
2032 ret = regexec(®[8], str, 13, pmatch, 0);
2034 for (idx = 1; 13 > idx; idx++) {
2035 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2045 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2047 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2048 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2051 vc_config_mgr_get_default_language(&lang);
2053 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2054 return VC_ERROR_OPERATION_FAILED;
2057 if (!strcmp("en_US", lang)) {
2058 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2061 return VC_ERROR_NONE;
2070 ret = regexec(®[7], str, 3, pmatch, 0);
2072 if (!m_flag) return -1;
2074 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2075 tempstr = strndup(str + pmatch[2].rm_so, len);
2077 if (NULL == tempstr) {
2078 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2079 return VC_ERROR_OUT_OF_MEMORY;
2082 year = atoi(tempstr);
2083 year = 1900 < year ? year - 1900 : year + 100;
2089 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2091 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2092 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2097 if (0 > g_time_flag) {
2101 } else if (2 == g_time_flag) {
2102 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2103 return VC_ERROR_NONE;
2106 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2107 if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2109 if (max_day[mon] < day || 1 > day) {
2110 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2111 return VC_ERROR_NONE;
2120 if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2122 if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2123 else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2127 __update_data_sidx(sidx);
2128 __update_data_eidx(eidx);
2131 return VC_ERROR_NONE;
2134 static int __vc_cmd_time_check(const char *str, struct tm *td)
2136 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Check time value in string \"%s\"", str);
2141 ret = __vc_cmd_tphrase_check(str, td, &exist);
2145 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2147 } else if (VC_ERROR_NONE != ret) {
2148 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2152 ret = __vc_cmd_trelative_check(str, td, &exist);
2156 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2158 } else if (VC_ERROR_NONE != ret) {
2159 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2163 ret = __vc_cmd_tabsolute_check(str, td, &exist);
2167 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Time value is exist");
2169 } else if (VC_ERROR_NONE != ret) {
2170 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2174 SLOG(LOG_DEBUG, TAG_VCCMD, "==== There is no time value");
2175 return VC_ERROR_NONE;
2178 static int __vc_cmd_date_check(const char *str, struct tm *td)
2180 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Check date value in string \"%s\"", str);
2185 ret = __vc_cmd_dphrase_check(str, td, &exist);
2189 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Date value is exist");
2191 } else if (VC_ERROR_NONE != ret) {
2192 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2196 ret = __vc_cmd_dabsolute_check(str, td, &exist);
2200 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Date value is exist");
2202 } else if (VC_ERROR_NONE != ret) {
2203 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2207 SLOG(LOG_DEBUG, TAG_VCCMD, "==== There is no date value");
2208 return VC_ERROR_NONE;
2211 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2213 SLOG(LOG_DEBUG, TAG_VCCMD, "==== Get timestamp data");
2216 const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2219 if (NULL == text || NULL == result || NULL == remain) {
2220 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2221 return VC_ERROR_INVALID_PARAMETER;
2225 ret = __vc_cmd_regex_init();
2226 if (VC_ERROR_NONE != ret) {
2227 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2231 g_data_sidx = g_data_eidx = -1;
2234 localtime_r(&t_now, &td_now);
2235 SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2237 __copy_struct_tm(&td, &td_now);
2238 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2239 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);
2241 g_time_flag = g_date_flag = -1;
2243 ret = __vc_cmd_time_check(text, &td);
2244 if (VC_ERROR_NONE != ret) {
2245 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2249 ret = __vc_cmd_date_check(text, &td);
2250 if (VC_ERROR_NONE != ret) {
2251 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2255 __vc_cmd_regex_deinit(12);
2257 if (g_time_flag > 0 || g_date_flag > 0) {
2258 *result = mktime(&td);
2260 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %d", *result);
2261 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2262 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);
2264 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2266 if (NULL == *remain) {
2267 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2268 return VC_ERROR_OUT_OF_MEMORY;
2271 strncpy(*remain, text, g_data_sidx);
2272 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2274 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2277 SLOG(LOG_DEBUG, TAG_VCCMD, "====");
2278 SLOG(LOG_DEBUG, TAG_VCCMD, "");
2280 return VC_ERROR_NONE;