ENDIF(PRIVACY_POPUP)
###################################################################################################
-## for libprivacy-guard-client (executable)
+## for libprivacy-guard-client
INCLUDE_DIRECTORIES(${pkgs_INCLUDE_DIRS} ${client_include_dir} ${common_include_dir} ${extern_include_dir})
SET(PRIVACY_GUARD_CLIENT_SOURCES
${common_src_dir}/SocketConnection.cpp
monitorPolicy = 0;
res = PRIV_GUARD_ERROR_NO_DATA;
}
- PG_LOGD("Here3");
+
return res;
}
int privacy_guard_client_add_privacy_access_log(const int user_id, const char *package_id, const char *privilege_id)
{
- if (user_id < 0 || package_id == NULL || privilege_id == NULL)
+ if (user_id < 0 || package_id == NULL || privilege_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
int monitor_policy = 0;
std::string privacy_id;
PG_LOGD("user_id : %d, package_id : %s, privilege_id : %s", user_id, package_id, privilege_id);
int retval = PrivacyChecker::checkMonitorPolicyWithPrivilege(user_id, std::string(package_id), std::string(privilege_id), privacy_id, monitor_policy);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyChecker::checkMonitorPolicyWithPrivilege() [%d]", retval);
+ return retval;
+ }
- PG_LOGD("monitor policy : %d", monitor_policy);
-
- if (retval == PRIV_GUARD_ERROR_SUCCESS && monitor_policy == MONITOR_POLICY_ON) {
+ if (monitor_policy == MONITOR_POLICY_ON) {
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
retval = pInst->PgAddPrivacyAccessLog(user_id, std::string(package_id), std::string(privacy_id));
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyChecker::checkMonitorPolicyWithPrivilege() [%d]", retval);
+ return retval;
+ }
}
- PG_LOGD("retval : %d", retval);
- return retval;
+
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_delete_all_logs_and_monitor_policy(void)
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgDeleteAllLogsAndMonitorPolicy();
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgDeleteAllLogsAndMonitorPolicy() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_delete_logs_by_package_id(const char *package_id)
{
- if (package_id == NULL)
+ if (package_id == NULL) {
+ PG_LOGE("Invalid parameters. (package_id)");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgDeleteLogsByPackageId(std::string(package_id));
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgDeleteLogsByPackageId() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_delete_monitor_policy_by_package_id(const char *package_id)
{
- if (package_id == NULL)
+ if (package_id == NULL) {
+ PG_LOGE("Invalid parameters. (package_id)");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgDeleteMonitorPolicyByPackageId(std::string(package_id));
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgDeleteMonitorPolicyByPackageId() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_total_privacy_count_of_package(const int user_id, const time_t start_date,
const time_t end_date, privacy_guard_client_privacy_count_of_package_cb callback, void *user_data)
{
- if (user_id < 0 || start_date > end_date || start_date <= 0)
+ if (user_id < 0 || start_date > end_date || start_date <= 0) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
+
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
std::list <std::pair<std::string, int>> list;
- PG_LOGD("start_date : %d, end_date : %d", start_date, end_date);
int retval = pInst->PgForeachTotalPrivacyCountOfPackage(user_id, start_date, end_date, list);
-
- if (retval != PRIV_GUARD_ERROR_SUCCESS)
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachTotalPrivacyCountOfPackage() [%d]", retval);
return retval;
+ }
+
if (list.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
for (std::list <std::pair <std::string, int>>::iterator iter = list.begin(); iter != list.end(); ++iter) {
- PG_LOGD("result > package_id : %s, count : %d", iter->first.c_str(), iter->second);
+ //PG_LOGD("result > package_id : %s, count : %d", iter->first.c_str(), iter->second);
bool ret = callback(iter->first.c_str(), iter->second, user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_total_privacy_count_of_privacy(const int user_id, const time_t start_date,
const time_t end_date, privacy_guard_client_privacy_count_cb callback, void *user_data)
{
- if (user_id < 0 || start_date > end_date || start_date <= 0)
+ if (user_id < 0 || start_date > end_date || start_date <= 0) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
std::list <std::pair<std::string, int>> list;
- PG_LOGD("start_date : %d, end_date : %d", start_date, end_date);
int retval = pInst->PgForeachTotalPrivacyCountOfPrivacy(user_id, start_date, end_date, list);
-
- if (retval != PRIV_GUARD_ERROR_SUCCESS)
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachTotalPrivacyCountOfPrivacy() [%d]", retval);
return retval;
+ }
+
if (list.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
for (std::list <std::pair <std::string, int>>::iterator iter = list.begin(); iter != list.end(); ++iter) {
- PG_LOGD("result > privacy_id : %s, count : %d", iter->first.c_str(), iter->second);
+ PG_LOGD("privacy_id: %s, count: %d", iter->first.c_str(), iter->second);
bool ret = callback(iter->first.c_str(), iter->second, user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_privacy_count_by_privacy_id(const int user_id, const time_t start_date,
const time_t end_date, const char *privacy_id,
privacy_guard_client_privacy_count_of_package_cb callback, void *user_data)
{
- if (user_id < 0 || start_date > end_date || start_date <= 0 || privacy_id == NULL)
+ if (user_id < 0 || start_date > end_date || start_date <= 0 || privacy_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
std::list <std::pair<std::string, int>> list;
- PG_LOGD("start_date : %d, end_date : %d", start_date, end_date);
int retval = pInst->PgForeachPrivacyCountByPrivacyId(user_id, start_date, end_date, std::string(privacy_id), list);
-
- if (retval != PRIV_GUARD_ERROR_SUCCESS)
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachPrivacyCountByPrivacyId() [%d]", retval);
return retval;
+ }
+
if (list.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
for (std::list <std::pair <std::string, int>>::iterator iter = list.begin(); iter != list.end(); ++iter) {
- PG_LOGD("result > package_id : %s, count : %d", iter->first.c_str(), iter->second);
+ PG_LOGD("package_id: %s, count: %d", iter->first.c_str(), iter->second);
bool ret = callback(iter->first.c_str(), iter->second, user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
-
int privacy_guard_client_foreach_privacy_count_by_package_id(const int user_id, const time_t start_date,
const time_t end_date, const char *package_id,
privacy_guard_client_privacy_count_cb callback, void *user_data)
{
- if (user_id < 0 || start_date > end_date || start_date <= 0 || package_id == NULL)
+ if (user_id < 0 || start_date > end_date || start_date <= 0 || package_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
std::list <std::pair<std::string, int>> list;
- PG_LOGD("start_date : %d, end_date : %d", start_date, end_date);
int retval = pInst->PgForeachPrivacyCountByPackageId(user_id, start_date, end_date, std::string(package_id), list);
-
- if (retval != PRIV_GUARD_ERROR_SUCCESS)
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachPrivacyCountByPackageId() [%d]", retval);
return retval;
+ }
+
if (list.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
for (std::list <std::pair <std::string, int>>::iterator iter = list.begin(); iter != list.end(); ++iter) {
- PG_LOGD("result > privacy_id : %s, count : %d", iter->first.c_str(), iter->second);
+ PG_LOGD("privacy_id: %s, count: %d", iter->first.c_str(), iter->second);
bool ret = callback(iter->first.c_str(), iter->second, user_data);
if (ret == false)
break;
int privacy_guard_client_add_monitor_policy(const int user_id, const char *package_id, const char **privilege_list, const int monitor_policy)
{
- if (user_id < 0 || package_id == NULL)
+ if (user_id < 0 || package_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
std::list < std::string > privilegeList;
- while (*privilege_list[0] != '\0')
- {
- PG_LOGD("privacyList : %s", *privilege_list);
+ while (*privilege_list[0] != '\0') {
+ PG_LOGD("Privilege in the list: %s", *privilege_list);
privilegeList.push_back(std::string(*privilege_list++));
}
int retval = pInst->PgAddMonitorPolicy(user_id, std::string(package_id), privilegeList, monitor_policy);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgAddMonitorPolicy() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_update_monitor_policy(const int user_id, const char *package_id, const char *privacy_id, const int monitor_policy)
{
- if (user_id < 0 || package_id == NULL || privacy_id == NULL)
+ if (user_id < 0 || package_id == NULL || privacy_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgUpdateMonitorPolicy(user_id, std::string(package_id), std::string(privacy_id), monitor_policy);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgUpdateMonitorPolicy() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_monitor_policy_by_package_id(const int user_id, const char *package_id,
privacy_guard_client_monitor_policy_cb callback, void *user_data)
{
- if (user_id < 0 || package_id == NULL)
+ if (user_id < 0 || package_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
-
- PG_LOGD("package_id : %s", package_id);
+ }
std::list <privacy_data_s> privacyInfoList;
int retval = -1;
retval = PrivacyGuardClient::getInstance()->PgForeachMonitorPolicyByPackageId(user_id, std::string(package_id), privacyInfoList);
-
if (retval != PRIV_GUARD_ERROR_SUCCESS) {
- PG_LOGE("PgForeachMonitorPolicyByPackageId : fail");
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachMonitorPolicyByPackageId() [%d]", retval);
return retval;
}
- if (privacyInfoList.size() == 0) {
- PG_LOGE("PgForeachMonitorPolicyByPackageId (privacyList.size = 0): fail");
+ if (privacyInfoList.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
- }
for (std::list <privacy_data_s>::iterator iter = privacyInfoList.begin(); iter != privacyInfoList.end(); ++iter) {
- PG_LOGD("result > privacy_id : %s, monitor_policy : %d",
- iter->privacy_id, iter->monitor_policy);
+ PG_LOGD("privacy_id: %s, monitor_policy: %d", iter->privacy_id, iter->monitor_policy);
bool ret = callback(iter->privacy_id, iter->monitor_policy, user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_check_privacy_package(const int user_id, const char *package_id, bool *is_privacy_package)
{
- if (user_id < 0 || package_id == NULL)
+ if (user_id < 0 || package_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient* pInst = PrivacyGuardClient::getInstance();
- PG_LOGD("user_id : %d, package_id : %s", user_id, package_id);
+ PG_LOGD("user_id: %d, package_id: %s", user_id, package_id);
+
int retval = pInst->PgCheckPrivacyPackage(user_id, std::string(package_id), *is_privacy_package);
- PG_LOGD("result > is_privacy_package : %d", *is_privacy_package);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgCheckPrivacyPackage() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_privacy_package_id(const int user_id, privacy_guard_client_package_id_cb callback, void *user_data)
{
- if (user_id < 0)
+ if (user_id < 0) {
+ PG_LOGE("Invalid parameters. (user_id: %d)", user_id);
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient* pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgForeachPrivacyPackageId(user_id, packageList);
if (retval != PRIV_GUARD_ERROR_SUCCESS) {
- PG_LOGE("PgForeachPrivacyPackageId : fail");
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachPrivacyPackageId(). [%d]", retval);
return retval;
}
- if (packageList.size() == 0) {
- PG_LOGE("PgForeachPrivacyPackageId (packageList.size = 0): fail");
+
+ if (packageList.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
- }
for (std::list < std::string >::iterator iter = packageList.begin(); iter != packageList.end(); ++iter) {
- PG_LOGD("package_id : %s", iter->c_str());
+ PG_LOGD("package_id: %s", iter->c_str());
bool ret = callback(iter->c_str(), user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_foreach_package_by_privacy_id(const int user_id, const char *privacy_id, privacy_guard_client_package_id_cb callback, void *user_data)
{
- if (user_id < 0 || privacy_id == NULL)
+ if (user_id < 0 || privacy_id == NULL) {
+ PG_LOGE("Invalid parameters.");
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient* pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgForeachPackageByPrivacyId(user_id, std::string(privacy_id), packageList);
if (retval != PRIV_GUARD_ERROR_SUCCESS) {
- PG_LOGE("PgForeachPackageByPrivacyId : fail");
+ PG_LOGE("Failed to do PrivacyGuardClient::PgForeachPackageByPrivacyId(). [%d]", retval);
return retval;
}
- if (packageList.size() == 0) {
- PG_LOGE("PgForeachPackageByPrivacyId (packageList.size = 0): fail");
+ if (packageList.size() == 0)
return PRIV_GUARD_ERROR_NO_DATA;
- }
for (std::list < std::string >::iterator iter = packageList.begin(); iter != packageList.end(); ++iter) {
- PG_LOGD("package_id : %s", iter->c_str());
+ PG_LOGD("package_id: %s", iter->c_str());
bool ret = callback(iter->c_str(), user_data);
if (ret == false)
break;
}
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_update_main_monitor_policy(const int user_id, const bool main_monitor_policy)
{
- if (user_id < 0)
+ if (user_id < 0) {
+ PG_LOGE("Invalid parameters. (user_id: %d)", user_id);
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgUpdateMainMonitorPolicy(user_id, main_monitor_policy);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgUpdateMainMonitorPolicy() [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_get_main_monitor_policy(const int user_id, bool *main_monitor_policy)
{
- if (user_id < 0)
+ if (user_id < 0) {
+ PG_LOGE("Invalid parameters. (user_id: %d)", user_id);
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient* pInst = PrivacyGuardClient::getInstance();
- PG_LOGD("user_id : %d", user_id);
int retval = pInst->PgGetMainMonitorPolicy(user_id, *main_monitor_policy);
- PG_LOGD("result > main_monitor_policy : %d", *main_monitor_policy);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgGetMainMonitorPolicy(). [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
int privacy_guard_client_delete_main_monitor_policy_by_user_id(const int user_id)
{
- if (user_id < 0)
+ if (user_id < 0) {
+ PG_LOGE("Invalid parameters. (user_id: %d)", user_id);
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ }
PrivacyGuardClient *pInst = PrivacyGuardClient::getInstance();
int retval = pInst->PgDeleteMainMonitorPolicyByUserId(user_id);
+ if (retval != PRIV_GUARD_ERROR_SUCCESS) {
+ PG_LOGE("Failed to do PrivacyGuardClient::PgDeleteMainMonitorPolicyByUserId(). [%d]", retval);
+ return retval;
+ }
- return retval;
+ return PRIV_GUARD_ERROR_SUCCESS;
}
#include "privacy_guard_client_types.h"
#define PRIVACY_DB_PATH tzplatform_mkpath(TZ_SYS_DB,".privacy_guard.db")
-#define PRIVACY_INFO_DB_PATH tzplatform_mkpath(TZ_SYS_DB,".privacy_guard_privacylist.db")
typedef struct _privacy_data_s {
char* privacy_id;
static int getPrivacyIdListFromPrivilegeList(const std::list< std::string > privilegeList, std::list< std::string >& privacyIdList);
static bool isValidPrivacyId(const std::string privacyId);
static int getAllPrivacyId(std::list< std::string >& privacyIdList);
- static int getPrivaycDisplayName(const std::string privacyId, std::string& displayName);
- static int getPrivaycDescription(const std::string privacyId, std::string& description);
- static int isFeatureEnabled(const char* feature, bool& enabled);
+ //static int getPrivaycDisplayName(const std::string privacyId, std::string& displayName);
+ //static int getPrivaycDescription(const std::string privacyId, std::string& description);
+ //static int isFeatureEnabled(const char* feature, bool& enabled);
};
#endif //_PRIVACYIDINFO_H_
#include <set>
#include <libintl.h>
#include <system_info.h>
+#include <privilege_info.h>
#include "PrivacyIdInfo.h"
#include "privacy_guard_client_types.h"
#include "PrivacyGuardTypes.h"
int
PrivacyIdInfo::initialize(void)
{
- static const std::string sqlPrivilege("SELECT PRIVILEGE_ID, PRIVACY_ID from PrivilegeToPrivacyTable");
- static const std::string sqlPrivacyInfo("SELECT FEATURE FROM PrivacyInfo where PRIVACY_ID=?");
+ GList *privacy_list = NULL, *privilege_list = NULL;
+ GList *l = NULL, *k = NULL;
- openDb(PRIVACY_INFO_DB_PATH, pDbHandler, SQLITE_OPEN_READONLY);
- prepareDb(pDbHandler, sqlPrivilege.c_str(), pStmtPrivilege);
-
- int res;
- while ((res = sqlite3_step(pStmtPrivilege.get())) == SQLITE_ROW)
- {
- const char* privilegeId = reinterpret_cast < const char* > (sqlite3_column_text(pStmtPrivilege.get(), 0));
- const char* privacyId = reinterpret_cast < const char* > (sqlite3_column_text(pStmtPrivilege.get(), 1));
-
- prepareDb(pDbHandler, sqlPrivacyInfo.c_str(), pStmtPrivacyInfo);
- res = sqlite3_bind_text(pStmtPrivacyInfo.get(), 1, privacyId, -1, SQLITE_TRANSIENT);
- TryReturn(res == SQLITE_OK, PRIV_GUARD_ERROR_DB_ERROR, , "sqlite3_bind_text : %d", res);
- res = sqlite3_step(pStmtPrivacyInfo.get());
- PG_LOGD("privacy id : %s", privacyId);
- TryReturn(res == SQLITE_DONE || res == SQLITE_ROW, PRIV_GUARD_ERROR_DB_ERROR, , "sqlite3_step : %d", res);
-
- const char* feature = reinterpret_cast < const char* > (sqlite3_column_text(pStmtPrivacyInfo.get(), 0));
- if (feature != NULL)
- {
- bool isSupported = false;
+ int ret = privilege_info_get_privacy_list(&privacy_list);
+ if (ret != PRVMGR_ERR_NONE) {
+ PG_LOGE("Failed to get privacy list from security-privilege-manager [%d].", ret);
+ return PRIV_GUARD_ERROR_INTERNAL_ERROR;
+ }
- res = isFeatureEnabled(feature, isSupported);
- TryReturn(res == PRIV_GUARD_ERROR_SUCCESS, res, , "isFeatureEnabled : %d", res);
+ for (l = privacy_list; l != NULL; l = l->next) {
+ char *privacy_id = (char*)l->data;
+ PG_LOGD("privacy_id: %s", privacy_id);
- if (!isSupported)
- {
- continue;
- }
+ ret = privilege_info_get_privilege_list_by_privacy(privacy_id, &privilege_list);
+ if (ret != PRVMGR_ERR_NONE) {
+ PG_LOGE("Failed to get privilege list from security-privilege-manager [%d] using privacy[%s].", ret, privacy_id);
+ g_list_free(privacy_list);
+ return PRIV_GUARD_ERROR_INTERNAL_ERROR;
}
- m_privilegeToPrivacyMap.insert(std::map< std::string, std::string >::value_type(std::string(privilegeId), std::string(privacyId)));
+ for (k = privilege_list; k != NULL; k = k->next) {
+ char *privilege_id = (char*)k->data;
+ PG_LOGD("(privacy, privilege): (%s, %s)", privacy_id, privilege_id);
+ m_privilegeToPrivacyMap.insert(std::map< std::string, std::string >::value_type(std::string(privilege_id), std::string(privacy_id)));
+ }
}
+ g_list_free(privacy_list);
+ g_list_free(privilege_list);
+
m_isInitialized = true;
return PRIV_GUARD_ERROR_SUCCESS;
int
PrivacyIdInfo::getPrivacyIdFromPrivilege(const std::string privilege, std::string& privacyId)
{
- if (!m_isInitialized)
- {
+ if (!m_isInitialized) {
initialize();
}
std::map< std::string, std::string >::iterator iter = m_privilegeToPrivacyMap.find(privilege);
- if (iter == m_privilegeToPrivacyMap.end())
- {
+ if (iter == m_privilegeToPrivacyMap.end()) {
+ PG_LOGE("There is no matching privacy to privilege [%s]", privilege.c_str());
return PRIV_GUARD_ERROR_NO_DATA;
}
+
privacyId = iter->second;
return PRIV_GUARD_ERROR_SUCCESS;
int
PrivacyIdInfo::getPrivilegeListFromPrivacyId(const std::string privacyId, std::list< std::string >& privilegeList)
{
- if (!m_isInitialized)
- {
+ if (!m_isInitialized) {
initialize();
}
privilegeList.clear();
- for (std::map< std::string, std::string >::iterator iter = m_privilegeToPrivacyMap.begin(); iter != m_privilegeToPrivacyMap.end(); ++iter)
- {
- if (privacyId.compare((iter->second)) == 0)
- {
+
+ for (std::map< std::string, std::string >::iterator iter = m_privilegeToPrivacyMap.begin(); iter != m_privilegeToPrivacyMap.end(); ++iter) {
+ if (privacyId.compare((iter->second)) == 0) {
privilegeList.push_back(iter->first);
}
}
- if (privilegeList.size() == 0)
- {
- PG_LOGE("PrivilegeList of %s privacy is empty!", privacyId.c_str());
+ if (privilegeList.size() == 0) {
+ PG_LOGE("There is no matching privilege to privacy [%s].", privacyId.c_str());
return PRIV_GUARD_ERROR_NO_DATA;
}
int
PrivacyIdInfo::getPrivacyIdListFromPrivilegeList(const std::list< std::string > privilegeList, std::list< std::string >& privacyIdList)
{
- if (!m_isInitialized)
- {
+ if (!m_isInitialized) {
initialize();
}
std::set< std::string > privacyIdSet;
- for (std::list< std::string >::const_iterator iter = privilegeList.begin(); iter != privilegeList.end(); ++iter)
- {
+ for (std::list< std::string >::const_iterator iter = privilegeList.begin(); iter != privilegeList.end(); ++iter) {
std::string privacyId;
int res = getPrivacyIdFromPrivilege(*iter, privacyId);
- if (res == PRIV_GUARD_ERROR_SUCCESS)
- {
+ if (res == PRIV_GUARD_ERROR_SUCCESS) {
PG_LOGD("Privacy[%s] from Privilege[%s]", privacyId.c_str(), iter->c_str());
privacyIdSet.insert(privacyId);
}
}
- for (std::set< std::string >::iterator iter = privacyIdSet.begin(); iter != privacyIdSet.end(); ++iter)
- {
+ for (std::set< std::string >::iterator iter = privacyIdSet.begin(); iter != privacyIdSet.end(); ++iter) {
privacyIdList.push_back(*iter);
}
int
PrivacyIdInfo::getAllPrivacyId(std::list< std::string >& privacyIdList)
{
- static const std::string sql("SELECT PRIVACY_ID, FEATURE from PrivacyInfo");
-
if (!m_isInitialized)
{
initialize();
}
- openDb(PRIVACY_INFO_DB_PATH, pDbHandler, SQLITE_OPEN_READONLY);
- prepareDb(pDbHandler, sql.c_str(), pStmt);
-
- int res;
- while ((res = sqlite3_step(pStmt.get())) == SQLITE_ROW)
- {
- const char* privacyId = reinterpret_cast < const char* > (sqlite3_column_text(pStmt.get(), 0));
- const char* feature = reinterpret_cast < const char* > (sqlite3_column_text(pStmt.get(), 1));
- PG_LOGD("privacy: %s, feature: %s", privacyId, feature);
+ GList *privacy_list = NULL;
+ GList *l = NULL;
- if (feature != NULL)
- {
- bool isSupported = false;
- res = isFeatureEnabled(feature, isSupported);
- TryReturn(res == PRIV_GUARD_ERROR_SUCCESS, res, , "isFeatureEnabled : %d", res);
- if (!isSupported)
- {
- continue;
- }
- }
+ int ret = privilege_info_get_privacy_list(&privacy_list);
+ if (ret != PRVMGR_ERR_NONE) {
+ PG_LOGE("Failed to get privacy list from security-privilege-manager [%d].", ret);
+ return PRIV_GUARD_ERROR_INTERNAL_ERROR;
+ }
- privacyIdList.push_back(std::string(privacyId));
- PG_LOGD("privacy Id : %s", privacyId);
+ for (l = privacy_list; l != NULL; l = l->next) {
+ char *privacy_id = (char*)l->data;
+ PG_LOGD("[kylee] privacy_id: %s", privacy_id);
+ privacyIdList.push_back(std::string(privacy_id));
}
return PRIV_GUARD_ERROR_SUCCESS;
}
+/*
int
PrivacyIdInfo::getPrivaycDisplayName(const std::string privacyId, std::string& displayName)
{
return PRIV_GUARD_ERROR_SUCCESS;
}
+*/
+/*
int
PrivacyIdInfo::getPrivaycDescription(const std::string privacyId, std::string& displayName)
{
return PRIV_GUARD_ERROR_SUCCESS;
}
+*/
-int
+/*int
PrivacyIdInfo::isFeatureEnabled(const char* feature, bool& enabled)
{
int res = PRIV_GUARD_ERROR_SUCCESS;
return PRIV_GUARD_ERROR_SUCCESS;
}
+*/
PRIV_GUARD_ERROR_INVALID_STATE = -17,
PRIV_GUARD_ERROR_SYSTEM_ERROR = -18,
PRIV_GUARD_ERROR_USER_NOT_CONSENTED = -19,
+ PRIV_GUARD_ERROR_INTERNAL_ERROR = -20,
PRIV_GUARD_ERROR_UNKNOWN = -(0x99),
};
BuildRequires: pkgconfig(sqlite3)
BuildRequires: pkgconfig(capi-system-info)
BuildRequires: pkgconfig(libtzplatform-config)
+BuildRequires: pkgconfig(security-privilege-manager)
#BuildRequires: pkgconfig(cynara-monitor)
Requires(post): /sbin/ldconfig
mkdir -p %{buildroot}%{_prefix}/bin
cp res/usr/bin/* %{buildroot}%{_bindir}/
mkdir -p %{buildroot}%{TZ_SYS_DB}
-cp res/opt/dbspace/.privacy_guard_privacylist.db /%{buildroot}%{TZ_SYS_DB}
%make_install
mkdir -p %{buildroot}%{_libdir}/systemd/system/multi-user.target.wants
install -m 0644 %{SOURCE2} %{buildroot}%{_libdir}/systemd/system/privacy-guard-server.socket
ln -sf /usr/lib/systemd/system/privacy-guard-server.socket %{buildroot}%{_libdir}/systemd/system/socket.target.wants/privacy-guard-server.socket
-
%post -n privacy-guard-server
/sbin/ldconfig
%defattr(-,root,root,-)
%license LICENSE.APLv2
%manifest privacy-guard-server.manifest
-%{TZ_SYS_DB}/.privacy_guard_privacylist.db
+#%{TZ_SYS_DB}/.privacy_guard_privacylist.db
%{_bindir}/*
%{_libdir}/systemd/system/*
SET(INCLUDEDIR "\${prefix}/include")
INCLUDE(FindPkgConfig)
-#pkg_check_modules(pkgs REQUIRED dlog sqlite3 dbus-1 dbus-glib-1 db-util pkgmgr-info capi-system-info libtzplatform-config cynara-monitor)
-pkg_check_modules(pkgs REQUIRED dlog sqlite3 dbus-1 dbus-glib-1 db-util pkgmgr-info capi-system-info libtzplatform-config)
+#pkg_check_modules(pkgs REQUIRED dlog sqlite3 dbus-1 dbus-glib-1 db-util pkgmgr-info capi-system-info libtzplatform-config security-privilege-manager cynara-monitor)
+pkg_check_modules(pkgs REQUIRED dlog sqlite3 dbus-1 dbus-glib-1 db-util pkgmgr-info capi-system-info libtzplatform-config security-privilege-manager)
FOREACH(flag ${pkgs_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
#include <memory>
#include <list>
#include <mutex>
+#include <glib.h>
#include "ICommonDb.h"
#include "privacy_guard_client_types.h"
#include "PrivacyGuardTypes.h"
-#ifdef __FILTER_LISTED_PKG
-#include <map>
-#endif
-
class PrivacyGuardDb : public ICommonDb
{
private:
static std::mutex m_singletonMutex;
static PrivacyGuardDb* m_pInstance;
-#ifdef __FILTER_LISTED_PKG
- const static std::string PRIVACY_FILTER_LIST_FILE;
- const static std::string FILTER_KEY;
- static std::map < std::string, bool > m_filteredPkgList;
-#endif
+ static GList *m_privacy_list;
+ bool m_bInitialized;
private:
- void createDB(void);
-
PrivacyGuardDb(void);
-
+ void initialize(void);
~PrivacyGuardDb(void);
public:
#include <sqlite3.h>
#include <pkgmgr-info.h>
#include <time.h>
+#include <privilege_info.h>
#include "Utils.h"
#include "PrivacyGuardDb.h"
#include "PrivacyIdInfo.h"
+
#if 0
// [CYNARA]
#include "CynaraService.h"
std::mutex PrivacyGuardDb::m_singletonMutex;
PrivacyGuardDb* PrivacyGuardDb::m_pInstance = NULL;
-
-static const char* privacy_list[5] = { "http://tizen.org/privacy/location",
- "http://tizen.org/privacy/contact",
- "http://tizen.org/privacy/calendar",
- "http://tizen.org/privacy/messaging",
- "http://tizen.org/privacy/callhistory" };
-
-#ifdef __FILTER_LISTED_PKG
-const std::string PrivacyGuardDb::PRIVACY_FILTER_LIST_FILE = std::string("/usr/share/privacy-guard/privacy-guard-list.ini");
-const std::string PrivacyGuardDb::FILTER_KEY = std::string("package_id");
-std::map < std::string, bool > PrivacyGuardDb::m_filteredPkgList;
-#endif
+GList *PrivacyGuardDb::m_privacy_list = NULL;
void
-PrivacyGuardDb::createDB(void)
+PrivacyGuardDb::initialize(void)
{
+ int res = privilege_info_get_privacy_list(&m_privacy_list);
+ if (res != PRVMGR_ERR_NONE) {
+ PG_LOGE("Failed to get privacy list from security-privilege-manager [%d].", res);
+ return;
+ }
+ m_bInitialized = true;
}
void
{
int res = -1;
res = sqlite3_open_v2(PRIVACY_DB_PATH, &m_sqlHandler, SQLITE_OPEN_READWRITE, NULL);
- if(res == SQLITE_OK) {
+ if(res == SQLITE_OK) {
PG_LOGI("monitor db is opened successfully");
// sqlite3_wal_autocheckpoint(m_sqlHandler, 1);
m_bDBOpen = true;
{
time_t current_date;
struct tm tm;
+
current_date = time(NULL);
localtime_r(¤t_date, &tm);
-
if(current_date <= 0) {
- return PRIV_GUARD_ERROR_INVALID_PARAMETER;
+ PG_LOGE("Failed to get current date. Date: [%d] So, return PRIV_GUARD_ERROR_SYSTEM_ERROR.", current_date);
+ return PRIV_GUARD_ERROR_SYSTEM_ERROR;
}
int res = -1;
static const std::string QUERY_INSERT = std::string("INSERT INTO StatisticsMonitorInfo(USER_ID, PKG_ID, PRIVACY_ID, USE_DATE) VALUES(?, ?, ?, ?)");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
}
TryCatchResLogReturn(m_bDBOpen == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_IO_ERROR, "openSqliteDB : %d", res);
- PG_LOGD("addlogToDb m_sqlHandler : %p", m_sqlHandler);
-
// prepare
res = sqlite3_prepare_v2(m_sqlHandler, QUERY_INSERT.c_str(), -1, &m_stmt, NULL);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_prepare_v2 : %d", res);
for (std::list <std::pair <std::string, std::string>>::iterator iter = logInfoList.begin(); iter != logInfoList.end(); ++iter) {
- PG_LOGD("packageID : %s, PrivacyID : %s", iter->first.c_str(), iter->second.c_str());
+ PG_LOGD("packageID: %s, PrivacyID: %s", iter->first.c_str(), iter->second.c_str());
// bind
res = sqlite3_bind_int(m_stmt, 1, userId);
int
PrivacyGuardDb::PgAddPrivacyAccessLogForCynara(const int userId, const std::string packageId, const std::string privilege, const timespec* timestamp)
{
+ ////////////////////////////////////////////////
+ // check userId, packageId, privilege here..
+ ////////////////////////////////////////////////
if(timestamp->tv_sec <= 0) {
+ PG_LOGE("Invalid timestamp value: [%d]", timestamp->tv_sec);
return PRIV_GUARD_ERROR_INVALID_PARAMETER;
}
static const std::string QUERY_INSERT = std::string("INSERT INTO StatisticsMonitorInfo(USER_ID, PKG_ID, PRIVACY_ID, USE_DATE) VALUES(?, ?, ?, ?)");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string QUERY_INSERT = std::string("INSERT INTO StatisticsMonitorInfo(USER_ID, PKG_ID, PRIVACY_ID, USE_DATE) VALUES(?, ?, ?, ?)");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string QUERY_INSERT = std::string("INSERT INTO MonitorPolicy(USER_ID, PKG_ID, PRIVACY_ID, MONITOR_POLICY) VALUES(?, ?, ?, ?)");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
}
TryCatchResLogReturn(m_bDBOpen == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_IO_ERROR, "openSqliteDB : %d", res);
- PG_LOGD("addlogToDb m_sqlHandler : %p", m_sqlHandler);
-
// prepare
res = sqlite3_prepare_v2(m_sqlHandler, QUERY_INSERT.c_str(), -1, &m_stmt, NULL);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_prepare_v2 : %d", res);
static const std::string query = std::string("SELECT COUNT(*) FROM MonitorPolicy WHERE USER_ID=? AND PKG_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
int
PrivacyGuardDb::PgDeleteAllLogsAndMonitorPolicy(void)
{
- PG_LOGD("PgDeleteAllLogsAndMonitorPolicy");
-
int res = -1;
static const std::string LOG_DELETE = std::string("DELETE FROM StatisticsMonitorInfo");
static const std::string MAIN_POLICY_DELETE = std::string("DELETE FROM MainMonitorPolicy");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
int
PrivacyGuardDb::PgDeleteLogsByPackageId(const std::string packageId)
{
- PG_LOGD("PrivacyGuardDb::PgDeleteLogsByPackageId packageid : %s", packageId.c_str());
-
int res = -1;
static const std::string QUERY_DELETE = std::string("DELETE FROM StatisticsMonitorInfo WHERE PKG_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
int
PrivacyGuardDb::PgDeleteMonitorPolicyByPackageId(const std::string packageId)
{
- PG_LOGD("PrivacyGuardDb::PgDeleteMonitorPolicyByPackageId packageid : %s", packageId.c_str());
-
int res = -1;
static const std::string QUERY_DELETE = std::string("DELETE FROM MonitorPolicy WHERE PKG_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
sqlite3_stmt* infoStmt;
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string PRIVACY_SELECT = std::string("SELECT COUNT(*) FROM StatisticsMonitorInfo WHERE USER_ID=? AND PRIVACY_ID=? AND USE_DATE>=? AND USE_DATE<=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
}
TryCatchResLogReturn(m_bDBOpen == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_IO_ERROR, "openSqliteDB : %d", res);
- int i;
- int cnt_privacy = sizeof(privacy_list) / sizeof(privacy_list[0]);
-
- for (i = 0; i < cnt_privacy; i++) {
+ GList* l;
+ for (l = m_privacy_list; l != NULL; l = l->next) {
// prepare
res = sqlite3_prepare_v2(m_sqlHandler, PRIVACY_SELECT.c_str(), -1, &m_stmt, NULL);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_prepare_v2 : %d", res);
res = sqlite3_bind_int(m_stmt, 1, userId);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_bind_int : %d", res);
- res = sqlite3_bind_text(m_stmt, 2, privacy_list[i], -1, SQLITE_TRANSIENT);
+ //res = sqlite3_bind_text(m_stmt, 2, privacy_list[i], -1, SQLITE_TRANSIENT);
+ res = sqlite3_bind_text(m_stmt, 2, (char*)l->data, -1, SQLITE_TRANSIENT);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_bind_text : %d", res);
res = sqlite3_bind_int(m_stmt, 3, startDate);
// step
if ((res = sqlite3_step(m_stmt)) == SQLITE_ROW) {
int count = sqlite3_column_int(m_stmt, 0);
- if (count == 0) {
+ if (count == 0)
continue;
- }
- const char* privacyId = privacy_list[i];
+ const char* privacyId = (char*)l->data;
privacyInfoList.push_back(std::pair <std::string, int> (std::string(privacyId), count));
}
sqlite3_reset(m_stmt);
sqlite3_stmt* infoStmt;
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
if ((res = sqlite3_step(infoStmt)) == SQLITE_ROW) {
int count = sqlite3_column_int(infoStmt, 0);
- if (count == 0) {
+ if (count == 0)
continue;
- }
packageInfoList.push_back(std::pair <std::string, int> (std::string(packageId), count));
}
sqlite3_reset(infoStmt);
static const std::string PRIVACY_SELECT = std::string("SELECT COUNT(*) FROM StatisticsMonitorInfo WHERE USER_ID=? AND PKG_ID=? AND PRIVACY_ID=? AND USE_DATE>=? AND USE_DATE<=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
}
TryCatchResLogReturn(m_bDBOpen == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_IO_ERROR, "openSqliteDB : %d", res);
- int i;
- int cnt_privacy = sizeof(privacy_list) / sizeof(privacy_list[0]);
-
- for (i = 0; i < cnt_privacy; i++) {
+ GList *l;
+ for (l = m_privacy_list; l != NULL; l = l->next) {
// prepare
res = sqlite3_prepare_v2(m_sqlHandler, PRIVACY_SELECT.c_str(), -1, &m_stmt, NULL);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_prepare_v2 : %d", res);
res = sqlite3_bind_text(m_stmt, 2, packageId.c_str(), -1, SQLITE_TRANSIENT);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_bind_text : %d", res);
- res = sqlite3_bind_text(m_stmt, 3, privacy_list[i], -1, SQLITE_TRANSIENT);
+ res = sqlite3_bind_text(m_stmt, 3, (char*)l->data, -1, SQLITE_TRANSIENT);
TryCatchResLogReturn(res == SQLITE_OK, m_dbMutex.unlock(), PRIV_GUARD_ERROR_DB_ERROR, "sqlite3_bind_text : %d", res);
res = sqlite3_bind_int(m_stmt, 4, startDate);
if (count == 0) {
continue;
}
- const char* privacyId = privacy_list[i];
+ const char* privacyId = (char*)l->data;
+ PG_LOGD("[kylee] privacy ID: %s", privacyId);
privacyInfoList.push_back(std::pair <std::string, int> (std::string(privacyId), count));
}
sqlite3_reset(m_stmt);
static const std::string query = std::string("SELECT MONITOR_POLICY FROM MonitorPolicy WHERE USER_ID=? AND PKG_ID=? AND PRIVACY_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string MONITOR_POLICY_SELECT = std::string("SELECT * FROM MonitorPolicy");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("SELECT DISTINCT PRIVACY_ID, MONITOR_POLICY FROM MonitorPolicy WHERE USER_ID=? AND PKG_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("SELECT DISTINCT PKG_ID FROM MonitorPolicy WHERE USER_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("SELECT DISTINCT PKG_ID FROM MonitorPolicy WHERE USER_ID=? AND PRIVACY_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("UPDATE MonitorPolicy SET MONITOR_POLICY=? WHERE USER_ID=? AND PKG_ID=? AND PRIVACY_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string QUERY_INSERT = std::string("INSERT INTO MainMonitorPolicy(USER_ID) VALUES(?)");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("UPDATE MainMonitorPolicy SET MAIN_MONITOR_POLICY=? WHERE USER_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string query = std::string("SELECT MAIN_MONITOR_POLICY FROM MainMonitorPolicy WHERE USER_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
static const std::string QUERY_DELETE = std::string("DELETE FROM MainMonitorPolicy WHERE USER_ID=?");
m_dbMutex.lock();
+
+ // initialize
+ if (m_bInitialized == false) {
+ initialize();
+ }
+ TryCatchResLogReturn(m_bInitialized == true, m_dbMutex.unlock(), PRIV_GUARD_ERROR_NOT_INITIALIZED, "Failed to initialize", res);
+
// open db
if(m_bDBOpen == false) {
openSqliteDB();
PrivacyGuardDb::PrivacyGuardDb(void)
{
-
// open DB
m_bDBOpen = false;
m_sqlHandler = NULL;
m_dbMutex.lock();
+ initialize();
openSqliteDB();
m_dbMutex.unlock();
m_stmt = NULL;
m_bDBOpen = false;
m_dbMutex.unlock();
}
+
+ if (m_bInitialized == true) {
+ m_dbMutex.lock();
+ g_list_free(m_privacy_list);
+ m_bInitialized = false;
+ m_dbMutex.unlock();
+ }
}
PrivacyGuardDb*
void
PrivacyInfoService::PgAddPrivacyAccessLog(SocketConnection* pConnector)
{
- PG_LOGI("PRIVACY PrivacyInfoService PgAddPrivacyAccessLog");
-
int userId = 0;
std::list <std::pair<std::string, std::string>> logInfoList;
pConnector->read(&userId, &logInfoList);
- PG_LOGD("PrivacyInfoService PgAddPrivacyAccessLog userId : %d", userId);
int result = PrivacyGuardDb::getInstance()->PgAddPrivacyAccessLog(userId, logInfoList);
void
PrivacyInfoService::PgAddPrivacyAccessLogTest(SocketConnection* pConnector)
{
- PG_LOGI("PRIVACY PrivacyInfoService PgAddPrivacyAccessLogTest");
-
int userId = 0;
std::string packageId;
std::string privacyId;
pConnector->read(&userId, &packageId, &privacyId);
- PG_LOGD("PrivacyInfoService PgAddPrivacyAccessLogTest userId : %d", userId);
int result = PrivacyGuardDb::getInstance()->PgAddPrivacyAccessLogTest(userId, packageId, privacyId);
std::string pkgId;
std::list < std::string > list;
bool privacyPopupRequired = true;
+
pConnector->read(&userId, &pkgId, &list, &privacyPopupRequired);
int result = PrivacyGuardDb::getInstance()->PgAddMonitorPolicy(userId, pkgId, list, privacyPopupRequired);
PrivacyInfoService::PgDeleteLogsByPackageId(SocketConnection* pConnector)
{
std::string packageId;
+
pConnector->read(&packageId);
int result = PrivacyGuardDb::getInstance()->PgDeleteLogsByPackageId(packageId);
PrivacyInfoService::PgDeleteMonitorPolicyByPackageId(SocketConnection* pConnector)
{
std::string packageId;
+
pConnector->read(&packageId);
int result = PrivacyGuardDb::getInstance()->PgDeleteMonitorPolicyByPackageId(packageId);
int startDate = -1;
int endDate = -1;
std::list < std::pair < std::string, int > > packageInfoList;
+
pConnector->read(&userId, &startDate, &endDate);
- PG_LOGD("requested > userId : %d, startDate : %d, endDate : %d", userId, startDate, endDate);
int result = PrivacyGuardDb::getInstance()->PgForeachTotalPrivacyCountOfPackage(userId, startDate, endDate, packageInfoList);
- PG_LOGD("response > packageInfoList size : %d", packageInfoList.size());
pConnector->write(result);
pConnector->write(packageInfoList);
int startDate = -1;
int endDate = -1;
std::list < std::pair < std::string, int > > privacyInfoList;
+
pConnector->read(&userId, &startDate, &endDate);
- PG_LOGD("requested > startDate : %d, endDate : %d", startDate, endDate);
int result = PrivacyGuardDb::getInstance()->PgForeachTotalPrivacyCountOfPrivacy(userId, startDate, endDate, privacyInfoList);
- PG_LOGD("response > privacyInfoList size : %d", privacyInfoList.size());
pConnector->write(result);
pConnector->write(privacyInfoList);
int endDate = -1;
std::string privacyId;
std::list < std::pair < std::string, int > > packageInfoList;
+
pConnector->read(&userId, &startDate, &endDate, &privacyId);
- PG_LOGD("requested > startDate : %d, endDate : %d, privacyId : %s",
- startDate, endDate, privacyId.c_str());
- int result = PrivacyGuardDb::getInstance()->PgForeachPrivacyCountByPrivacyId(userId, startDate, endDate,
- privacyId, packageInfoList);
- PG_LOGD("response > packageInfoList size : %d", packageInfoList.size());
+ int result = PrivacyGuardDb::getInstance()->PgForeachPrivacyCountByPrivacyId(userId, startDate, endDate, privacyId, packageInfoList);
pConnector->write(result);
pConnector->write(packageInfoList);
int endDate = -1;
std::string packageId;
std::list < std::pair < std::string, int > > privacyInfoList;
+
pConnector->read(&userId, &startDate, &endDate, &packageId);
- PG_LOGD("requested > startDate : %d, endDate : %d, packageId : %s",
- startDate, endDate, packageId.c_str());
- int result = PrivacyGuardDb::getInstance()->PgForeachPrivacyCountByPackageId(userId, startDate, endDate,
- packageId, privacyInfoList);
- PG_LOGD("response > privacyInfoList size : %d", privacyInfoList.size());
+ int result = PrivacyGuardDb::getInstance()->PgForeachPrivacyCountByPackageId(userId, startDate, endDate, packageId, privacyInfoList);
pConnector->write(result);
pConnector->write(privacyInfoList);
std::list < std::string > packageList;
pConnector->read(&userId);
- PG_LOGD("requested > userId : %d", userId);
int result = PrivacyGuardDb::getInstance()->PgForeachPrivacyPackageId(userId, packageList);
- PG_LOGD("response > packageList size : %d", packageList.size());
pConnector->write(result);
pConnector->write(packageList);
{
int userId = 0;
std::string packageId;
- pConnector->read(&userId, &packageId);
-
std::list <privacy_data_s> privacyInfoList;
- int result = -1;
- result = PrivacyGuardDb::getInstance()->PgForeachMonitorPolicyByPackageId(userId, packageId, privacyInfoList);
- PG_LOGD("response > privacyInfoList size : %d", privacyInfoList.size());
+ pConnector->read(&userId, &packageId);
+
+ int result = PrivacyGuardDb::getInstance()->PgForeachMonitorPolicyByPackageId(userId, packageId, privacyInfoList);
pConnector->write(result);
pConnector->write(privacyInfoList);
int userId = 0;
std::string packageId;
std::string privacyId;
- pConnector->read(&userId, &packageId, &privacyId);
-
- PG_LOGD("requested > packageId : %s, privacyId : %s", packageId.c_str(), privacyId.c_str());
int monitorPolicy = 1;
- int result = -1;
- result = PrivacyGuardDb::getInstance()->PgGetMonitorPolicy(userId, packageId, privacyId, monitorPolicy);
- PG_LOGD("response > monitorPolicy : %d", monitorPolicy);
+ pConnector->read(&userId, &packageId, &privacyId);
+
+ int result = PrivacyGuardDb::getInstance()->PgGetMonitorPolicy(userId, packageId, privacyId, monitorPolicy);
pConnector->write(result);
pConnector->write(monitorPolicy);
std::list < std::string > packageList;
pConnector->read(&userId, &privacyId);
- PG_LOGD("requested > userId : %d, privacyId : %s", userId, privacyId.c_str());
int result = PrivacyGuardDb::getInstance()->PgForeachPackageByPrivacyId(userId, privacyId, packageList);
- PG_LOGD("response > packageList size : %d", packageList.size());
pConnector->write(result);
pConnector->write(packageList);
int userId = 0;
std::string packageId;
bool isPrivacyPackage = false;
+
pConnector->read(&userId, &packageId);
- PG_LOGD("requested > packageId : %s", packageId.c_str());
int result = PrivacyGuardDb::getInstance()->PgCheckPrivacyPackage(userId, packageId, isPrivacyPackage);
pConnector->write(result);
std::string packageId;
std::string privacyId;
int monitorPolicy = 1;
+
pConnector->read(&userId, &packageId, &privacyId, &monitorPolicy);
- PG_LOGD("requested > packageId : %s, privacyId : %s, monitorPolicy : %d",
- packageId.c_str(), privacyId.c_str(), monitorPolicy);
int result = PrivacyGuardDb::getInstance()->PgUpdateMonitorPolicy(userId, packageId, privacyId, monitorPolicy);
pConnector->write(result);
{
int userId = 0;
bool mainMonitorPolicy = false;
+
pConnector->read(&userId, &mainMonitorPolicy);
- PG_LOGD("requested > mainMonitorPolicy : %d", mainMonitorPolicy);
int result = PrivacyGuardDb::getInstance()->PgUpdateMainMonitorPolicy(userId, mainMonitorPolicy);
pConnector->write(result);
PrivacyInfoService::PgGetMainMonitorPolicy(SocketConnection* pConnector)
{
int userId = 0;
- pConnector->read(&userId);
-
- PG_LOGD("PgGetMainMonitorPolicy userId : %d", userId);
-
bool mainMonitorPolicy = false;
- int result = -1;
- result = PrivacyGuardDb::getInstance()->PgGetMainMonitorPolicy(userId, mainMonitorPolicy);
- PG_LOGD("response > mainMonitorPolicy : %d", mainMonitorPolicy);
+ pConnector->read(&userId);
+
+ int result = PrivacyGuardDb::getInstance()->PgGetMainMonitorPolicy(userId, mainMonitorPolicy);
pConnector->write(result);
pConnector->write(mainMonitorPolicy);
PrivacyInfoService::PgDeleteMainMonitorPolicyByUserId(SocketConnection* pConnector)
{
int userId = 0;
+
pConnector->read(&userId);
int result = PrivacyGuardDb::getInstance()->PgDeleteMainMonitorPolicyByUserId(userId);
projects / platform / core / security / privacy-guard.git / commitdiff