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;
40 static GList *g_cmdlist_list = NULL;
43 // For getting timestamp using regular expression
44 static regex_t reg[MAX_NUM_REGEX];
45 static time_t t_now; //time_t is based on UTC
46 static struct tm td_now; //if use localtime function, the value follows the local time zone, otherwise it follows the UTC.
48 static int g_time_flag;
49 static int g_date_flag;
51 static int g_data_sidx;
52 static int g_data_eidx;
54 static int __vc_cmd_get_feature_enabled()
56 if (0 == g_feature_enabled) {
57 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
58 return VC_ERROR_NOT_SUPPORTED;
59 } else if (-1 == g_feature_enabled) {
60 bool vc_supported = false;
61 bool mic_supported = false;
62 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
63 if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
64 if (false == vc_supported || false == mic_supported) {
65 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Voice control feature NOT supported");
66 g_feature_enabled = 0;
67 return VC_ERROR_NOT_SUPPORTED;
70 g_feature_enabled = 1;
72 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
73 return VC_ERROR_NOT_SUPPORTED;
76 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get feature value");
77 return VC_ERROR_NOT_SUPPORTED;
84 static int __check_privilege_initialize()
86 int ret = cynara_initialize(&p_cynara, NULL);
87 if (CYNARA_API_SUCCESS != ret)
88 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to initialize");
90 return ret == CYNARA_API_SUCCESS;
93 static int __check_privilege(const char* uid, const char * privilege)
96 char label_path[1024] = "/proc/self/attr/current";
97 char smack_label[1024] = {'\0',};
103 fp = fopen(label_path, "r");
105 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
106 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] fail to fread");
111 pid_t pid = getpid();
112 char *session = cynara_session_from_pid(pid);
113 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
114 SLOG(LOG_DEBUG, TAG_VCCMD, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
118 if (ret != CYNARA_API_ACCESS_ALLOWED)
123 static void __check_privilege_deinitialize()
126 cynara_finish(p_cynara);
130 static int __vc_cmd_check_privilege()
134 if (0 == g_privilege_allowed) {
135 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
136 return VC_ERROR_PERMISSION_DENIED;
137 } else if (-1 == g_privilege_allowed) {
138 if (false == __check_privilege_initialize()) {
139 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] privilege initialize is failed");
140 return VC_ERROR_PERMISSION_DENIED;
142 snprintf(uid, 16, "%d", getuid());
143 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
144 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
145 g_privilege_allowed = 0;
146 __check_privilege_deinitialize();
147 return VC_ERROR_PERMISSION_DENIED;
149 __check_privilege_deinitialize();
152 g_privilege_allowed = 1;
154 return VC_ERROR_NONE;
157 int vc_cmd_list_create(vc_cmd_list_h* vc_cmd_list)
159 if (0 != __vc_cmd_get_feature_enabled()) {
160 return VC_ERROR_NOT_SUPPORTED;
162 if (0 != __vc_cmd_check_privilege()) {
163 return VC_ERROR_PERMISSION_DENIED;
166 if (NULL == vc_cmd_list) {
167 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
168 return VC_ERROR_INVALID_PARAMETER;
171 vc_cmd_list_s* list = (vc_cmd_list_s*)calloc(1, sizeof(vc_cmd_list_s));
174 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
175 return VC_ERROR_OUT_OF_MEMORY;
181 *vc_cmd_list = (vc_cmd_list_h)list;
183 g_cmdlist_list = g_list_append(g_cmdlist_list, list);
185 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
187 return VC_ERROR_NONE;
190 int vc_cmd_list_destroy(vc_cmd_list_h vc_cmd_list, bool release_command)
192 if (0 != __vc_cmd_get_feature_enabled()) {
193 return VC_ERROR_NOT_SUPPORTED;
195 if (0 != __vc_cmd_check_privilege()) {
196 return VC_ERROR_PERMISSION_DENIED;
199 if (NULL == vc_cmd_list) {
200 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
201 return VC_ERROR_INVALID_PARAMETER;
204 vc_cmd_list_remove_all(vc_cmd_list, release_command);
206 vc_cmd_list_s* list = NULL;
207 list = (vc_cmd_list_s*)vc_cmd_list;
209 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", list);
212 vc_cmd_list_s *data = NULL;
214 /* if list have item */
215 if (g_list_length(g_cmdlist_list) > 0) {
216 /* Get a first item */
217 iter = g_list_first(g_cmdlist_list);
219 while (NULL != iter) {
221 if (data && list == data) {
222 g_cmdlist_list = g_list_remove_link(g_cmdlist_list, iter);
227 SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
230 return VC_ERROR_NONE;
233 iter = g_list_next(iter);
236 SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
238 return VC_ERROR_INVALID_PARAMETER;
241 int vc_cmd_list_get_count(vc_cmd_list_h vc_cmd_list, int* count)
243 if (0 != __vc_cmd_get_feature_enabled()) {
244 return VC_ERROR_NOT_SUPPORTED;
246 if (0 != __vc_cmd_check_privilege()) {
247 return VC_ERROR_PERMISSION_DENIED;
250 if (NULL == vc_cmd_list || NULL == count) {
251 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Get command count : Input parameter is NULL");
252 return VC_ERROR_INVALID_PARAMETER;
255 vc_cmd_list_s* list = NULL;
256 list = (vc_cmd_list_s*)vc_cmd_list;
258 *count = g_slist_length(list->list);
260 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), count(%d)", list, *count);
262 return VC_ERROR_NONE;
265 int vc_cmd_list_add(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
267 if (0 != __vc_cmd_get_feature_enabled()) {
268 return VC_ERROR_NOT_SUPPORTED;
270 if (0 != __vc_cmd_check_privilege()) {
271 return VC_ERROR_PERMISSION_DENIED;
274 if (NULL == vc_cmd_list || NULL == vc_command) {
275 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
276 return VC_ERROR_INVALID_PARAMETER;
279 vc_cmd_list_s* list = NULL;
280 list = (vc_cmd_list_s*)vc_cmd_list;
282 vc_cmd_s* cmd = NULL;
283 cmd = (vc_cmd_s*)vc_command;
285 list->list = g_slist_append(list->list, cmd);
287 if (1 == g_slist_length(list->list)) {
291 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
293 return VC_ERROR_NONE;
296 int vc_cmd_list_remove(vc_cmd_list_h vc_cmd_list, vc_cmd_h vc_command)
298 if (0 != __vc_cmd_get_feature_enabled()) {
299 return VC_ERROR_NOT_SUPPORTED;
301 if (0 != __vc_cmd_check_privilege()) {
302 return VC_ERROR_PERMISSION_DENIED;
305 if (NULL == vc_cmd_list || NULL == vc_command) {
306 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
307 return VC_ERROR_INVALID_PARAMETER;
310 vc_cmd_list_s* list = NULL;
311 list = (vc_cmd_list_s*)vc_cmd_list;
313 vc_cmd_s* cmd = NULL;
314 cmd = (vc_cmd_s*)vc_command;
316 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p), command(%p)", list, cmd);
318 vc_cmd_s* temp_cmd = NULL;
321 iter = g_slist_nth(list->list, 0);
323 while (NULL != iter) {
324 temp_cmd = iter->data;
326 if (NULL != temp_cmd && cmd == temp_cmd) {
327 list->list = g_slist_remove(list->list, temp_cmd);
329 if (true == release_command) {
330 SLOG(LOG_DEBUG, TAG_VCCMD, "Release command data");
331 if (NULL != temp_cmd->command) free(temp_cmd->command);
332 if (NULL != temp_cmd->parameter) free(temp_cmd->parameter);
339 iter = g_slist_next(iter);
342 int count = g_slist_length(list->list);
346 } else if (list->index == count) {
347 list->index = count - 1;
350 return VC_ERROR_NONE;
353 int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
355 if (0 != __vc_cmd_get_feature_enabled()) {
356 return VC_ERROR_NOT_SUPPORTED;
358 if (0 != __vc_cmd_check_privilege()) {
359 return VC_ERROR_PERMISSION_DENIED;
362 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Destroy all command");
364 if (NULL == vc_cmd_list) {
365 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
366 return VC_ERROR_INVALID_PARAMETER;
369 vc_cmd_list_s* list = NULL;
370 list = (vc_cmd_list_s*)vc_cmd_list;
372 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
373 , list, release_command ? "true" : "false");
375 int count = g_slist_length(list->list);
380 for (i = 0; i < count ; i++) {
381 temp_cmd = g_slist_nth_data(list->list, 0);
383 if (NULL != temp_cmd) {
384 list->list = g_slist_remove(list->list, temp_cmd);
386 if (true == release_command) {
387 SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp_cmd);
388 if (NULL != temp_cmd->command) free(temp_cmd->command);
389 if (NULL != temp_cmd->parameter) free(temp_cmd->parameter);
390 if (NULL != temp_cmd->appid) free(temp_cmd->appid);
391 if (NULL != temp_cmd->invocation_name) free(temp_cmd->invocation_name);
392 if (NULL != temp_cmd->fixed) free(temp_cmd->fixed);
401 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
403 return VC_ERROR_NONE;
406 int vc_cmd_list_foreach_commands(vc_cmd_list_h vc_cmd_list, vc_cmd_list_cb callback, void* user_data)
408 if (0 != __vc_cmd_get_feature_enabled()) {
409 return VC_ERROR_NOT_SUPPORTED;
411 if (0 != __vc_cmd_check_privilege()) {
412 return VC_ERROR_PERMISSION_DENIED;
415 if (NULL == vc_cmd_list) {
416 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
417 return VC_ERROR_INVALID_PARAMETER;
420 vc_cmd_list_s* list = NULL;
421 list = (vc_cmd_list_s*)vc_cmd_list;
423 int count = g_slist_length(list->list);
429 iter = g_slist_nth(list->list, 0);
431 for (i = 0; i < count; i++) {
433 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
434 return VC_ERROR_OPERATION_FAILED;
437 temp_cmd = iter->data;
439 if (NULL != temp_cmd) {
440 if (false == callback((vc_cmd_h)temp_cmd, user_data)) {
445 iter = g_slist_next(iter);
448 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Foreach commands Done");
450 return VC_ERROR_NONE;
453 int vc_cmd_list_filter_by_type(vc_cmd_list_h original, int type, vc_cmd_list_h* filtered)
455 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Filter by type");
457 if (0 != __vc_cmd_get_feature_enabled()) {
458 return VC_ERROR_NOT_SUPPORTED;
460 if (0 != __vc_cmd_check_privilege()) {
461 return VC_ERROR_PERMISSION_DENIED;
464 if (NULL == original) {
465 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
466 return VC_ERROR_INVALID_PARAMETER;
469 if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
470 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type");
471 return VC_ERROR_INVALID_PARAMETER;
474 vc_cmd_list_s* list = NULL;
475 list = (vc_cmd_list_s*)original;
477 vc_cmd_list_h temp_list;
478 if (0 != vc_cmd_list_create(&temp_list)) {
479 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to list create");
480 return VC_ERROR_OPERATION_FAILED;
483 int count = g_slist_length(list->list);
489 iter = g_slist_nth(list->list, 0);
491 for (i = 0; i < count; i++) {
493 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] No command in list");
494 return VC_ERROR_OPERATION_FAILED;
496 if (NULL != iter->data) {
497 iter_cmd = iter->data;
499 if (NULL != iter_cmd) {
501 if (0 != vc_cmd_get_type((vc_cmd_h)iter_cmd, &iter_type)) {
502 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get command type");
506 if (iter_type == type) {
508 if (0 != vc_cmd_create(&temp_cmd)) {
509 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to create cmd");
513 memcpy(temp_cmd, iter_cmd, sizeof(vc_cmd_s));
514 if (NULL != iter_cmd->command) {
515 ((vc_cmd_s*)temp_cmd)->command = strdup(iter_cmd->command);
517 if (NULL != iter_cmd->parameter) {
518 ((vc_cmd_s*)temp_cmd)->parameter = strdup(iter_cmd->parameter);
521 if (0 != vc_cmd_list_add(temp_list, temp_cmd)) {
522 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to cmd list add");
523 vc_cmd_destroy(temp_cmd);
529 iter = g_slist_next(iter);
533 if (0 != vc_cmd_list_get_count(temp_list, &count)) {
534 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get count");
536 SLOG(LOG_DEBUG, TAG_VCCMD, "Filtering result : (%d) command", count);
539 *filtered = temp_list;
541 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
543 return VC_ERROR_NONE;
546 int vc_cmd_list_first(vc_cmd_list_h vc_cmd_list)
548 if (0 != __vc_cmd_get_feature_enabled()) {
549 return VC_ERROR_NOT_SUPPORTED;
551 if (0 != __vc_cmd_check_privilege()) {
552 return VC_ERROR_PERMISSION_DENIED;
555 if (NULL == vc_cmd_list) {
556 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
557 return VC_ERROR_INVALID_PARAMETER;
560 vc_cmd_list_s* list = NULL;
561 list = (vc_cmd_list_s*)vc_cmd_list;
563 if (0 == g_slist_length(list->list)) {
564 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
565 return VC_ERROR_EMPTY;
570 return VC_ERROR_NONE;
573 int vc_cmd_list_last(vc_cmd_list_h vc_cmd_list)
575 if (0 != __vc_cmd_get_feature_enabled()) {
576 return VC_ERROR_NOT_SUPPORTED;
578 if (0 != __vc_cmd_check_privilege()) {
579 return VC_ERROR_PERMISSION_DENIED;
582 if (NULL == vc_cmd_list) {
583 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
584 return VC_ERROR_INVALID_PARAMETER;
587 vc_cmd_list_s* list = NULL;
588 list = (vc_cmd_list_s*)vc_cmd_list;
590 int count = g_slist_length(list->list);
593 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
594 return VC_ERROR_EMPTY;
596 list->index = count - 1;
597 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
600 return VC_ERROR_NONE;
603 int vc_cmd_list_next(vc_cmd_list_h vc_cmd_list)
605 if (0 != __vc_cmd_get_feature_enabled()) {
606 return VC_ERROR_NOT_SUPPORTED;
608 if (0 != __vc_cmd_check_privilege()) {
609 return VC_ERROR_PERMISSION_DENIED;
612 if (NULL == vc_cmd_list) {
613 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
614 return VC_ERROR_INVALID_PARAMETER;
617 vc_cmd_list_s* list = NULL;
618 list = (vc_cmd_list_s*)vc_cmd_list;
620 int count = g_slist_length(list->list);
622 if (list->index < count - 1) {
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_prev(vc_cmd_list_h vc_cmd_list)
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) {
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 if (list->index > 0) {
651 list->index = list->index - 1;
652 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
654 SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
655 return VC_ERROR_ITERATION_END;
658 return VC_ERROR_NONE;
661 int vc_cmd_list_get_current(vc_cmd_list_h vc_cmd_list, vc_cmd_h* vc_command)
663 if (0 != __vc_cmd_get_feature_enabled()) {
664 return VC_ERROR_NOT_SUPPORTED;
666 if (0 != __vc_cmd_check_privilege()) {
667 return VC_ERROR_PERMISSION_DENIED;
670 if (NULL == vc_cmd_list || NULL == vc_command) {
671 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
672 return VC_ERROR_INVALID_PARAMETER;
675 vc_cmd_list_s* list = NULL;
676 list = (vc_cmd_list_s*)vc_cmd_list;
678 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), index (%d)", list, list->index);
680 if (0 == g_slist_length(list->list)) {
681 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list is empty");
683 return VC_ERROR_EMPTY;
686 vc_cmd_s *temp_cmd = NULL;
687 temp_cmd = g_slist_nth_data(list->list, list->index);
689 *vc_command = (vc_cmd_h)temp_cmd;
691 SLOG(LOG_DEBUG, TAG_VCCMD, "[List] Get current command (%p)", *vc_command);
693 return VC_ERROR_NONE;
697 int vc_cmd_create(vc_cmd_h* vc_command)
699 if (0 != __vc_cmd_get_feature_enabled()) {
700 return VC_ERROR_NOT_SUPPORTED;
702 if (0 != __vc_cmd_check_privilege()) {
703 return VC_ERROR_PERMISSION_DENIED;
706 if (NULL == vc_command) {
707 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
708 return VC_ERROR_INVALID_PARAMETER;
711 vc_cmd_s* command = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
713 if (NULL == command) {
714 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
715 return VC_ERROR_OUT_OF_MEMORY;
721 command->type = VC_COMMAND_TYPE_NONE;
722 command->format = VC_CMD_FORMAT_FIXED;
723 command->command = NULL;
724 command->parameter = NULL;
726 command->priority = 0;
727 command->key = VC_KEY_NONE;
728 command->modifier = VC_MODIFIER_NONE;
729 command->invocation_name = NULL;
730 command->appid = NULL;
731 command->fixed = NULL;
732 command->coordinates = NULL;
734 *vc_command = (vc_cmd_h)command;
736 SLOG(LOG_DEBUG, TAG_VCCMD, "[Create command][%p]", *vc_command);
738 return VC_ERROR_NONE;
741 int vc_cmd_destroy(vc_cmd_h vc_command)
743 if (0 != __vc_cmd_get_feature_enabled()) {
744 return VC_ERROR_NOT_SUPPORTED;
746 if (0 != __vc_cmd_check_privilege()) {
747 return VC_ERROR_PERMISSION_DENIED;
750 if (NULL == vc_command) {
751 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
752 return VC_ERROR_INVALID_PARAMETER;
755 vc_cmd_s* command = NULL;
756 command = (vc_cmd_s*)vc_command;
758 SLOG(LOG_DEBUG, TAG_VCCMD, "[Destroy command][%p]", command);
760 if (NULL != command) {
761 if (NULL != command->command) {
762 free(command->command);
763 command->command = NULL;
765 if (NULL != command->parameter) {
766 free(command->parameter);
767 command->parameter = NULL;
769 if (NULL != command->invocation_name) {
770 free(command->invocation_name);
771 command->invocation_name = NULL;
773 if (NULL != command->appid) {
774 free(command->appid);
775 command->appid = NULL;
777 if (NULL != command->fixed) {
778 free(command->fixed);
779 command->fixed = NULL;
781 if (NULL != command->coordinates) {
782 free(command->coordinates);
783 command->coordinates = NULL;
789 return VC_ERROR_NONE;
792 int vc_cmd_set_id(vc_cmd_h vc_command, int id)
794 if (0 != __vc_cmd_get_feature_enabled()) {
795 return VC_ERROR_NOT_SUPPORTED;
797 if (0 != __vc_cmd_check_privilege()) {
798 return VC_ERROR_PERMISSION_DENIED;
801 if (NULL == vc_command) {
802 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
803 return VC_ERROR_INVALID_PARAMETER;
806 vc_cmd_s* cmd = NULL;
807 cmd = (vc_cmd_s*)vc_command;
811 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
817 int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
819 if (0 != __vc_cmd_get_feature_enabled()) {
820 return VC_ERROR_NOT_SUPPORTED;
822 if (0 != __vc_cmd_check_privilege()) {
823 return VC_ERROR_PERMISSION_DENIED;
826 if (NULL == vc_command || NULL == id) {
827 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
828 return VC_ERROR_INVALID_PARAMETER;
831 vc_cmd_s* cmd = NULL;
832 cmd = (vc_cmd_s*)vc_command;
836 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
842 int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
844 if (0 != __vc_cmd_get_feature_enabled()) {
845 return VC_ERROR_NOT_SUPPORTED;
848 if (NULL == vc_command) {
849 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
850 return VC_ERROR_INVALID_PARAMETER;
854 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, appid is NULL");
855 return VC_ERROR_INVALID_PARAMETER;
858 vc_cmd_s* cmd = NULL;
859 cmd = (vc_cmd_s*)vc_command;
861 if (NULL != cmd->appid) {
866 cmd->appid = strdup(appid);
868 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
872 int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
874 if (0 != __vc_cmd_get_feature_enabled()) {
875 return VC_ERROR_NOT_SUPPORTED;
878 if (NULL == vc_command || NULL == appid) {
879 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
880 return VC_ERROR_INVALID_PARAMETER;
883 vc_cmd_s* cmd = NULL;
884 cmd = (vc_cmd_s*)vc_command;
886 if (NULL != cmd->appid) {
887 *appid = strdup(gettext(cmd->appid));
890 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
894 int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
896 if (0 != __vc_cmd_get_feature_enabled()) {
897 return VC_ERROR_NOT_SUPPORTED;
899 if (0 != __vc_cmd_check_privilege()) {
900 return VC_ERROR_PERMISSION_DENIED;
903 if (NULL == vc_command) {
904 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
905 return VC_ERROR_INVALID_PARAMETER;
908 vc_cmd_s* cmd = NULL;
909 cmd = (vc_cmd_s*)vc_command;
911 if (NULL != cmd->command) {
917 if (NULL != command) {
918 cmd->command = strdup(command);
921 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
926 int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
928 if (0 != __vc_cmd_get_feature_enabled()) {
929 return VC_ERROR_NOT_SUPPORTED;
931 if (0 != __vc_cmd_check_privilege()) {
932 return VC_ERROR_PERMISSION_DENIED;
935 if (NULL == vc_command || NULL == command) {
936 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
937 return VC_ERROR_INVALID_PARAMETER;
940 vc_cmd_s* cmd = NULL;
941 cmd = (vc_cmd_s*)vc_command;
943 if (NULL != cmd->command) {
944 *command = strdup(gettext(cmd->command));
947 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
952 int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
954 if (0 != __vc_cmd_get_feature_enabled()) {
955 return VC_ERROR_NOT_SUPPORTED;
957 if (0 != __vc_cmd_check_privilege()) {
958 return VC_ERROR_PERMISSION_DENIED;
961 if (NULL == vc_command) {
962 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
963 return VC_ERROR_INVALID_PARAMETER;
966 vc_cmd_s* cmd = NULL;
967 cmd = (vc_cmd_s*)vc_command;
969 if (NULL != cmd->parameter) {
970 free(cmd->parameter);
973 cmd->parameter = NULL;
975 if (NULL != command) {
976 cmd->parameter = strdup(command);
977 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
983 int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
985 if (0 != __vc_cmd_get_feature_enabled()) {
986 return VC_ERROR_NOT_SUPPORTED;
989 if (NULL == vc_command || NULL == command) {
990 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
991 return VC_ERROR_INVALID_PARAMETER;
994 vc_cmd_s* cmd = NULL;
995 cmd = (vc_cmd_s*)vc_command;
997 if (NULL != cmd->parameter) {
998 *command = strdup(gettext(cmd->parameter));
999 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
1005 int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
1007 if (0 != __vc_cmd_get_feature_enabled()) {
1008 return VC_ERROR_NOT_SUPPORTED;
1011 if (NULL == vc_command) {
1012 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1013 return VC_ERROR_INVALID_PARAMETER;
1016 if (NULL == fixed) {
1017 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, fixed is NULL");
1018 return VC_ERROR_INVALID_PARAMETER;
1021 vc_cmd_s* cmd = NULL;
1022 cmd = (vc_cmd_s*)vc_command;
1024 if (NULL != cmd->fixed) {
1029 cmd->fixed = strdup(fixed);
1031 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
1035 int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
1037 if (0 != __vc_cmd_get_feature_enabled()) {
1038 return VC_ERROR_NOT_SUPPORTED;
1041 if (NULL == vc_command || NULL == fixed) {
1042 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1043 return VC_ERROR_INVALID_PARAMETER;
1046 vc_cmd_s* cmd = NULL;
1047 cmd = (vc_cmd_s*)vc_command;
1049 if (NULL != cmd->fixed) {
1050 *fixed = strdup(gettext(cmd->fixed));
1051 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
1057 int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
1059 if (0 != __vc_cmd_get_feature_enabled()) {
1060 return VC_ERROR_NOT_SUPPORTED;
1063 if (NULL == vc_command) {
1064 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, vc_command is NULL");
1065 return VC_ERROR_INVALID_PARAMETER;
1068 if (NULL == invocation_name) {
1069 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter, invocation_name is NULL");
1070 return VC_ERROR_INVALID_PARAMETER;
1073 vc_cmd_s* cmd = NULL;
1074 cmd = (vc_cmd_s*)vc_command;
1076 if (NULL != cmd->invocation_name) {
1077 free(cmd->invocation_name);
1078 cmd->invocation_name = NULL;
1081 cmd->invocation_name = strdup(invocation_name);
1083 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
1087 int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
1089 if (0 != __vc_cmd_get_feature_enabled()) {
1090 return VC_ERROR_NOT_SUPPORTED;
1093 if (NULL == vc_command || NULL == invocation_name) {
1094 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid handle ");
1095 return VC_ERROR_INVALID_PARAMETER;
1098 vc_cmd_s* cmd = NULL;
1099 cmd = (vc_cmd_s*)vc_command;
1101 if (NULL != cmd->invocation_name) {
1102 *invocation_name = strdup(gettext(cmd->invocation_name));
1105 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
1109 int vc_cmd_set_type(vc_cmd_h vc_command, int type)
1111 if (0 != __vc_cmd_get_feature_enabled()) {
1112 return VC_ERROR_NOT_SUPPORTED;
1114 if (0 != __vc_cmd_check_privilege()) {
1115 return VC_ERROR_PERMISSION_DENIED;
1118 if (NULL == vc_command) {
1119 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1120 return VC_ERROR_INVALID_PARAMETER;
1123 vc_cmd_s* cmd = NULL;
1124 cmd = (vc_cmd_s*)vc_command;
1128 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
1133 int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
1135 if (0 != __vc_cmd_get_feature_enabled()) {
1136 return VC_ERROR_NOT_SUPPORTED;
1138 if (0 != __vc_cmd_check_privilege()) {
1139 return VC_ERROR_PERMISSION_DENIED;
1142 if (NULL == vc_command || NULL == type) {
1143 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1144 return VC_ERROR_INVALID_PARAMETER;
1147 vc_cmd_s* cmd = NULL;
1148 cmd = (vc_cmd_s*)vc_command;
1152 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
1157 int vc_cmd_set_format(vc_cmd_h vc_command, int format)
1159 if (0 != __vc_cmd_get_feature_enabled()) {
1160 return VC_ERROR_NOT_SUPPORTED;
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;
1171 cmd->format = format;
1173 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
1178 int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
1180 if (0 != __vc_cmd_get_feature_enabled()) {
1181 return VC_ERROR_NOT_SUPPORTED;
1184 if (NULL == vc_command || NULL == format) {
1185 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1186 return VC_ERROR_INVALID_PARAMETER;
1189 vc_cmd_s* cmd = NULL;
1190 cmd = (vc_cmd_s*)vc_command;
1192 *format = cmd->format;
1194 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
1199 int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
1201 if (0 != __vc_cmd_get_feature_enabled()) {
1202 return VC_ERROR_NOT_SUPPORTED;
1204 if (0 != __vc_cmd_check_privilege()) {
1205 return VC_ERROR_PERMISSION_DENIED;
1208 if (NULL == vc_command) {
1209 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1210 return VC_ERROR_INVALID_PARAMETER;
1213 vc_cmd_s* cmd = NULL;
1214 cmd = (vc_cmd_s*)vc_command;
1218 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
1223 int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
1225 if (0 != __vc_cmd_get_feature_enabled()) {
1226 return VC_ERROR_NOT_SUPPORTED;
1228 if (0 != __vc_cmd_check_privilege()) {
1229 return VC_ERROR_PERMISSION_DENIED;
1232 if (NULL == vc_command || NULL == pid) {
1233 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1234 return VC_ERROR_INVALID_PARAMETER;
1237 vc_cmd_s* cmd = NULL;
1238 cmd = (vc_cmd_s*)vc_command;
1242 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
1247 int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
1249 if (0 != __vc_cmd_get_feature_enabled()) {
1250 return VC_ERROR_NOT_SUPPORTED;
1252 if (0 != __vc_cmd_check_privilege()) {
1253 return VC_ERROR_PERMISSION_DENIED;
1256 if (NULL == vc_command) {
1257 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1258 return VC_ERROR_INVALID_PARAMETER;
1261 vc_cmd_s* cmd = NULL;
1262 cmd = (vc_cmd_s*)vc_command;
1264 cmd->domain = domain;
1266 SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
1271 int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
1273 if (0 != __vc_cmd_get_feature_enabled()) {
1274 return VC_ERROR_NOT_SUPPORTED;
1276 if (0 != __vc_cmd_check_privilege()) {
1277 return VC_ERROR_PERMISSION_DENIED;
1280 if (NULL == vc_command || NULL == domain) {
1281 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1282 return VC_ERROR_INVALID_PARAMETER;
1285 vc_cmd_s* cmd = NULL;
1286 cmd = (vc_cmd_s*)vc_command;
1288 *domain = cmd->domain;
1290 SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
1296 * @brief Sets key value of command.
1298 * @param[in] vc_command Command handle
1299 * @param[in] key key value
1300 * @param[in] 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_get_result_key()
1308 int vc_cmd_set_result_key(vc_cmd_h vc_command, int key, int modifier)
1310 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Set result key");
1312 if (NULL == vc_command) {
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;
1320 SLOG(LOG_DEBUG, TAG_VCCMD, "key : %d, modifier : %d", key, modifier);
1323 cmd->modifier = modifier;
1325 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1331 * @brief Gets key value of command.
1333 * @param[in] vc_command Command handle
1334 * @param[out] key key value
1335 * @param[out] modifier modifier value
1337 * @return 0 on success, otherwise a negative error value
1338 * @retval #VC_ERROR_NONE Successful
1339 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
1341 * @see vc_cmd_add_result_key()
1343 int vc_cmd_get_result_key(vc_cmd_h vc_command, int* key, int* modifier)
1345 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get result key");
1347 if (NULL == vc_command || NULL == key || NULL == modifier) {
1348 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
1349 return VC_ERROR_INVALID_PARAMETER;
1352 vc_cmd_s* cmd = NULL;
1353 cmd = (vc_cmd_s*)vc_command;
1356 *modifier = cmd->modifier;
1358 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1363 int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
1365 if (NULL == vc_cmd_list) {
1369 vc_cmd_list_s* list = NULL;
1370 list = (vc_cmd_list_s*)vc_cmd_list;
1372 SLOG(LOG_DEBUG, TAG_VCCMD, "@ Command List @");
1373 SLOG(LOG_DEBUG, TAG_VCCMD, "[List][%p]", list);
1375 int count = g_slist_length(list->list);
1378 vc_cmd_s *cmd = NULL;
1380 for (i = 0; i < count ; i++) {
1381 cmd = g_slist_nth_data(list->list, i);
1384 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)",
1385 i, cmd, cmd->pid, cmd->index, cmd->type, cmd->format, cmd->command, cmd->parameter, cmd->appid, cmd->invocation_name, cmd->fixed);
1389 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1394 int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
1396 if (0 != __vc_cmd_get_feature_enabled()) {
1397 return VC_ERROR_NOT_SUPPORTED;
1400 if (NULL == vc_cmd || NULL == json) {
1401 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] NULL parameter");
1402 return VC_ERROR_INVALID_PARAMETER;
1405 vc_cmd_s* cmd = NULL;
1406 cmd = (vc_cmd_s*)vc_cmd;
1408 if (VC_CMD_FORMAT_ACTION != cmd->format) {
1409 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not Action format");
1410 return VC_ERROR_INVALID_PARAMETER;
1413 if (0 != vc_info_parser_get_nlu_result(json)) {
1414 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get nlu result");
1415 return VC_ERROR_OPERATION_FAILED;
1421 static void __vc_cmd_regex_deinit(int num_regex)
1423 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start Deinitialize regex @@@");
1426 for (i = 0; num_regex > i; i++) {
1430 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1433 static int __vc_cmd_regex_init()
1435 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Initialize regular expression @@@");
1437 int cflags = REG_EXTENDED | REG_ICASE;
1443 vc_config_mgr_get_default_language(&lang);
1445 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1446 return VC_ERROR_OPERATION_FAILED;
1449 if (!strcmp("en_US", lang)) {
1451 } else if (!strcmp("ko_KR", lang)) {
1457 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not supported language type");
1458 return VC_ERROR_INVALID_LANGUAGE;
1464 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ lang type > %d @@@", lang_type);
1466 re_syntax_options = RE_SYNTAX_POSIX_EXTENDED;
1468 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s" , TIME_ABS1_REGEX[lang_type]);
1469 ret = regcomp(®[0], TIME_ABS1_REGEX[lang_type], cflags);
1471 regerror(ret, ®[0], errStr, sizeof(errStr));
1473 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1474 return VC_ERROR_OPERATION_FAILED;
1477 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS2_REGEX[lang_type]);
1478 ret = regcomp(®[1], TIME_ABS2_REGEX[lang_type], cflags);
1480 regerror(ret, ®[1], errStr, sizeof(errStr));
1481 __vc_cmd_regex_deinit(1);
1483 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1484 return VC_ERROR_OPERATION_FAILED;
1487 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_ABS3_REGEX[lang_type]);
1488 ret = regcomp(®[2], TIME_ABS3_REGEX[lang_type], cflags);
1490 regerror(ret, ®[2], errStr, sizeof(errStr));
1491 __vc_cmd_regex_deinit(2);
1493 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1494 return VC_ERROR_OPERATION_FAILED;
1497 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL1_REGEX[lang_type]);
1498 ret = regcomp(®[3], TIME_REL1_REGEX[lang_type], cflags);
1500 regerror(ret, ®[3], errStr, sizeof(errStr));
1501 __vc_cmd_regex_deinit(3);
1503 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1504 return VC_ERROR_OPERATION_FAILED;
1507 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL2_REGEX[lang_type]);
1508 ret = regcomp(®[4], TIME_REL2_REGEX[lang_type], cflags);
1510 regerror(ret, ®[4], errStr, sizeof(errStr));
1511 __vc_cmd_regex_deinit(4);
1513 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1514 return VC_ERROR_OPERATION_FAILED;
1517 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_REL3_REGEX[lang_type]);
1518 ret = regcomp(®[5], TIME_REL3_REGEX[lang_type], cflags);
1520 regerror(ret, ®[5], errStr, sizeof(errStr));
1521 __vc_cmd_regex_deinit(5);
1523 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1524 return VC_ERROR_OPERATION_FAILED;
1527 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", TIME_PHR_REGEX[lang_type]);
1528 ret = regcomp(®[6], TIME_PHR_REGEX[lang_type], cflags);
1530 regerror(ret, ®[6], errStr, sizeof(errStr));
1531 __vc_cmd_regex_deinit(6);
1533 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1534 return VC_ERROR_OPERATION_FAILED;
1537 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS1_REGEX[lang_type]);
1538 ret = regcomp(®[7], DATE_ABS1_REGEX[lang_type], cflags);
1540 regerror(ret, ®[7], errStr, sizeof(errStr));
1541 __vc_cmd_regex_deinit(7);
1543 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1544 return VC_ERROR_OPERATION_FAILED;
1547 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS2_REGEX[lang_type]);
1548 ret = regcomp(®[8], DATE_ABS2_REGEX[lang_type], cflags);
1550 regerror(ret, ®[8], errStr, sizeof(errStr));
1551 __vc_cmd_regex_deinit(8);
1553 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1554 return VC_ERROR_OPERATION_FAILED;
1557 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_ABS3_REGEX[lang_type]);
1558 ret = regcomp(®[9], DATE_ABS3_REGEX[lang_type], cflags);
1560 regerror(ret, ®[9], errStr, sizeof(errStr));
1561 __vc_cmd_regex_deinit(9);
1563 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1564 return VC_ERROR_OPERATION_FAILED;
1567 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR1_REGEX[lang_type]);
1568 ret = regcomp(®[10], DATE_PHR1_REGEX[lang_type], cflags);
1570 regerror(ret, ®[10], errStr, sizeof(errStr));
1571 __vc_cmd_regex_deinit(10);
1573 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1574 return VC_ERROR_OPERATION_FAILED;
1577 SLOG(LOG_DEBUG, TAG_VCCMD, "Regular expression > %s", DATE_PHR2_REGEX[lang_type]);
1578 ret = regcomp(®[11], DATE_PHR2_REGEX[lang_type], cflags);
1580 regerror(ret, ®[11], errStr, sizeof(errStr));
1581 __vc_cmd_regex_deinit(11);
1583 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] regcomp() error > %s", errStr);
1584 return VC_ERROR_OPERATION_FAILED;
1587 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
1589 return VC_ERROR_NONE;
1592 static void __vc_cmd_add_year(struct tm *td, int year)
1594 td->tm_year += year;
1597 static void __vc_cmd_add_mon(struct tm *td, int mon)
1601 mon = td->tm_mon + mon;
1605 __vc_cmd_add_year(td, year);
1608 td->tm_mon = mon % 12;
1611 static void __vc_cmd_add_mday(struct tm *td, int mday)
1613 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
1614 int year = td->tm_year + 1900;
1618 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) max_day[1] = 29;
1620 mday = td->tm_mday + mday;
1622 for (mon = td->tm_mon; mday >= max_day[mon % 12]; mon++) {
1623 mday -= max_day[mon % 12];
1625 if (11 == mon % 12) {
1628 if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
1636 mon = mon - td->tm_mon;
1639 __vc_cmd_add_mon(td, mon);
1645 static void __vc_cmd_add_hour(struct tm *td, int hour)
1649 hour = td->tm_hour + hour;
1653 __vc_cmd_add_mday(td, day);
1656 td->tm_hour = hour % 24;
1659 static void __vc_cmd_add_min(struct tm *td, int min)
1663 min = td->tm_min + min;
1667 __vc_cmd_add_hour(td, hour);
1670 td->tm_min = min % 60;
1673 static void __copy_struct_tm(struct tm *des, struct tm *src)
1675 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Start to copy struct tm @@@");
1677 des->tm_sec = src->tm_sec;
1678 des->tm_min = src->tm_min;
1679 des->tm_hour = src->tm_hour;
1680 des->tm_mday = src->tm_mday;
1681 des->tm_mon = src->tm_mon;
1682 des->tm_year = src->tm_year;
1683 des->tm_wday = src->tm_wday;
1684 des->tm_yday = src->tm_yday;
1685 des->tm_isdst = src->tm_isdst;
1687 des->tm_gmtoff = src->tm_gmtoff;
1688 des->tm_zone = src->tm_zone;
1691 static void __update_data_sidx(int idx)
1693 if (0 > g_data_sidx || idx < g_data_sidx) g_data_sidx = idx;
1696 static void __update_data_eidx(int idx)
1698 if (0 > g_data_eidx || idx > g_data_eidx) g_data_eidx = idx;
1701 static int __vc_cmd_tphrase_check(const char *str, struct tm *td, int *exist)
1703 regmatch_t pmatch[3];
1709 ret = regexec(®[6], str, 3, pmatch, 0);
1712 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1714 if (12 < td->tm_hour) {
1715 __vc_cmd_add_mday(td, 1);
1721 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1723 __vc_cmd_add_mday(td, 1);
1728 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1730 __update_data_sidx(pmatch[0].rm_so);
1731 __update_data_eidx(pmatch[0].rm_eo);
1734 return VC_ERROR_NONE;
1737 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1738 return VC_ERROR_NONE;
1741 static int __vc_cmd_trelative_check(const char *str, struct tm *td, int *exist)
1743 regmatch_t pmatch[2];
1751 char *tempstr = NULL;
1754 ret = regexec(®[3], str, 1, pmatch, 0);
1756 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str+pmatch[0].rm_so);
1759 sidx = pmatch[0].rm_so;
1760 eidx = pmatch[0].rm_eo;
1762 ret = regexec(®[4], str, 2, pmatch, 0);
1764 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1767 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1768 return VC_ERROR_OPERATION_FAILED;
1770 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1772 if (NULL == tempstr) {
1773 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1774 return VC_ERROR_OUT_OF_MEMORY;
1777 hour = atoi(tempstr);
1782 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1784 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1785 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1788 ret = regexec(®[5], str, 2, pmatch, 0);
1790 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1793 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1794 return VC_ERROR_OPERATION_FAILED;
1796 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1798 if (NULL == tempstr) {
1799 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1800 return VC_ERROR_OUT_OF_MEMORY;
1803 min = atoi(tempstr);
1808 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1810 if (pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1811 if (pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1814 if (hour < 0 && min < 0) {
1815 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1816 return VC_ERROR_NONE;
1819 hour = 0 > hour ? 0 : hour;
1820 min = 0 > min ? 0 : min;
1822 min = min + (hour * 60);
1824 __vc_cmd_add_min(td, min);
1827 __update_data_sidx(sidx);
1828 __update_data_eidx(eidx);
1831 return VC_ERROR_NONE;
1834 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1835 return VC_ERROR_NONE;
1838 static int __vc_cmd_tabsolute_check(const char *str, struct tm *td, int *exist)
1840 regmatch_t pmatch[5];
1849 char *tempstr = NULL;
1852 ret = regexec(®[0], str, 5, pmatch, 0);
1854 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1858 sidx = pmatch[0].rm_so;
1859 eidx = pmatch[0].rm_eo;
1862 ret = regexec(®[1], str, 2, pmatch, 0);
1864 len = pmatch[1].rm_eo - pmatch[1].rm_so;
1867 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
1868 return VC_ERROR_OPERATION_FAILED;
1870 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
1872 if (NULL == tempstr) {
1873 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1874 return VC_ERROR_OUT_OF_MEMORY;
1877 hour = atoi(tempstr);
1880 hour = hour + 12 * flag;
1882 if (12 == hour) hour = 0;
1883 else if (24 == hour) hour = 12;
1886 if (0 > hour || 24 <= hour || (0 == flag && 12 < hour)) {
1887 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1888 return VC_ERROR_NONE;
1894 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
1896 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1897 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1898 } else if (0 < flag) {
1899 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1900 return VC_ERROR_NONE;
1903 ret = regexec(®[2], str, 2, pmatch, 0);
1906 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1908 tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
1910 if (NULL == tempstr) {
1911 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
1912 return VC_ERROR_OUT_OF_MEMORY;
1915 min = atoi(tempstr);
1917 if (0 > min || 60 <= min) {
1918 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1919 return VC_ERROR_NONE;
1931 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", pmatch[0].rm_eo - pmatch[0].rm_so, str + pmatch[0].rm_so);
1932 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
1933 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
1936 if (0 > hour && 0 > min) {
1937 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
1938 return VC_ERROR_NONE;
1941 if (0 <= min && 0 <= hour) {
1942 if (hour < td->tm_hour || (hour == td->tm_hour && min <= td->tm_min)) __vc_cmd_add_mday(td, 1);
1946 } else if (0 <= min) {
1948 vc_config_mgr_get_default_language(&lang);
1950 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
1951 return VC_ERROR_OPERATION_FAILED;
1954 if (!strcmp("en_US", lang)) {
1955 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
1958 return VC_ERROR_NONE;
1960 if (min <= td->tm_min) __vc_cmd_add_hour(td, 1);
1967 if (hour <= td->tm_hour) __vc_cmd_add_mday(td, 1);
1975 __update_data_sidx(sidx);
1976 __update_data_eidx(eidx);
1979 return VC_ERROR_NONE;
1982 static int __vc_cmd_dphrase_check(const char *str, struct tm *td, int *exist)
1984 regmatch_t pmatch[10];
1990 ret = regexec(®[10], str, 5, pmatch, 0);
1992 for (idx = 1; 5 > idx && 0 >= pmatch[idx].rm_eo - pmatch[idx].rm_so; idx++);
1994 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
1996 td->tm_year = td_now.tm_year;
1997 td->tm_mon = td_now.tm_mon;
1998 td->tm_mday = td_now.tm_mday;
2000 __vc_cmd_add_mday(td, idx - 1);
2002 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2004 __update_data_sidx(pmatch[0].rm_so);
2005 __update_data_eidx(pmatch[0].rm_eo);
2008 return VC_ERROR_NONE;
2011 ret = regexec(®[11], str, 10, pmatch, 0);
2013 for (idx = 1; 10 > idx; idx++) {
2014 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2019 td->tm_year = td_now.tm_year;
2020 td->tm_mon = td_now.tm_mon;
2021 td->tm_mday = td_now.tm_mday;
2023 __vc_cmd_add_mday(td, idx + 1);
2025 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2027 __update_data_sidx(pmatch[0].rm_so);
2028 __update_data_eidx(pmatch[0].rm_eo);
2031 return VC_ERROR_NONE;
2034 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no matched string");
2035 return VC_ERROR_NONE;
2038 static int __vc_cmd_dabsolute_check(const char *str, struct tm *td, int *exist)
2040 regmatch_t pmatch[13];
2051 char *tempstr = NULL;
2054 ret = regexec(®[9], str, 2, pmatch, 0);
2056 len = pmatch[1].rm_eo - pmatch[1].rm_so;
2059 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2060 return VC_ERROR_OPERATION_FAILED;
2062 tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
2064 if (NULL == tempstr) {
2065 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2066 return VC_ERROR_OUT_OF_MEMORY;
2069 day = atoi(tempstr);
2074 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2076 sidx = pmatch[0].rm_so;
2077 eidx = pmatch[0].rm_eo;
2079 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2080 return VC_ERROR_NONE;
2083 ret = regexec(®[8], str, 13, pmatch, 0);
2085 for (idx = 1; 13 > idx; idx++) {
2086 len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
2096 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2098 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2099 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2102 vc_config_mgr_get_default_language(&lang);
2104 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Fail to get current language");
2105 return VC_ERROR_OPERATION_FAILED;
2108 if (!strcmp("en_US", lang)) {
2109 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2112 return VC_ERROR_NONE;
2121 ret = regexec(®[7], str, 3, pmatch, 0);
2123 if (!m_flag) return -1;
2125 len = pmatch[2].rm_eo - pmatch[2].rm_so;
2128 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
2129 return VC_ERROR_OPERATION_FAILED;
2131 tempstr = strndup(str + pmatch[2].rm_so, (size_t)len);
2133 if (NULL == tempstr) {
2134 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
2135 return VC_ERROR_OUT_OF_MEMORY;
2138 year = atoi(tempstr);
2139 year = 1900 < year ? year - 1900 : year + 100;
2145 SLOG(LOG_DEBUG, TAG_VCCMD, "Matched string > %.*s", len, str + pmatch[0].rm_so);
2147 if (0 > sidx || pmatch[0].rm_so < sidx) sidx = pmatch[0].rm_so;
2148 if (0 > eidx || pmatch[0].rm_eo > eidx) eidx = pmatch[0].rm_eo;
2153 if (0 > g_time_flag) {
2157 } else if (2 == g_time_flag) {
2158 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2159 return VC_ERROR_NONE;
2162 int max_day[12] = {31, 28, 31, 30, 31, 30, 31, 30, 30, 31, 30, 31};
2163 if ((0 == (year + 1900) % 4 && 0 != (year + 1900) % 100) || 0 == (year + 1900) % 400) max_day[1] = 29;
2165 if (max_day[mon] < day || 1 > day) {
2166 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] Incomming sentence is weird");
2167 return VC_ERROR_NONE;
2176 if (day < td_now.tm_mday) __vc_cmd_add_mon(td, 1);
2178 if (mon < td_now.tm_mon) __vc_cmd_add_year(td, 1);
2179 else if (mon == td_now.tm_mon && day < td_now.tm_mday) __vc_cmd_add_year(td, 1);
2183 __update_data_sidx(sidx);
2184 __update_data_eidx(eidx);
2187 return VC_ERROR_NONE;
2190 static int __vc_cmd_time_check(const char *str, struct tm *td)
2192 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check time value in string \"%s\"", str);
2197 ret = __vc_cmd_tphrase_check(str, td, &exist);
2201 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2203 } else if (VC_ERROR_NONE != ret) {
2204 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2208 ret = __vc_cmd_trelative_check(str, td, &exist);
2212 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2214 } else if (VC_ERROR_NONE != ret) {
2215 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2219 ret = __vc_cmd_tabsolute_check(str, td, &exist);
2223 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Time value is exist");
2225 } else if (VC_ERROR_NONE != ret) {
2226 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2230 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no time value");
2231 return VC_ERROR_NONE;
2234 static int __vc_cmd_date_check(const char *str, struct tm *td)
2236 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Check date value in string \"%s\"", str);
2241 ret = __vc_cmd_dphrase_check(str, td, &exist);
2245 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2247 } else if (VC_ERROR_NONE != ret) {
2248 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2252 ret = __vc_cmd_dabsolute_check(str, td, &exist);
2256 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Date value is exist");
2258 } else if (VC_ERROR_NONE != ret) {
2259 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured > (%d)", ret);
2263 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ There is no date value");
2264 return VC_ERROR_NONE;
2267 int vc_cmd_get_datetime(const char *text, time_t *result, char **remain)
2269 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ Get timestamp data");
2272 const char *day_name[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
2275 if (NULL == text || NULL == result || NULL == remain) {
2276 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter");
2277 return VC_ERROR_INVALID_PARAMETER;
2281 ret = __vc_cmd_regex_init();
2282 if (VC_ERROR_NONE != ret) {
2283 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] initialize regex failed");
2287 g_data_sidx = g_data_eidx = -1;
2290 localtime_r(&t_now, &td_now);
2291 SLOG(LOG_DEBUG, TAG_VCCMD, "Current timestamp = %d", (int)t_now);
2293 __copy_struct_tm(&td, &td_now);
2294 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2295 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);
2297 g_time_flag = g_date_flag = -1;
2299 ret = __vc_cmd_time_check(text, &td);
2300 if (VC_ERROR_NONE != ret) {
2301 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2305 ret = __vc_cmd_date_check(text, &td);
2306 if (VC_ERROR_NONE != ret) {
2307 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Error is occured in the check > (%d)", ret);
2311 __vc_cmd_regex_deinit(12);
2313 if (g_time_flag > 0 || g_date_flag > 0) {
2314 *result = mktime(&td);
2316 SLOG(LOG_DEBUG, TAG_VCCMD, "Timestamp in the text = %ld", *result);
2317 SLOG(LOG_DEBUG, TAG_VCCMD, "%d-%d-%d (%s), %d:%d:%d",
2318 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);
2320 *remain = (char *)calloc(sizeof(char), (strlen(text) + 1 - g_data_eidx + g_data_sidx));
2322 if (NULL == *remain) {
2323 SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Out of memory error");
2324 return VC_ERROR_OUT_OF_MEMORY;
2327 strncpy(*remain, text, g_data_sidx);
2328 strncat(*remain, text + g_data_eidx, strlen(text) - g_data_eidx);
2330 SLOG(LOG_DEBUG, TAG_VCCMD, "[REGEX] There is no data in the text");
2333 SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
2335 return VC_ERROR_NONE;