4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
7 * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
35 #include <pkgmgr-info.h>
36 #include <iniparser.h>
37 /* For multi-user support */
38 #include <tzplatform_config.h>
40 #include "package-manager.h"
41 #include "pkgmgr-internal.h"
42 #include "pkgmgr-debug.h"
43 #include "pkgmgr-api.h"
44 #include "comm_client.h"
46 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
48 #define BINSH_NAME "/bin/sh"
51 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
53 static int _get_request_id()
55 static int internal_req_id = 1;
57 return internal_req_id++;
60 typedef struct _req_cb_info {
63 pkgmgr_handler event_cb;
65 struct _req_cb_info *next;
68 typedef struct _listen_cb_info {
70 pkgmgr_handler event_cb;
72 struct _listen_cb_info *next;
75 typedef struct _pkgmgr_client_t {
85 listen_cb_info *lhead;
93 typedef struct _iter_data {
94 pkgmgr_iter_fn iter_fn;
98 static int __xsystem(const char *argv[])
105 perror("fork failed");
109 execvp(argv[0], (char *const *)argv);
115 if (waitpid(pid, &status, 0) == -1) {
116 perror("waitpid failed");
119 if (WIFSIGNALED(status)) {
123 if (!WIFEXITED(status)) {
124 /* shouldn't happen */
125 perror("should not happen");
128 return WEXITSTATUS(status);
131 static void __error_to_string(int errnumber, char **errstr)
136 case PKGCMD_ERR_PACKAGE_NOT_FOUND:
137 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
139 case PKGCMD_ERR_PACKAGE_INVALID:
140 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
142 case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
143 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
145 case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
146 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
148 case PKGCMD_ERR_MANIFEST_INVALID:
149 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
151 case PKGCMD_ERR_CONFIG_NOT_FOUND:
152 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
154 case PKGCMD_ERR_CONFIG_INVALID:
155 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
157 case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
158 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
160 case PKGCMD_ERR_SIGNATURE_INVALID:
161 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
163 case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
164 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
166 case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
167 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
169 case PKGCMD_ERR_CERTIFICATE_INVALID:
170 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
172 case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
173 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
175 case PKGCMD_ERR_CERTIFICATE_EXPIRED:
176 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
178 case PKGCMD_ERR_INVALID_PRIVILEGE:
179 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
181 case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
182 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
184 case PKGCMD_ERR_FATAL_ERROR:
185 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
187 case PKGCMD_ERR_OUT_OF_STORAGE:
188 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
190 case PKGCMD_ERR_OUT_OF_MEMORY:
191 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
193 case PKGCMD_ERR_ARGUMENT_INVALID:
194 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
197 *errstr = PKGCMD_ERR_UNKNOWN_STR;
202 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
203 const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
206 req_cb_info *cb_info;
207 req_cb_info *current;
210 cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
211 if (cb_info == NULL) {
212 DBG("calloc failed");
215 cb_info->request_id = request_id;
216 cb_info->req_key = strdup(req_key);
217 cb_info->event_cb = event_cb;
218 cb_info->data = data;
219 cb_info->next = NULL;
220 pc->new_event_cb = new_event_cb;
222 if (pc->info.request.rhead == NULL)
223 pc->info.request.rhead = cb_info;
225 current = prev = pc->info.request.rhead;
228 current = current->next;
231 prev->next = cb_info;
235 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
239 tmp = pc->info.request.rhead;
246 DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
249 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
256 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
257 pkgmgr_handler event_cb, void *data)
259 listen_cb_info *cb_info;
260 listen_cb_info *current;
261 listen_cb_info *prev;
263 cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
264 if (cb_info == NULL) {
265 DBG("calloc failed");
268 cb_info->request_id = request_id;
269 cb_info->event_cb = event_cb;
270 cb_info->data = data;
271 cb_info->next = NULL;
273 /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
274 if (pc->info.listening.lhead == NULL)
275 pc->info.listening.lhead = cb_info;
277 current = prev = pc->info.listening.lhead;
280 current = current->next;
283 prev->next = cb_info;
287 static void __operation_callback(void *cb_data, uid_t target_uid,
288 const char *req_id, const char *pkg_type,
289 const char *pkgid, const char *key,
293 req_cb_info *cb_info;
295 pc = (pkgmgr_client_t *) cb_data;
297 /* find callback info */
298 cb_info = __find_op_cbinfo(pc, req_id);
299 if (cb_info == NULL) {
300 ERR("cannot fint cb_info for req_id:%s", req_id);
305 if (cb_info->event_cb) {
306 if (pc->new_event_cb)
307 cb_info->event_cb(target_uid, cb_info->request_id,
308 pkg_type, pkgid, key, val, pc,
311 cb_info->event_cb(target_uid, cb_info->request_id,
312 pkg_type, pkgid, key, val, NULL,
319 static void __status_callback(void *cb_data, uid_t target_uid,
320 const char *req_id, const char *pkg_type,
321 const char *pkgid, const char *key,
327 pc = (pkgmgr_client_t *) cb_data;
329 tmp = pc->info.listening.lhead;
331 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
332 key, val, NULL, tmp->data) != 0)
340 static inline int __read_proc(const char *path, char *buf, int size)
345 if (buf == NULL || path == NULL)
348 fd = open(path, O_RDONLY);
352 ret = read(fd, buf, size - 1);
364 char *__proc_get_cmdline_bypid(int pid)
366 char buf[PKG_STRING_LEN_MAX] = {'\0', };
369 snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
370 ret = __read_proc(buf, buf, sizeof(buf));
374 /* support app launched by shell script*/
375 if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
376 return strdup(&buf[BINSH_SIZE + 1]);
381 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
386 if (buf == NULL || path == NULL)
389 fd = open(path, O_RDONLY);
393 ret = read(fd, buf, size - 1);
405 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
406 const char *cmdline, const char *apppath)
410 if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
412 if (pid != getpgid(pid))
419 static int __sync_process(const char *req_key)
422 char info_file[PKG_STRING_LEN_MAX] = {'\0', };
426 char buf[PKG_STRING_LEN_MAX] = {0, };
428 snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
433 if (access(info_file, F_OK) == 0) {
434 fp = fopen(info_file, "r");
436 DBG("file is not generated yet.... wait\n");
437 usleep(100 * 1000); /* 100ms sleep*/
441 if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
442 ERR("failed to read info file");
448 DBG("info_file file is generated, result = %s. \n", buf);
453 DBG("file is not generated yet.... wait\n");
454 usleep(100 * 1000); /* 100ms sleep*/
456 if (check_cnt > 6000) { /* 60s * 10 time over*/
457 ERR("wait time over!!\n");
462 ret = remove(info_file);
464 ERR("file is can not remove[%s, %d]\n", info_file, ret);
469 static int __csc_process(const char *csc_path, char *result_path)
476 char *pkgtype = NULL;
478 char buf[PKG_STRING_LEN_MAX] = {0,};
479 char type_buf[1024] = { 0 };
480 char des_buf[1024] = { 0 };
481 dictionary *csc = NULL;
484 csc = iniparser_load(csc_path);
485 retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
487 file = fopen(result_path, "w");
488 tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
490 count = iniparser_getint(csc, "csc packages:count", -1);
491 tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
493 snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
494 fwrite(buf, 1, strlen(buf), file);
495 snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
496 fwrite(buf, 1, strlen(buf), file);
498 for(cnt = 1 ; cnt <= count ; cnt++)
500 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
501 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
503 pkgtype = iniparser_getstring(csc, type_buf, NULL);
504 des = iniparser_getstring(csc, des_buf, NULL);
507 if (pkgtype == NULL) {
509 snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
510 fwrite(buf, 1, strlen(buf), file);
512 } else if (des == NULL) {
514 snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
515 fwrite(buf, 1, strlen(buf), file);
519 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
520 fwrite(buf, 1, strlen(buf), file);
521 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
522 fwrite(buf, 1, strlen(buf), file);
524 if (strcmp(pkgtype, "tpk") == 0) {
525 const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
526 ret = __xsystem(ospinstaller_argv);
527 } else if (strcmp(pkgtype, "wgt")== 0) {
528 const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
529 ret = __xsystem(wrtinstaller_argv);
537 __error_to_string(ret, &errstr);
538 snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
541 snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
543 fwrite(buf, 1, strlen(buf), file);
547 iniparser_freedict(csc);
557 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid,
558 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
562 int ret = PKGMGR_R_ECOMM;
563 char *req_key = NULL;
564 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
566 if (pc == NULL || pkgid == NULL) {
567 ERR("invalid parameter");
568 return PKGMGR_R_EINVAL;
571 if (mpc->ctype != PC_REQUEST) {
572 ERR("mpc->ctype is not PC_REQUEST");
573 return PKGMGR_R_EINVAL;
575 result = comm_client_request(mpc->info.request.cc, "getsize",
576 g_variant_new("(si)", pkgid, get_type));
578 return PKGMGR_R_ECOMM;
580 g_variant_get(result, "(i&s)", &ret, &req_key);
581 if (req_key == NULL) {
582 g_variant_unref(result);
583 return PKGMGR_R_ECOMM;
585 if (ret != PKGMGR_R_OK) {
586 g_variant_unref(result);
590 ret = __sync_process(req_key);
592 ERR("get size failed, ret=%d\n", ret);
594 g_variant_unref(result);
599 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
600 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
601 pkgmgr_handler event_cb, void *data)
605 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, 0, uid);
607 ERR("move request failed");
612 ret = __sync_process(pkgid);
614 ERR("move pkg failed, ret=%d\n", ret);
619 static int __check_app_process(pkgmgr_request_service_type service_type,
620 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
622 GVariant *result = NULL;
623 int ret = PKGMGR_R_ECOMM;
624 pkgmgrinfo_pkginfo_h handle;
626 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
628 retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
630 if (uid != GLOBAL_USER)
631 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
633 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
634 retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
636 if (service_type == PM_REQUEST_KILL_APP)
637 result = comm_client_request(mpc->info.request.cc, "kill",
638 g_variant_new("(s)", pkgid));
639 else if (service_type == PM_REQUEST_CHECK_APP)
640 result = comm_client_request(mpc->info.request.cc, "check",
641 g_variant_new("(s)", pkgid));
644 return PKGMGR_R_ECOMM;
645 g_variant_get(result, "(i)", &ret);
646 g_variant_unref(result);
647 if (ret != PKGMGR_R_OK) {
648 ERR("request failed, ret=%d", ret);
653 pid = __sync_process(pkgid);
656 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
662 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
665 int ret = PKGMGR_R_ECOMM;
666 char *req_key = NULL;
667 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
670 ERR("invalid parameter");
671 return PKGMGR_R_EINVAL;
674 if (mpc->ctype != PC_REQUEST) {
675 ERR("mpc->ctype is not PC_REQUEST");
676 return PKGMGR_R_EINVAL;
679 result = comm_client_request(mpc->info.request.cc, "getsize",
680 g_variant_new("(si)", "size_info", PM_GET_SIZE_INFO));
682 return PKGMGR_R_ECOMM;
684 g_variant_get(result, "(i&s)", &ret, &req_key);
685 if (req_key == NULL) {
686 g_variant_unref(result);
687 return PKGMGR_R_ECOMM;
690 g_variant_unref(result);
695 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
699 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
700 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
702 /* free listening head */
703 req_cb_info *tmp = NULL;
704 req_cb_info *prev = NULL;
705 for (tmp = mpc->info.request.rhead; tmp;) {
711 /* free dbus connection */
712 ret = comm_client_free(mpc->info.request.cc);
713 retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
715 /* Manage pc for seperated event */
716 mpc->ctype = PC_REQUEST;
717 mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
720 mpc->info.request.cc = comm_client_new();
721 retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
723 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
724 retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
729 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
730 const char *pkgid, const char *key,
731 const char *value, const void *pc, void *user_data)
734 DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
735 target_uid, req_id, req_type, pkgid, key, value);
737 pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
738 retvm_if(size_info == NULL, -1, "The memory is insufficient.");
740 char *save_ptr = NULL;
741 char *token = strtok_r((char*)value, ":", &save_ptr);
742 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
743 size_info->data_size = atoll(token);
744 token = strtok_r(NULL, ":", &save_ptr);
745 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
746 size_info->cache_size = atoll(token);
747 token = strtok_r(NULL, ":", &save_ptr);
748 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
749 size_info->app_size = atoll(token);
750 token = strtok_r(NULL, ":", &save_ptr);
751 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
752 size_info->ext_data_size = atoll(token);
753 token = strtok_r(NULL, ":", &save_ptr);
754 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
755 size_info->ext_cache_size = atoll(token);
756 token = strtok_r(NULL, ":", &save_ptr);
757 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
758 size_info->ext_app_size = atoll(token);
760 DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
761 size_info->data_size, size_info->cache_size, size_info->app_size,
762 size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
764 pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
765 tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
767 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
768 { // total package size info
769 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
770 callback((pkgmgr_client *)pc, size_info, user_data);
774 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
775 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
787 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
789 pkgmgr_client_t *pc = NULL;
792 retvm_if(ctype == PC_BROADCAST, NULL, "broadcast type is not supported");
793 retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING, NULL, "ctype is not client_type");
795 /* Allocate memory for ADT:pkgmgr_client */
796 pc = calloc(1, sizeof(pkgmgr_client_t));
797 retvm_if(pc == NULL, NULL, "No memory");
801 pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
804 if (pc->ctype == PC_REQUEST) {
805 pc->info.request.cc = comm_client_new();
806 trym_if(pc->info.request.cc == NULL, "client creation failed");
808 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
809 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
810 } else if (pc->ctype == PC_LISTENING) {
811 pc->info.listening.cc = comm_client_new();
812 trym_if(pc->info.listening.cc == NULL, "client creation failed");
814 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
815 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
818 return (pkgmgr_client *) pc;
826 API int pkgmgr_client_free(pkgmgr_client *pc)
829 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
830 retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
832 if (mpc->ctype == PC_REQUEST) {
835 for (tmp = mpc->info.request.rhead; tmp;) {
841 ret = comm_client_free(mpc->info.request.cc);
842 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
843 } else if (mpc->ctype == PC_LISTENING) {
845 listen_cb_info *prev;
846 for (tmp = mpc->info.listening.lhead; tmp;) {
852 ret = comm_client_free(mpc->info.listening.cc);
853 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
854 } else if (mpc->ctype == PC_BROADCAST) {
857 ERR("Invalid client type\n");
858 return PKGMGR_R_EINVAL;
863 mpc->tep_path = NULL;
868 mpc->tep_move = NULL;
880 return PKGMGR_R_ERROR;
883 static char *__get_type_from_path(const char *pkg_path)
886 char mimetype[255] = { '\0', };
887 char extlist[256] = { '\0', };
890 ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
892 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
896 ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
898 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
902 if (strlen(extlist) == 0)
905 if (strchr(extlist, ','))
906 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
908 pkg_type = strchr(extlist, '.') + 1;
909 return strdup(pkg_type);
912 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, char *tep_path, char *tep_move)
914 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
915 retvm_if(tep_path == NULL, PKGMGR_R_EINVAL, "tep path is NULL");
916 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
918 mpc->tep_path = strdup(tep_path);
919 mpc->tep_move = strdup(tep_move);
924 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
925 const char *descriptor_path, const char *pkg_path,
926 const char *optional_file, pkgmgr_mode mode,
927 pkgmgr_handler event_cb, void *data, uid_t uid)
930 int ret = PKGMGR_R_ECOMM;
931 char *req_key = NULL;
932 GVariantBuilder *builder = NULL;
933 GVariant *args = NULL;
935 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
939 if (pc == NULL || pkg_path == NULL) {
940 ERR("invalid parameter");
941 return PKGMGR_R_EINVAL;
944 if (mpc->ctype != PC_REQUEST) {
945 ERR("mpc->ctype is not PC_REQUEST");
946 return PKGMGR_R_EINVAL;
949 if (access(pkg_path, F_OK) != 0) {
950 ERR("failed to access: %s", pkg_path);
951 return PKGMGR_R_EINVAL;
954 if (mpc->tep_path != NULL && access(mpc->tep_path, F_OK) != 0) {
955 ERR("failed to access: %s", mpc->tep_path);
956 return PKGMGR_R_EINVAL;
959 /* TODO: check pkg's type on server-side */
960 if (pkg_type == NULL)
961 pkgtype = __get_type_from_path(pkg_path);
963 pkgtype = strdup(pkg_type);
965 /* build arguments */
966 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
968 g_variant_builder_add(builder, "s", "-e");
969 g_variant_builder_add(builder, "s", mpc->tep_path);
970 g_variant_builder_add(builder, "s", "-M");
971 g_variant_builder_add(builder, "s", mpc->tep_move);
974 args = g_variant_new("as", builder);
975 g_variant_builder_unref(builder);
977 result = comm_client_request(mpc->info.request.cc, "install",
978 g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args));
981 return PKGMGR_R_ECOMM;
982 g_variant_get(result, "(i&s)", &ret, &req_key);
983 if (req_key == NULL) {
984 g_variant_unref(result);
985 return PKGMGR_R_ECOMM;
987 if (ret != PKGMGR_R_OK) {
988 g_variant_unref(result);
992 req_id = _get_request_id();
993 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
995 g_variant_unref(result);
1000 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
1001 const char *descriptor_path, const char *pkg_path,
1002 const char *optional_file, pkgmgr_mode mode,
1003 pkgmgr_handler event_cb, void *data)
1005 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
1006 pkg_path, optional_file, mode, event_cb,data,
1010 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
1011 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
1012 pkgmgr_handler event_cb, void *data)
1014 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file,
1015 mode, event_cb, data,GLOBAL_USER);
1018 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type,
1019 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
1020 pkgmgr_handler event_cb, void *data, uid_t uid)
1023 int ret = PKGMGR_R_ECOMM;
1024 char *req_key = NULL;
1026 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1028 pkgmgrinfo_pkginfo_h handle;
1030 if (pc == NULL || pkgid == NULL) {
1031 ERR("invalid parameter");
1032 return PKGMGR_R_EINVAL;
1035 if (mpc->ctype != PC_REQUEST) {
1036 ERR("mpc->ctype is not PC_REQUEST");
1037 return PKGMGR_R_EINVAL;
1040 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1042 return PKGMGR_R_EINVAL;
1044 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1046 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1047 return PKGMGR_R_ERROR;
1050 result = comm_client_request(mpc->info.request.cc, "reinstall",
1051 g_variant_new("(uss)", uid, pkgtype, pkgid));
1052 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1054 return PKGMGR_R_ECOMM;
1055 g_variant_get(result, "(i&s)", &ret, &req_key);
1056 if (req_key == NULL) {
1057 g_variant_unref(result);
1058 return PKGMGR_R_ECOMM;
1060 if (ret != PKGMGR_R_OK) {
1061 g_variant_unref(result);
1065 req_id = _get_request_id();
1066 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1068 g_variant_unref(result);
1073 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1074 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1077 return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,
1081 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1082 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1083 void *data, uid_t uid)
1086 int ret = PKGMGR_R_ECOMM;
1087 char *req_key = NULL;
1089 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1091 pkgmgrinfo_pkginfo_h handle;
1093 if (pc == NULL || pkgid == NULL) {
1094 ERR("invalid parameter");
1095 return PKGMGR_R_EINVAL;
1098 if (mpc->ctype != PC_REQUEST) {
1099 ERR("mpc->ctype is not PC_REQUEST");
1100 return PKGMGR_R_EINVAL;
1103 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1105 return PKGMGR_R_EINVAL;
1107 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1109 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1110 return PKGMGR_R_ERROR;
1113 /* TODO: check removable ? */
1115 result = comm_client_request(mpc->info.request.cc, "uninstall",
1116 g_variant_new("(uss)", uid, pkgtype, pkgid));
1117 if (result == NULL) {
1118 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1119 return PKGMGR_R_ECOMM;
1121 g_variant_get(result, "(i&s)", &ret, &req_key);
1122 if (req_key == NULL) {
1123 g_variant_unref(result);
1124 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1125 return PKGMGR_R_ECOMM;
1127 if (ret != PKGMGR_R_OK) {
1128 g_variant_unref(result);
1129 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1133 req_id = _get_request_id();
1134 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1136 g_variant_unref(result);
1137 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1142 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1143 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1145 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, mode,
1148 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1149 const char *pkgid, pkgmgr_move_type move_type,
1150 pkgmgr_mode mode, uid_t uid)
1153 int ret = PKGMGR_R_ECOMM;
1154 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1156 if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
1157 ERR("invalid parameter");
1158 return PKGMGR_R_EINVAL;
1161 if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1162 return PKGMGR_R_EINVAL;
1164 if (mpc->ctype != PC_REQUEST) {
1165 ERR("mpc->ctype is not PC_REQUEST");
1166 return PKGMGR_R_EINVAL;
1169 result = comm_client_request(mpc->info.request.cc, "move",
1170 g_variant_new("(uss)", uid, pkg_type, pkgid));
1172 return PKGMGR_R_ECOMM;
1173 g_variant_get(result, "(i)", &ret);
1174 g_variant_unref(result);
1179 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1180 const char *pkgid, uid_t uid)
1183 int ret = PKGMGR_R_ECOMM;
1184 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1186 if (pc == NULL || pkgid == NULL) {
1187 ERR("invalid parameter");
1188 return PKGMGR_R_EINVAL;
1191 result = comm_client_request(mpc->info.request.cc, "enable_pkg",
1192 g_variant_new("(us)", uid, pkgid));
1194 return PKGMGR_R_ECOMM;
1195 g_variant_get(result, "(i)", &ret);
1196 g_variant_unref(result);
1201 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1204 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1207 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1208 const char *pkgid, uid_t uid)
1211 int ret = PKGMGR_R_ECOMM;
1212 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1214 if (pc == NULL || pkgid == NULL) {
1215 ERR("invalid parameter");
1216 return PKGMGR_R_EINVAL;
1219 result = comm_client_request(mpc->info.request.cc, "disable_pkg",
1220 g_variant_new("(us)", uid, pkgid));
1222 return PKGMGR_R_ECOMM;
1223 g_variant_get(result, "(i)", &ret);
1224 g_variant_unref(result);
1229 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1232 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
1235 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1239 int ret = PKGMGR_R_ECOMM;
1240 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1242 if (pc == NULL || appid == NULL) {
1243 ERR("invalid parameter");
1244 return PKGMGR_R_EINVAL;
1247 result = comm_client_request(mpc->info.request.cc, "enable_app",
1248 g_variant_new("(us)", uid, appid));
1250 return PKGMGR_R_ECOMM;
1251 g_variant_get(result, "(i)", &ret);
1252 g_variant_unref(result);
1257 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1259 return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1262 /* TODO: deprecate? */
1263 API int pkgmgr_client_usr_activate_appv(pkgmgr_client *pc, const char *appid,
1264 char *const argv[], uid_t uid)
1266 return pkgmgr_client_usr_activate_app(pc, appid, uid);
1269 API int pkgmgr_client_activate_appv(pkgmgr_client *pc, const char *appid,
1272 return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1275 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1279 int ret = PKGMGR_R_ECOMM;
1280 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1282 if (pc == NULL || appid == NULL) {
1283 ERR("invalid parameter");
1284 return PKGMGR_R_EINVAL;
1287 result = comm_client_request(mpc->info.request.cc, "disable_app",
1288 g_variant_new("(us)", uid, appid));
1290 return PKGMGR_R_ECOMM;
1291 g_variant_get(result, "(i)", &ret);
1292 g_variant_unref(result);
1297 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
1299 return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
1302 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1303 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1307 int ret = PKGMGR_R_ECOMM;
1308 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1310 if (pc == NULL || pkg_type == NULL || appid == NULL) {
1311 ERR("invalid parameter");
1312 return PKGMGR_R_EINVAL;
1315 if (mpc->ctype != PC_REQUEST) {
1316 ERR("mpc->ctype is not PC_REQUEST");
1317 return PKGMGR_R_EINVAL;
1320 result = comm_client_request(mpc->info.request.cc, "cleardata",
1321 g_variant_new("(uss)", uid, pkg_type, appid));
1323 return PKGMGR_R_ECOMM;
1325 g_variant_get(result, "(i)", &ret);
1326 g_variant_unref(result);
1331 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1332 const char *appid, pkgmgr_mode mode)
1334 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1338 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1342 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1343 retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
1344 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1346 /* free listening head */
1347 listen_cb_info *tmp = NULL;
1348 listen_cb_info *prev = NULL;
1349 for (tmp = mpc->info.listening.lhead; tmp;) {
1355 /* free dbus connection */
1356 ret = comm_client_free(mpc->info.listening.cc);
1357 retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1359 /* Manage pc for seperated event */
1360 mpc->ctype = PC_LISTENING;
1361 mpc->status_type = status_type;
1363 mpc->info.listening.cc = comm_client_new();
1364 retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
1366 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
1367 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
1368 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
1371 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
1372 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
1373 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
1376 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
1377 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
1378 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
1381 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
1382 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
1383 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
1386 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
1387 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
1388 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
1394 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1398 /* Check for NULL value of pc */
1399 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1400 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1402 /* 0. check input */
1403 retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
1404 retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
1407 req_id = _get_request_id();
1409 /* 2. add callback info to pkgmgr_client */
1410 __add_stat_cbinfo(mpc, req_id, event_cb, data);
1414 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1415 const char *pkgid, const char *key,
1418 /* client cannot broadcast signal */
1422 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
1423 pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1424 const char *custom_info, pkgmgr_handler event_cb, void *data)
1426 return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
1429 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
1430 pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
1431 const char *custom_info, pkgmgr_handler event_cb, void *data)
1435 /* Check for NULL value of service type */
1436 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1437 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1439 switch (service_type) {
1440 case PM_REQUEST_CSC:
1441 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
1442 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1443 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
1445 ret = __csc_process(custom_info, (char *)data);
1447 ERR("__csc_process fail \n");
1453 case PM_REQUEST_MOVE:
1454 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1455 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1456 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1458 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1461 case PM_REQUEST_GET_SIZE:
1462 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1463 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1464 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1466 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1469 case PM_REQUEST_KILL_APP:
1470 case PM_REQUEST_CHECK_APP:
1471 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1472 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1474 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1476 ERR("__check_app_process fail \n");
1483 ERR("Wrong Request\n");
1494 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1497 pkgmgr_client *pc = NULL;
1499 pc = pkgmgr_client_new(PC_REQUEST);
1500 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
1502 ret = __request_size_info(pc, uid);
1504 ERR("__request_size_info fail \n");
1507 pkgmgr_client_free(pc);
1511 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
1513 return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
1516 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1519 int ret = PKGMGR_R_ECOMM;
1520 pkgmgr_client_t *pc;
1522 if (pkgid == NULL) {
1523 ERR("invalid parameter");
1524 return PKGMGR_R_EINVAL;
1527 pc = pkgmgr_client_new(PC_REQUEST);
1529 ERR("out of memory");
1530 return PKGMGR_R_ESYSTEM;
1533 result = comm_client_request(pc->info.request.cc, "clearcache",
1534 g_variant_new("(s)", pkgid));
1536 return PKGMGR_R_ECOMM;
1537 g_variant_get(result, "(i)", &ret);
1538 g_variant_unref(result);
1543 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1545 return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
1548 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1550 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1553 API int pkgmgr_client_clear_all_cache_dir(void)
1555 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
1558 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid,
1559 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1562 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1566 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid,
1567 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1568 void *data, uid_t uid)
1571 int ret = PKGMGR_R_ECOMM;
1572 char *req_key = NULL;
1574 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1576 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1577 ERR("invalid parameter");
1578 return PKGMGR_R_EINVAL;
1581 if (mpc->ctype != PC_REQUEST) {
1582 ERR("mpc->ctype is not PC_REQUEST");
1583 return PKGMGR_R_EINVAL;
1587 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1588 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1590 get_type = PM_GET_PKG_SIZE_INFO;
1591 result = comm_client_request(mpc->info.request.cc, "getsize",
1592 g_variant_new("(usi)", uid, pkgid, get_type));
1594 return PKGMGR_R_ECOMM;
1596 g_variant_get(result, "(i&s)", &ret, &req_key);
1597 if (req_key == NULL) {
1598 g_variant_unref(result);
1599 return PKGMGR_R_ECOMM;
1601 if (ret != PKGMGR_R_OK) {
1602 g_variant_unref(result);
1606 req_id = _get_request_id();
1607 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1609 g_variant_unref(result);
1614 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1615 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1616 void *user_data, uid_t uid)
1619 int ret = PKGMGR_R_ECOMM;
1620 char *req_key = NULL;
1623 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1625 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1626 ERR("invalid parameter");
1627 return PKGMGR_R_EINVAL;
1630 if (mpc->ctype != PC_REQUEST) {
1631 ERR("mpc->ctype is not PC_REQUEST");
1632 return PKGMGR_R_EINVAL;
1636 if (__change_op_cb_for_getsize(mpc) < 0) {
1637 ERR("__change_op_cb_for_getsize failed");
1638 return PKGMGR_R_ESYSTEM;
1641 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1642 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1644 get_type = PM_GET_PKG_SIZE_INFO;
1645 result = comm_client_request(mpc->info.request.cc, "getsize",
1646 g_variant_new("(usi)", uid, pkgid, get_type));
1648 return PKGMGR_R_ECOMM;
1650 g_variant_get(result, "(i&s)", &ret, &req_key);
1651 if (req_key == NULL) {
1652 g_variant_unref(result);
1653 return PKGMGR_R_ECOMM;
1655 if (ret != PKGMGR_R_OK) {
1656 g_variant_unref(result);
1660 req_id = _get_request_id();
1661 __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb,
1664 g_variant_unref(result);
1669 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc, const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, void *user_data)
1671 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
1674 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data, uid_t uid)
1675 { // total package size info
1676 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
1679 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1681 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, GLOBAL_USER);