#include "voice_control_key_defines.h"
static pthread_mutex_t g_cmd_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t g_cmd_list_mutex = PTHREAD_MUTEX_INITIALIZER;
#define CMD_MUTEX_LOCK() pthread_mutex_lock(&g_cmd_mutex)
#define CMD_MUTEX_UNLOCK() pthread_mutex_unlock(&g_cmd_mutex)
+#define CMD_LIST_MUTEX_LOCK() pthread_mutex_lock(&g_cmd_list_mutex)
+#define CMD_LIST_MUTEX_UNLOCK() pthread_mutex_unlock(&g_cmd_list_mutex)
static int g_feature_enabled = -1;
static bool g_privilege_allowed = false;
}
}
- return 0;
+ return VC_ERROR_NONE;
}
static int __check_privilege_initialize()
return VC_ERROR_PERMISSION_DENIED;
}
- char uid[16];
- snprintf(uid, 16, "%d", getuid());
+ char uid[32];
+ snprintf(uid, 32, "%d", getuid());
ret = true;
- ret = __check_privilege(uid, VC_PRIVILEGE);
- __check_privilege_deinitialize();
+ ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
if (false == ret) {
- SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied");
+ //LCOV_EXCL_START
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
+ __check_privilege_deinitialize();
g_privilege_allowed = false;
pthread_mutex_unlock(&g_cynara_mutex);
return VC_ERROR_PERMISSION_DENIED;
+ //LCOV_EXCL_STOP
}
+
+ __check_privilege_deinitialize();
}
g_privilege_allowed = true;
return VC_ERROR_PERMISSION_DENIED;
}
+ CMD_LIST_MUTEX_LOCK();
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_INVALID_PARAMETER;
}
if (NULL == list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Not enough memory");
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_OUT_OF_MEMORY;
}
SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list(%p)", *vc_cmd_list);
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_NONE;
}
return VC_ERROR_PERMISSION_DENIED;
}
+ CMD_LIST_MUTEX_LOCK();
+
if (NULL == vc_cmd_list) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_INVALID_PARAMETER;
}
- vc_cmd_list_remove_all(vc_cmd_list, release_command);
vc_cmd_list_s* list = NULL;
list = (vc_cmd_list_s*)vc_cmd_list;
iter = g_list_find(g_cmdlist_list, list);
if (NULL == iter) {
SLOG(LOG_ERROR, TAG_VCCMD, "Fail to destroy client : handle is not valid");
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_INVALID_PARAMETER;
}
- g_cmdlist_list = g_list_remove_link(g_cmdlist_list, iter);
- if (iter->data)
- free(iter->data);
- iter->data = NULL;
- iter = NULL;
+ g_cmdlist_list = g_list_delete_link(g_cmdlist_list, iter);
+
+ vc_cmd_list_remove_all((vc_cmd_list_h)list, release_command);
+ free(list);
+ list = NULL;
+
SLOG(LOG_DEBUG, TAG_VCCMD, "Client destroy");
+
+ CMD_LIST_MUTEX_UNLOCK();
return VC_ERROR_NONE;
}
return VC_ERROR_NONE;
}
-static void __vc_cmd_list_remove_all_foreach(gpointer data, gpointer user_data)
+static void __vc_cmd_list_remove_all_foreach(gpointer data)
{
- vc_cmd_s *temp = NULL;
- temp = data;
+ vc_cmd_s *temp = (vc_cmd_s *)data;
if (temp) {
- SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
+ SECURE_SLOG(LOG_DEBUG, TAG_VCCMD, "Free command(%p)", temp);
vc_cmd_destroy((vc_cmd_h)temp);
- temp = NULL;
}
- return;
}
int vc_cmd_list_remove_all(vc_cmd_list_h vc_cmd_list, bool release_command)
return VC_ERROR_INVALID_PARAMETER;
}
- vc_cmd_list_s* list = NULL;
- list = (vc_cmd_list_s*)vc_cmd_list;
+ vc_cmd_list_s* cmd_list = (vc_cmd_list_s*)vc_cmd_list;
SLOG(LOG_DEBUG, TAG_VCCMD, "[List] list (%p), release command (%s)"
- , list, release_command ? "true" : "false");
+ , cmd_list, release_command ? "true" : "false");
- if (true == release_command)
- g_slist_foreach(list->list, __vc_cmd_list_remove_all_foreach, NULL);
- g_slist_free(list->list);
- list->list = NULL;
- list->index = -1;
+ if (NULL == cmd_list->list) {
+ SLOG(LOG_DEBUG, TAG_VCCMD, "@@@ List is already empty.");
+ return VC_ERROR_NONE;
+ }
+
+ if (true == release_command) {
+ g_slist_free_full(cmd_list->list, __vc_cmd_list_remove_all_foreach);
+ } else {
+ g_slist_free(cmd_list->list);
+ }
+
+ cmd_list->list = NULL;
+ cmd_list->index = -1;
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
return VC_ERROR_PERMISSION_DENIED;
}
- if (NULL == vc_cmd_list) {
+ if (NULL == vc_cmd_list || NULL == callback) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
}
return VC_ERROR_PERMISSION_DENIED;
}
- if (NULL == original) {
+ if (NULL == original || NULL == filtered) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Input parameter is NULL");
return VC_ERROR_INVALID_PARAMETER;
}
list = (vc_cmd_list_s*)vc_cmd_list;
int count = g_slist_length(list->list);
+ if (0 == count) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
+ return VC_ERROR_EMPTY;
+ }
if (list->index < count - 1) {
list->index = list->index + 1;
vc_cmd_list_s* list = NULL;
list = (vc_cmd_list_s*)vc_cmd_list;
+ if (0 == g_slist_length(list->list)) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] List is empty");
+ return VC_ERROR_EMPTY;
+ }
+
if (list->index > 0) {
list->index = list->index - 1;
SLOG(LOG_DEBUG, TAG_VCCMD, "[DEBUG] List index : %d", list->index);
return VC_ERROR_INVALID_PARAMETER;
}
- g_cmd_list = g_list_remove_link(g_cmd_list, iter);
+ g_cmd_list = g_list_delete_link(g_cmd_list, iter);
if (command->command)
free(command->command);
cmd->id = id;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set id][%p] id(%d)", vc_command, cmd->id);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_START
int vc_cmd_get_id(vc_cmd_h vc_command, int* id)
{
if (0 != __vc_cmd_get_feature_enabled()) {
*id = cmd->id;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get id][%p] id(%d)", vc_command, *id);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int vc_cmd_set_appid(vc_cmd_h vc_command, const char* appid)
{
cmd->appid = strdup(appid);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set appid][%p] appid(%s)", vc_command, cmd->appid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_appid(vc_cmd_h vc_command, char** appid)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get appid][%p] appid(%s)", vc_command, *appid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_command(vc_cmd_h vc_command, const char* command)
return VC_ERROR_PERMISSION_DENIED;
}
- if (NULL == vc_command) {
+ if (NULL == vc_command || NULL == command) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid parameter ");
return VC_ERROR_INVALID_PARAMETER;
}
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set command][%p] Command(%s)", vc_command, cmd->command);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_command(vc_cmd_h vc_command, char** command)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get command][%p] Command(%s)", vc_command, *command);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_unfixed_command(vc_cmd_h vc_command, const char* command)
cmd->parameter = strdup(command);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set unfixed command][%p] unfixed command(%s)", vc_command, cmd->parameter);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_unfixed_command(vc_cmd_h vc_command, char** command)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get unfixed command][%p] unfixed command(%s)", vc_command, *command);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_START
int vc_cmd_set_fixed_command(vc_cmd_h vc_command, const char* fixed)
{
if (0 != __vc_cmd_get_feature_enabled()) {
cmd->fixed = strdup(fixed);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set parameter][%p] fixed command(%s)", vc_command, cmd->fixed);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_fixed_command(vc_cmd_h vc_command, char** fixed)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get fixed command][%p] fixed command(%s)", vc_command, *fixed);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int vc_cmd_set_invocation_name(vc_cmd_h vc_command, const char* invocation_name)
{
cmd->invocation_name = strdup(invocation_name);
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set invocation name][%p] invocation_name(%s)", vc_command, cmd->invocation_name);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_START
int vc_cmd_get_invocation_name(vc_cmd_h vc_command, char** invocation_name)
{
if (0 != __vc_cmd_get_feature_enabled()) {
*invocation_name = NULL;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get invocation name][%p] invocation_name(%s)", vc_command, *invocation_name);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int vc_cmd_set_type(vc_cmd_h vc_command, int type)
{
return VC_ERROR_INVALID_PARAMETER;
}
+ if (VC_COMMAND_TYPE_NONE >= type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid type(%d)", type);
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
vc_cmd_s* cmd = NULL;
cmd = (vc_cmd_s*)vc_command;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set type][%p] type(%d)", vc_command, cmd->type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_type(vc_cmd_h vc_command, int* type)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get type][%p] type(%d)", vc_command, *type);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_format(vc_cmd_h vc_command, int format)
return VC_ERROR_INVALID_PARAMETER;
}
+ if (VC_COMMAND_FORMAT_FIXED > format || VC_COMMAND_FORMAT_NONFIXED_AND_FIXED < format) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid format(%d)", format);
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
vc_cmd_s* cmd = NULL;
cmd = (vc_cmd_s*)vc_command;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set format][%p] format(%d)", vc_command, format);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_format(vc_cmd_h vc_command, int* format)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get format][%p] format(%d)", vc_command, *format);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_pid(vc_cmd_h vc_command, int pid)
return VC_ERROR_INVALID_PARAMETER;
}
+ if (0 > pid) {
+ SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid pid (%d)", pid);
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
vc_cmd_s* cmd = NULL;
cmd = (vc_cmd_s*)vc_command;
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set pid][%p] pid(%d)", vc_command, cmd->pid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_pid(vc_cmd_h vc_command, int* pid)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get pid][%p] pid(%d)", vc_command, *pid);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_set_domain(vc_cmd_h vc_command, int domain)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Set domain] domain : %d", domain);
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_domain(vc_cmd_h vc_command, int* domain)
SLOG(LOG_DEBUG, TAG_VCCMD, "[Get domain] domain : %d", *domain);
- return 0;
+ return VC_ERROR_NONE;
}
+//LCOV_EXCL_START
/**
* @brief Sets key value of command.
*
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
/**
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_print_list(vc_cmd_list_h vc_cmd_list)
SLOG(LOG_DEBUG, TAG_VCCMD, "@@@");
- return 0;
+ return VC_ERROR_NONE;
}
int vc_cmd_get_nlu_json(vc_cmd_h vc_cmd, char** json)
return VC_ERROR_OPERATION_FAILED;
}
- return 0;
+ return VC_ERROR_NONE;
}
static void __vc_cmd_regex_deinit(int num_regex)
int hour = -1;
int min = -1;
- char *tempstr = NULL;
-
*exist = 0;
ret = regexec(®[3], str, 1, pmatch, 0);
if (0 == ret) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
return VC_ERROR_OPERATION_FAILED;
}
- tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+ char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
if (NULL == tempstr) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
return VC_ERROR_OPERATION_FAILED;
}
- tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+ char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
if (NULL == tempstr) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
int min = -1;
int sidx = -1;
int eidx = -1;
- char *tempstr = NULL;
*exist = 0;
ret = regexec(®[0], str, 5, pmatch, 0);
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Invalid string length");
return VC_ERROR_OPERATION_FAILED;
}
- tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
+ char *tempstr = strndup(str + pmatch[1].rm_so, (size_t)len);
if (NULL == tempstr) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
idx = 1;
len = pmatch[idx].rm_eo - pmatch[idx].rm_so;
if (0 < len) {
- tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
+ char *tempstr = strndup(str + pmatch[idx].rm_so, (size_t)len);
if (NULL == tempstr) {
SLOG(LOG_ERROR, TAG_VCCMD, "[ERROR] Memory allocation is failed");
return VC_ERROR_NONE;
}
+//LCOV_EXCL_STOP
projects / platform / core / uifw / voice-control.git / blobdiff