#include <sys/signalfd.h>
#include <signal.h>
#include <grp.h>
+#include <dlfcn.h>
#include <fcntl.h>
+#include <fnmatch.h>
#include <glib.h>
#include <gio/gio.h>
#include <pkgmgr-info.h>
#include <pkgmgr/pkgmgr_parser_db.h>
#include <tzplatform_config.h>
-#include <drm-tizen-apps.h>
#include <dd-display.h>
-#ifdef TIZEN_FEATURE_CSR
-#include <csr-content-screening.h>
-#endif
#include "pkgmgr_installer.h"
#include "pkgmgr-server.h"
#include "queue.h"
#include "package-manager.h"
+#define USRLIB "/usr/lib"
+
+#define PATH_LIBDRM_SVC_CORE \
+ "/usr/lib/libdrm-service-core-tizen.so.0"
+#define PATH_LIBCSR_CLIENT \
+ "/usr/lib/libcsr-client.so.2"
#define OWNER_ROOT 0
#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
#define APPFW_UID 301
static GHashTable *backend_info_table;
static GMainLoop *mainloop;
+static int (*_drm_tizen_register_license)
+ (const char *pRespBuf, unsigned int respBufLen);
+static int (*_drm_tizen_decrypt_package)(const char *pTADCFilepath,
+ int tadcFileLen, const char *pDecryptedFile,
+ int decryptedFileLen);
+static int (*_drm_tizen_generate_license_request)(const char *pRespBuf,
+ unsigned int respBufLen, char *pReqBuf,
+ unsigned int *pReqBufLen, char *pLicenseUrl,
+ unsigned int *pLicenseUrlLen);
+static void *drm_lib_handle;
+
static int __check_backend_status_for_exit(void);
static int __check_queue_status_for_exit(void);
static int __is_backend_busy(int position);
return TRUE;
}
-#ifdef TIZEN_FEATURE_CSR
static int __check_csr(const char *path)
{
- csr_cs_context_h context = NULL;
- csr_cs_malware_h detected = NULL;
- int ret = -1;
+ int ret;
+ void *context;
+ void *malware;
+ void *lib_handle;
+ int (*_csr_cs_context_create)(void **handle);
+ int (*_csr_cs_scan_file)(void *handle, const char *file_path, void **malware);
+ int (*_csr_cs_context_destroy)(void *handle);
+
+ lib_handle = dlopen(PATH_LIBCSR_CLIENT, RTLD_LAZY);
+ if (!lib_handle) {
+ DBG("Unable to open %s", PATH_LIBCSR_CLIENT);
+ return 0;
+ }
- ret = csr_cs_context_create(&context);
- if (ret != CSR_ERROR_NONE) {
- ERR("Failed to create csr context");
- return -1;
+ _csr_cs_context_create = dlsym(lib_handle, "csr_cs_context_create");
+ _csr_cs_scan_file = dlsym(lib_handle, "csr_cs_scan_file");
+ _csr_cs_context_destroy = dlsym(lib_handle, "csr_cs_context_destroy");
+
+ if (!_csr_cs_context_create || !_csr_cs_scan_file ||
+ !_csr_cs_context_destroy) {
+ ERR("Failed to load CSR symbols");
+ ret = -1;
+ goto catch;
}
- if (context) {
- ret = csr_cs_scan_file(context, path, &detected);
+ ret = _csr_cs_context_create(&context);
+ if (ret != 0) {
+ ERR("Failed to create context");
+ ret = -1;
+ goto catch;
+ }
+
+ ret = _csr_cs_scan_file(context, path, &malware);
+ if (ret != 0) {
DBG("CSR result[%d]", ret);
+ ret = 0;
+ goto catch;
+ }
- csr_cs_context_destroy(context);
- if (detected != NULL) {
- ERR("CSR Denied[%s] Installation", path);
- return -1;
- }
+ ret = _csr_cs_context_destroy(context);
+ if (ret != 0) {
+ ERR("Failed to destroy context");
+ ret = -1;
+ goto catch;
}
- return 0;
+ if (malware != NULL) {
+ ERR("CSR denied[%d] installation", path);
+ ret = -1;
+ }
+
+catch:
+ if (lib_handle)
+ dlclose(lib_handle);
+
+ return ret;
}
-#endif
static int __kill_app(char *appid, uid_t uid)
{
return 0;
}
+static int __load_drm_library(void)
+{
+ if (drm_lib_handle)
+ return 0;
+
+ drm_lib_handle = dlopen(PATH_LIBDRM_SVC_CORE, RTLD_LAZY);
+ if (!drm_lib_handle) {
+ DBG("Unable to open %s", PATH_LIBDRM_SVC_CORE);
+ return -1;
+ }
+
+ _drm_tizen_generate_license_request =
+ dlsym(drm_lib_handle, "drm_tizen_generate_license_request");
+ if (_drm_tizen_generate_license_request == NULL) {
+ ERR("_drm_tizen_generate_license_request() failed");
+ goto catch;
+ }
+
+ _drm_tizen_register_license =
+ dlsym(drm_lib_handle, "drm_tizen_register_license");
+ if (_drm_tizen_register_license == NULL) {
+ ERR("_register_license() failed");
+ goto catch;
+ }
+
+ _drm_tizen_decrypt_package =
+ dlsym(drm_lib_handle, "drm_tizen_decrypt_package");
+ if (_drm_tizen_decrypt_package == NULL) {
+ ERR("_drm_tizen_decrypt_package() failed");
+ goto catch;
+ }
+
+ return 0;
+catch:
+ if (drm_lib_handle) {
+ dlclose(drm_lib_handle);
+ drm_lib_handle = NULL;
+ }
+ return -1;
+}
+
+static void __unload_drm_library(void)
+{
+ if (drm_lib_handle) {
+ dlclose(drm_lib_handle);
+ drm_lib_handle = NULL;
+ }
+}
+
static int __process_generate_license_request(struct backend_job *job)
{
- int ret;
char *resp_data;
char req_data[MAX_PKG_ARGS_LEN];
unsigned int req_data_len;
char license_url[MAX_PKG_ARGS_LEN];
unsigned int license_url_len;
+ int ret;
resp_data = job->args;
req_data_len = sizeof(req_data);
license_url_len = sizeof(license_url);
- ret = drm_tizen_generate_license_request(resp_data, strlen(resp_data),
- req_data, &req_data_len, license_url, &license_url_len);
- if (ret != TADC_SUCCESS) {
- ERR("drm_tizen_generate_license_request failed: %d", ret);
- _return_value_to_caller(job->req_id, g_variant_new("(iss)",
- PKGMGR_R_ESYSTEM, "", ""));
- is_drm_busy = false;
- return -1;
+ if (__load_drm_library() != 0) {
+ ERR("Failed to load library");
+ goto catch;
}
+ ret = _drm_tizen_generate_license_request(resp_data, strlen(resp_data),
+ req_data, &req_data_len,
+ license_url, &license_url_len);
+ if (ret != 1) {
+ ERR("drm_tizen_generate_license_request failed");
+ goto catch;
+ }
_return_value_to_caller(job->req_id,
g_variant_new("(iss)", PKGMGR_R_OK, req_data,
license_url));
is_drm_busy = true;
return 0;
+
+catch:
+ _return_value_to_caller(job->req_id, g_variant_new("(iss)",
+ PKGMGR_R_ESYSTEM, "", ""));
+ is_drm_busy = false;
+ __unload_drm_library();
+ return -1;
}
static int __process_register_license(struct backend_job *job)
{
- int ret;
char *resp_data;
+ int ret;
resp_data = job->args;
-
- ret = drm_tizen_register_license(resp_data, strlen(resp_data));
- if (ret != TADC_SUCCESS) {
+ if (!_drm_tizen_register_license) {
+ ERR("_drm_tizen_register_license is not loaded");
+ goto catch;
+ }
+ ret = _drm_tizen_register_license(resp_data, strlen(resp_data));
+ if (ret != 1) {
ERR("drm_tizen_register_license failed: %d", ret);
- _return_value_to_caller(job->req_id,
- g_variant_new("(i)", PKGMGR_R_ESYSTEM));
- is_drm_busy = false;
- return -1;
+ goto catch;
}
-
_return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
-
return 0;
+
+catch:
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
+ is_drm_busy = false;
+ __unload_drm_library();
+
+ return -1;
}
static int __process_decrypt_package(struct backend_job *job)
decrypted_file_path = job->args;
/* TODO: check ownership of decrypted file */
- ret = drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
+ if (!_drm_tizen_decrypt_package) {
+ ERR("drm_tizen_decrypt_package is not loaded");
+
+ goto catch;
+ }
+ ret = _drm_tizen_decrypt_package(drm_file_path, strlen(drm_file_path),
decrypted_file_path, strlen(decrypted_file_path));
- if (ret != TADC_SUCCESS) {
- ERR("drm_tizen_register_license failed: %d", ret);
- _return_value_to_caller(job->req_id,
- g_variant_new("(i)", PKGMGR_R_ESYSTEM));
- is_drm_busy = false;
- return -1;
+ if (ret != 1) {
+ ERR("drm_tizen_decrypt_package failed: %d", ret);
+ goto catch;
}
-
_return_value_to_caller(job->req_id,
g_variant_new("(i)", PKGMGR_R_OK));
+ return 0;
+
+catch:
+ _return_value_to_caller(job->req_id,
+ g_variant_new("(i)", PKGMGR_R_ESYSTEM));
is_drm_busy = false;
+ __unload_drm_library();
- return 0;
+ return -1;
}
static int __process_update_app_splash_screen(struct backend_job *job, int flag)
/* set current backend job */
DBG("handle request type [%d]", job->req_type);
-#ifdef TIZEN_FEATURE_CSR
if (job->req_type == REQUEST_TYPE_INSTALL ||
job->req_type == REQUEST_TYPE_MOUNT_INSTALL ||
job->req_type == REQUEST_TYPE_REINSTALL) {
return TRUE;
}
}
-#endif
switch (job->req_type) {
case REQUEST_TYPE_INSTALL:
projects / platform / core / appfw / pkgmgr-server.git / commitdiff