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;
91 typedef struct _iter_data {
92 pkgmgr_iter_fn iter_fn;
96 static int __xsystem(const char *argv[])
103 perror("fork failed");
107 execvp(argv[0], (char *const *)argv);
113 if (waitpid(pid, &status, 0) == -1) {
114 perror("waitpid failed");
117 if (WIFSIGNALED(status)) {
121 if (!WIFEXITED(status)) {
122 /* shouldn't happen */
123 perror("should not happen");
126 return WEXITSTATUS(status);
129 static void __error_to_string(int errnumber, char **errstr)
134 case PKGCMD_ERR_PACKAGE_NOT_FOUND:
135 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
137 case PKGCMD_ERR_PACKAGE_INVALID:
138 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
140 case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
141 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
143 case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
144 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
146 case PKGCMD_ERR_MANIFEST_INVALID:
147 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
149 case PKGCMD_ERR_CONFIG_NOT_FOUND:
150 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
152 case PKGCMD_ERR_CONFIG_INVALID:
153 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
155 case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
156 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
158 case PKGCMD_ERR_SIGNATURE_INVALID:
159 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
161 case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
162 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
164 case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
165 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
167 case PKGCMD_ERR_CERTIFICATE_INVALID:
168 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
170 case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
171 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
173 case PKGCMD_ERR_CERTIFICATE_EXPIRED:
174 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
176 case PKGCMD_ERR_INVALID_PRIVILEGE:
177 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
179 case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
180 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
182 case PKGCMD_ERR_FATAL_ERROR:
183 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
185 case PKGCMD_ERR_OUT_OF_STORAGE:
186 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
188 case PKGCMD_ERR_OUT_OF_MEMORY:
189 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
191 case PKGCMD_ERR_ARGUMENT_INVALID:
192 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
195 *errstr = PKGCMD_ERR_UNKNOWN_STR;
200 static void __add_op_cbinfo(pkgmgr_client_t * pc, int request_id,
201 const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
204 req_cb_info *cb_info;
205 req_cb_info *current;
208 cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
209 if (cb_info == NULL) {
210 DBG("calloc failed");
213 cb_info->request_id = request_id;
214 cb_info->req_key = strdup(req_key);
215 cb_info->event_cb = event_cb;
216 cb_info->data = data;
217 cb_info->next = NULL;
218 pc->new_event_cb = new_event_cb;
220 if (pc->info.request.rhead == NULL)
221 pc->info.request.rhead = cb_info;
223 current = prev = pc->info.request.rhead;
226 current = current->next;
229 prev->next = cb_info;
233 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
237 tmp = pc->info.request.rhead;
244 DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
247 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
254 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
255 pkgmgr_handler event_cb, void *data)
257 listen_cb_info *cb_info;
258 listen_cb_info *current;
259 listen_cb_info *prev;
261 cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
262 if (cb_info == NULL) {
263 DBG("calloc failed");
266 cb_info->request_id = request_id;
267 cb_info->event_cb = event_cb;
268 cb_info->data = data;
269 cb_info->next = NULL;
271 /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
272 if (pc->info.listening.lhead == NULL)
273 pc->info.listening.lhead = cb_info;
275 current = prev = pc->info.listening.lhead;
278 current = current->next;
281 prev->next = cb_info;
285 static void __operation_callback(void *cb_data, uid_t target_uid,
286 const char *req_id, const char *pkg_type,
287 const char *pkgid, const char *key,
291 req_cb_info *cb_info;
293 pc = (pkgmgr_client_t *) cb_data;
295 /* find callback info */
296 cb_info = __find_op_cbinfo(pc, req_id);
297 if (cb_info == NULL) {
298 ERR("cannot fint cb_info for req_id:%s", req_id);
303 if (cb_info->event_cb) {
304 if (pc->new_event_cb)
305 cb_info->event_cb(target_uid, cb_info->request_id,
306 pkg_type, pkgid, key, val, pc,
309 cb_info->event_cb(target_uid, cb_info->request_id,
310 pkg_type, pkgid, key, val, NULL,
317 static void __status_callback(void *cb_data, uid_t target_uid,
318 const char *req_id, const char *pkg_type,
319 const char *pkgid, const char *key,
325 pc = (pkgmgr_client_t *) cb_data;
327 tmp = pc->info.listening.lhead;
329 if (tmp->event_cb(target_uid, tmp->request_id, pkg_type, pkgid,
330 key, val, NULL, tmp->data) != 0)
338 static inline int __read_proc(const char *path, char *buf, int size)
343 if (buf == NULL || path == NULL)
346 fd = open(path, O_RDONLY);
350 ret = read(fd, buf, size - 1);
362 char *__proc_get_cmdline_bypid(int pid)
364 char buf[PKG_STRING_LEN_MAX] = {'\0', };
367 snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
368 ret = __read_proc(buf, buf, sizeof(buf));
372 /* support app launched by shell script*/
373 if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
374 return strdup(&buf[BINSH_SIZE + 1]);
379 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
384 if (buf == NULL || path == NULL)
387 fd = open(path, O_RDONLY);
391 ret = read(fd, buf, size - 1);
403 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
404 const char *cmdline, const char *apppath)
408 if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
410 if (pid != getpgid(pid))
417 static int __sync_process(const char *req_key)
420 char info_file[PKG_STRING_LEN_MAX] = {'\0', };
424 char buf[PKG_STRING_LEN_MAX] = {0, };
426 snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
431 if (access(info_file, F_OK) == 0) {
432 fp = fopen(info_file, "r");
434 DBG("file is not generated yet.... wait\n");
435 usleep(100 * 1000); /* 100ms sleep*/
439 if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
440 ERR("failed to read info file");
446 DBG("info_file file is generated, result = %s. \n", buf);
451 DBG("file is not generated yet.... wait\n");
452 usleep(100 * 1000); /* 100ms sleep*/
454 if (check_cnt > 6000) { /* 60s * 10 time over*/
455 ERR("wait time over!!\n");
460 ret = remove(info_file);
462 ERR("file is can not remove[%s, %d]\n", info_file, ret);
467 static int __csc_process(const char *csc_path, char *result_path)
474 char *pkgtype = NULL;
476 char buf[PKG_STRING_LEN_MAX] = {0,};
477 char type_buf[1024] = { 0 };
478 char des_buf[1024] = { 0 };
479 dictionary *csc = NULL;
482 csc = iniparser_load(csc_path);
483 retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
485 file = fopen(result_path, "w");
486 tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
488 count = iniparser_getint(csc, "csc packages:count", -1);
489 tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
491 snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
492 fwrite(buf, 1, strlen(buf), file);
493 snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
494 fwrite(buf, 1, strlen(buf), file);
496 for(cnt = 1 ; cnt <= count ; cnt++)
498 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
499 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
501 pkgtype = iniparser_getstring(csc, type_buf, NULL);
502 des = iniparser_getstring(csc, des_buf, NULL);
505 if (pkgtype == NULL) {
507 snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
508 fwrite(buf, 1, strlen(buf), file);
510 } else if (des == NULL) {
512 snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
513 fwrite(buf, 1, strlen(buf), file);
517 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
518 fwrite(buf, 1, strlen(buf), file);
519 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
520 fwrite(buf, 1, strlen(buf), file);
522 if (strcmp(pkgtype, "tpk") == 0) {
523 const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
524 ret = __xsystem(ospinstaller_argv);
525 } else if (strcmp(pkgtype, "wgt")== 0) {
526 const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
527 ret = __xsystem(wrtinstaller_argv);
535 __error_to_string(ret, &errstr);
536 snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
539 snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
541 fwrite(buf, 1, strlen(buf), file);
545 iniparser_freedict(csc);
555 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid,
556 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
560 int ret = PKGMGR_R_ECOMM;
561 char *req_key = NULL;
562 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
564 if (pc == NULL || pkgid == NULL) {
565 ERR("invalid parameter");
566 return PKGMGR_R_EINVAL;
569 if (mpc->ctype != PC_REQUEST) {
570 ERR("mpc->ctype is not PC_REQUEST");
571 return PKGMGR_R_EINVAL;
573 result = comm_client_request(mpc->info.request.cc, "getsize",
574 g_variant_new("(si)", pkgid, get_type));
576 return PKGMGR_R_ECOMM;
578 g_variant_get(result, "(i&s)", &ret, &req_key);
579 if (req_key == NULL) {
580 g_variant_unref(result);
581 return PKGMGR_R_ECOMM;
583 if (ret != PKGMGR_R_OK) {
584 g_variant_unref(result);
588 ret = __sync_process(req_key);
590 ERR("get size failed, ret=%d\n", ret);
592 g_variant_unref(result);
597 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
598 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
599 pkgmgr_handler event_cb, void *data)
603 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, 0, uid);
605 ERR("move request failed");
610 ret = __sync_process(pkgid);
612 ERR("move pkg failed, ret=%d\n", ret);
617 static int __check_app_process(pkgmgr_request_service_type service_type,
618 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
620 GVariant *result = NULL;
621 int ret = PKGMGR_R_ECOMM;
622 pkgmgrinfo_pkginfo_h handle;
624 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
626 retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
628 if (uid != GLOBAL_USER)
629 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
631 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
632 retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
634 if (service_type == PM_REQUEST_KILL_APP)
635 result = comm_client_request(mpc->info.request.cc, "kill",
636 g_variant_new("(s)", pkgid));
637 else if (service_type == PM_REQUEST_CHECK_APP)
638 result = comm_client_request(mpc->info.request.cc, "check",
639 g_variant_new("(s)", pkgid));
642 return PKGMGR_R_ECOMM;
643 g_variant_get(result, "(i)", &ret);
644 g_variant_unref(result);
645 if (ret != PKGMGR_R_OK) {
646 ERR("request failed, ret=%d", ret);
651 pid = __sync_process(pkgid);
654 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
660 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
663 int ret = PKGMGR_R_ECOMM;
664 char *req_key = NULL;
665 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
668 ERR("invalid parameter");
669 return PKGMGR_R_EINVAL;
672 if (mpc->ctype != PC_REQUEST) {
673 ERR("mpc->ctype is not PC_REQUEST");
674 return PKGMGR_R_EINVAL;
677 result = comm_client_request(mpc->info.request.cc, "getsize",
678 g_variant_new("(si)", "size_info", PM_GET_SIZE_INFO));
680 return PKGMGR_R_ECOMM;
682 g_variant_get(result, "(i&s)", &ret, &req_key);
683 if (req_key == NULL) {
684 g_variant_unref(result);
685 return PKGMGR_R_ECOMM;
688 g_variant_unref(result);
693 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
697 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
698 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
700 /* free listening head */
701 req_cb_info *tmp = NULL;
702 req_cb_info *prev = NULL;
703 for (tmp = mpc->info.request.rhead; tmp;) {
709 /* free dbus connection */
710 ret = comm_client_free(mpc->info.request.cc);
711 retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
713 /* Manage pc for seperated event */
714 mpc->ctype = PC_REQUEST;
715 mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
718 mpc->info.request.cc = comm_client_new();
719 retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
721 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
722 retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
727 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
728 const char *pkgid, const char *key,
729 const char *value, const void *pc, void *user_data)
732 DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
733 target_uid, req_id, req_type, pkgid, key, value);
735 pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
736 retvm_if(size_info == NULL, -1, "The memory is insufficient.");
738 char *save_ptr = NULL;
739 char *token = strtok_r((char*)value, ":", &save_ptr);
740 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
741 size_info->data_size = atoll(token);
742 token = strtok_r(NULL, ":", &save_ptr);
743 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
744 size_info->cache_size = atoll(token);
745 token = strtok_r(NULL, ":", &save_ptr);
746 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
747 size_info->app_size = atoll(token);
748 token = strtok_r(NULL, ":", &save_ptr);
749 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
750 size_info->ext_data_size = atoll(token);
751 token = strtok_r(NULL, ":", &save_ptr);
752 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
753 size_info->ext_cache_size = atoll(token);
754 token = strtok_r(NULL, ":", &save_ptr);
755 tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
756 size_info->ext_app_size = atoll(token);
758 DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
759 size_info->data_size, size_info->cache_size, size_info->app_size,
760 size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
762 pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
763 tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
765 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
766 { // total package size info
767 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
768 callback((pkgmgr_client *)pc, size_info, user_data);
772 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
773 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
785 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
787 pkgmgr_client_t *pc = NULL;
790 retvm_if(ctype == PC_BROADCAST, NULL, "broadcast type is not supported");
791 retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING, NULL, "ctype is not client_type");
793 /* Allocate memory for ADT:pkgmgr_client */
794 pc = calloc(1, sizeof(pkgmgr_client_t));
795 retvm_if(pc == NULL, NULL, "No memory");
799 pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
801 if (pc->ctype == PC_REQUEST) {
802 pc->info.request.cc = comm_client_new();
803 trym_if(pc->info.request.cc == NULL, "client creation failed");
805 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
806 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
807 } else if (pc->ctype == PC_LISTENING) {
808 pc->info.listening.cc = comm_client_new();
809 trym_if(pc->info.listening.cc == NULL, "client creation failed");
811 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
812 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
815 return (pkgmgr_client *) pc;
823 API int pkgmgr_client_free(pkgmgr_client *pc)
826 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
827 retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
829 if (mpc->ctype == PC_REQUEST) {
832 for (tmp = mpc->info.request.rhead; tmp;) {
838 ret = comm_client_free(mpc->info.request.cc);
839 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
840 } else if (mpc->ctype == PC_LISTENING) {
842 listen_cb_info *prev;
843 for (tmp = mpc->info.listening.lhead; tmp;) {
849 ret = comm_client_free(mpc->info.listening.cc);
850 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
851 } else if (mpc->ctype == PC_BROADCAST) {
854 ERR("Invalid client type\n");
855 return PKGMGR_R_EINVAL;
867 return PKGMGR_R_ERROR;
870 static char *__get_type_from_path(const char *pkg_path)
873 char mimetype[255] = { '\0', };
874 char extlist[256] = { '\0', };
877 ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
879 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
883 ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
885 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
889 if (strlen(extlist) == 0)
892 if (strchr(extlist, ','))
893 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
895 pkg_type = strchr(extlist, '.') + 1;
896 return strdup(pkg_type);
899 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
900 const char *descriptor_path, const char *pkg_path,
901 const char *optional_file, pkgmgr_mode mode,
902 pkgmgr_handler event_cb, void *data, uid_t uid)
905 int ret = PKGMGR_R_ECOMM;
906 char *req_key = NULL;
908 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
911 if (pc == NULL || pkg_path == NULL) {
912 ERR("invalid parameter");
913 return PKGMGR_R_EINVAL;
916 if (mpc->ctype != PC_REQUEST) {
917 ERR("mpc->ctype is not PC_REQUEST");
918 return PKGMGR_R_EINVAL;
921 if (access(pkg_path, F_OK) != 0) {
922 ERR("failed to access: %s", pkg_path);
923 return PKGMGR_R_EINVAL;
926 /* TODO: check pkg's type on server-side */
927 if (pkg_type == NULL)
928 pkgtype = __get_type_from_path(pkg_path);
930 pkgtype = strdup(pkg_type);
932 result = comm_client_request(mpc->info.request.cc, "install",
933 g_variant_new("(ss)", pkgtype, pkg_path));
936 return PKGMGR_R_ECOMM;
937 g_variant_get(result, "(i&s)", &ret, &req_key);
938 if (req_key == NULL) {
939 g_variant_unref(result);
940 return PKGMGR_R_ECOMM;
942 if (ret != PKGMGR_R_OK) {
943 g_variant_unref(result);
947 req_id = _get_request_id();
948 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
950 g_variant_unref(result);
955 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
956 const char *descriptor_path, const char *pkg_path,
957 const char *optional_file, pkgmgr_mode mode,
958 pkgmgr_handler event_cb, void *data)
960 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
961 pkg_path, optional_file, mode, event_cb,data,
965 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
966 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
967 pkgmgr_handler event_cb, void *data)
969 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_file,
970 mode, event_cb, data,GLOBAL_USER);
973 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type,
974 const char *pkgid, const char *optional_file, pkgmgr_mode mode,
975 pkgmgr_handler event_cb, void *data, uid_t uid)
978 int ret = PKGMGR_R_ECOMM;
979 char *req_key = NULL;
981 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
983 pkgmgrinfo_pkginfo_h handle;
985 if (pc == NULL || pkgid == NULL) {
986 ERR("invalid parameter");
987 return PKGMGR_R_EINVAL;
990 if (mpc->ctype != PC_REQUEST) {
991 ERR("mpc->ctype is not PC_REQUEST");
992 return PKGMGR_R_EINVAL;
995 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
997 return PKGMGR_R_EINVAL;
999 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1001 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1002 return PKGMGR_R_ERROR;
1005 result = comm_client_request(mpc->info.request.cc, "reinstall",
1006 g_variant_new("(ss)", pkgtype, pkgid));
1007 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1009 return PKGMGR_R_ECOMM;
1010 g_variant_get(result, "(i&s)", &ret, &req_key);
1011 if (req_key == NULL) {
1012 g_variant_unref(result);
1013 return PKGMGR_R_ECOMM;
1015 if (ret != PKGMGR_R_OK) {
1016 g_variant_unref(result);
1020 req_id = _get_request_id();
1021 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1023 g_variant_unref(result);
1028 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1029 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1032 return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,
1036 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1037 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1038 void *data, uid_t uid)
1041 int ret = PKGMGR_R_ECOMM;
1042 char *req_key = NULL;
1044 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1046 pkgmgrinfo_pkginfo_h handle;
1048 if (pc == NULL || pkgid == NULL) {
1049 ERR("invalid parameter");
1050 return PKGMGR_R_EINVAL;
1053 if (mpc->ctype != PC_REQUEST) {
1054 ERR("mpc->ctype is not PC_REQUEST");
1055 return PKGMGR_R_EINVAL;
1058 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1060 return PKGMGR_R_EINVAL;
1062 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1064 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1065 return PKGMGR_R_ERROR;
1068 /* TODO: check removable ? */
1070 result = comm_client_request(mpc->info.request.cc, "uninstall",
1071 g_variant_new("(ss)", pkgtype, pkgid));
1072 if (result == NULL) {
1073 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1074 return PKGMGR_R_ECOMM;
1076 g_variant_get(result, "(i&s)", &ret, &req_key);
1077 if (req_key == NULL) {
1078 g_variant_unref(result);
1079 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1080 return PKGMGR_R_ECOMM;
1082 if (ret != PKGMGR_R_OK) {
1083 g_variant_unref(result);
1084 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1088 req_id = _get_request_id();
1089 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1091 g_variant_unref(result);
1092 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1097 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1098 const char *pkgid, pkgmgr_move_type move_type, pkgmgr_mode mode)
1100 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, mode,
1103 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1104 const char *pkgid, pkgmgr_move_type move_type,
1105 pkgmgr_mode mode, uid_t uid)
1108 int ret = PKGMGR_R_ECOMM;
1109 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1111 if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
1112 ERR("invalid parameter");
1113 return PKGMGR_R_EINVAL;
1116 if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1117 return PKGMGR_R_EINVAL;
1119 if (mpc->ctype != PC_REQUEST) {
1120 ERR("mpc->ctype is not PC_REQUEST");
1121 return PKGMGR_R_EINVAL;
1124 result = comm_client_request(mpc->info.request.cc, "move",
1125 g_variant_new("(ss)", pkg_type, pkgid));
1127 return PKGMGR_R_ECOMM;
1128 g_variant_get(result, "(i)", &ret);
1129 g_variant_unref(result);
1134 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1135 const char *pkgid, uid_t uid)
1138 int ret = PKGMGR_R_ECOMM;
1139 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1141 if (pc == NULL || pkgid == NULL) {
1142 ERR("invalid parameter");
1143 return PKGMGR_R_EINVAL;
1146 result = comm_client_request(mpc->info.request.cc, "enable_pkg",
1147 g_variant_new("(s)", pkgid));
1149 return PKGMGR_R_ECOMM;
1150 g_variant_get(result, "(i)", &ret);
1151 g_variant_unref(result);
1156 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1159 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, GLOBAL_USER);
1162 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1163 const char *pkgid, uid_t uid)
1166 int ret = PKGMGR_R_ECOMM;
1167 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1169 if (pc == NULL || pkgid == NULL) {
1170 ERR("invalid parameter");
1171 return PKGMGR_R_EINVAL;
1174 result = comm_client_request(mpc->info.request.cc, "disable_pkg",
1175 g_variant_new("(s)", pkgid));
1177 return PKGMGR_R_ECOMM;
1178 g_variant_get(result, "(i)", &ret);
1179 g_variant_unref(result);
1184 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1187 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, GLOBAL_USER);
1190 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1194 int ret = PKGMGR_R_ECOMM;
1195 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1197 if (pc == NULL || appid == NULL) {
1198 ERR("invalid parameter");
1199 return PKGMGR_R_EINVAL;
1202 result = comm_client_request(mpc->info.request.cc, "enable_app",
1203 g_variant_new("(s)", appid));
1205 return PKGMGR_R_ECOMM;
1206 g_variant_get(result, "(i)", &ret);
1207 g_variant_unref(result);
1212 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid)
1214 return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1217 /* TODO: deprecate? */
1218 API int pkgmgr_client_usr_activate_appv(pkgmgr_client *pc, const char *appid,
1219 char *const argv[], uid_t uid)
1221 return pkgmgr_client_usr_activate_app(pc, appid, uid);
1224 API int pkgmgr_client_activate_appv(pkgmgr_client *pc, const char *appid,
1227 return pkgmgr_client_usr_activate_app(pc, appid, GLOBAL_USER);
1230 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1234 int ret = PKGMGR_R_ECOMM;
1235 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1237 if (pc == NULL || appid == NULL) {
1238 ERR("invalid parameter");
1239 return PKGMGR_R_EINVAL;
1242 result = comm_client_request(mpc->info.request.cc, "disable_app",
1243 g_variant_new("(s)", appid));
1245 return PKGMGR_R_ECOMM;
1246 g_variant_get(result, "(i)", &ret);
1247 g_variant_unref(result);
1252 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid)
1254 return pkgmgr_client_usr_deactivate_app(pc, appid, GLOBAL_USER);
1257 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1258 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1262 int ret = PKGMGR_R_ECOMM;
1263 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1265 if (pc == NULL || pkg_type == NULL || appid == NULL) {
1266 ERR("invalid parameter");
1267 return PKGMGR_R_EINVAL;
1270 if (mpc->ctype != PC_REQUEST) {
1271 ERR("mpc->ctype is not PC_REQUEST");
1272 return PKGMGR_R_EINVAL;
1275 result = comm_client_request(mpc->info.request.cc, "cleardata",
1276 g_variant_new("(ss)", pkg_type, appid));
1278 return PKGMGR_R_ECOMM;
1280 g_variant_get(result, "(i)", &ret);
1281 g_variant_unref(result);
1286 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1287 const char *appid, pkgmgr_mode mode)
1289 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1293 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1297 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1298 retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
1299 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1301 /* free listening head */
1302 listen_cb_info *tmp = NULL;
1303 listen_cb_info *prev = NULL;
1304 for (tmp = mpc->info.listening.lhead; tmp;) {
1310 /* free dbus connection */
1311 ret = comm_client_free(mpc->info.listening.cc);
1312 retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1314 /* Manage pc for seperated event */
1315 mpc->ctype = PC_LISTENING;
1316 mpc->status_type = status_type;
1318 mpc->info.listening.cc = comm_client_new();
1319 retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
1321 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
1322 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
1323 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
1326 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
1327 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
1328 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
1331 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
1332 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
1333 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
1336 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
1337 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
1338 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
1341 if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
1342 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
1343 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
1349 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1353 /* Check for NULL value of pc */
1354 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1355 pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1357 /* 0. check input */
1358 retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
1359 retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
1362 req_id = _get_request_id();
1364 /* 2. add callback info to pkgmgr_client */
1365 __add_stat_cbinfo(mpc, req_id, event_cb, data);
1369 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1370 const char *pkgid, const char *key,
1373 /* client cannot broadcast signal */
1377 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
1378 pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1379 const char *custom_info, pkgmgr_handler event_cb, void *data)
1381 return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, GLOBAL_USER, custom_info, event_cb, data);
1384 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
1385 pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
1386 const char *custom_info, pkgmgr_handler event_cb, void *data)
1390 /* Check for NULL value of service type */
1391 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1392 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1394 switch (service_type) {
1395 case PM_REQUEST_CSC:
1396 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
1397 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "optional_file over PKG_STRING_LEN_MAX");
1398 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
1400 ret = __csc_process(custom_info, (char *)data);
1402 ERR("__csc_process fail \n");
1408 case PM_REQUEST_MOVE:
1409 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1410 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1411 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1413 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1416 case PM_REQUEST_GET_SIZE:
1417 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1418 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1419 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1421 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1424 case PM_REQUEST_KILL_APP:
1425 case PM_REQUEST_CHECK_APP:
1426 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1427 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1429 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1431 ERR("__check_app_process fail \n");
1438 ERR("Wrong Request\n");
1449 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1452 pkgmgr_client *pc = NULL;
1454 pc = pkgmgr_client_new(PC_REQUEST);
1455 retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
1457 ret = __request_size_info(pc, uid);
1459 ERR("__request_size_info fail \n");
1462 pkgmgr_client_free(pc);
1466 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
1468 return pkgmgr_client_usr_request_size_info(GLOBAL_USER);
1471 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1474 int ret = PKGMGR_R_ECOMM;
1475 pkgmgr_client_t *pc;
1477 if (pkgid == NULL) {
1478 ERR("invalid parameter");
1479 return PKGMGR_R_EINVAL;
1482 pc = pkgmgr_client_new(PC_REQUEST);
1484 ERR("out of memory");
1485 return PKGMGR_R_ESYSTEM;
1488 result = comm_client_request(pc->info.request.cc, "clearcache",
1489 g_variant_new("(s)", pkgid));
1491 return PKGMGR_R_ECOMM;
1492 g_variant_get(result, "(i)", &ret);
1493 g_variant_unref(result);
1498 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1500 return pkgmgr_client_usr_clear_cache_dir(pkgid, GLOBAL_USER);
1503 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1505 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1508 API int pkgmgr_client_clear_all_cache_dir(void)
1510 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, GLOBAL_USER);
1513 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid,
1514 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1517 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1521 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid,
1522 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1523 void *data, uid_t uid)
1526 int ret = PKGMGR_R_ECOMM;
1527 char *req_key = NULL;
1529 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1531 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1532 ERR("invalid parameter");
1533 return PKGMGR_R_EINVAL;
1536 if (mpc->ctype != PC_REQUEST) {
1537 ERR("mpc->ctype is not PC_REQUEST");
1538 return PKGMGR_R_EINVAL;
1542 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1543 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1545 get_type = PM_GET_PKG_SIZE_INFO;
1546 result = comm_client_request(mpc->info.request.cc, "getsize",
1547 g_variant_new("(si)", pkgid, get_type));
1549 return PKGMGR_R_ECOMM;
1551 g_variant_get(result, "(i&s)", &ret, &req_key);
1552 if (req_key == NULL) {
1553 g_variant_unref(result);
1554 return PKGMGR_R_ECOMM;
1556 if (ret != PKGMGR_R_OK) {
1557 g_variant_unref(result);
1561 req_id = _get_request_id();
1562 __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1564 g_variant_unref(result);
1569 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1570 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1571 void *user_data, uid_t uid)
1574 int ret = PKGMGR_R_ECOMM;
1575 char *req_key = NULL;
1578 pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1580 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1581 ERR("invalid parameter");
1582 return PKGMGR_R_EINVAL;
1585 if (mpc->ctype != PC_REQUEST) {
1586 ERR("mpc->ctype is not PC_REQUEST");
1587 return PKGMGR_R_EINVAL;
1591 if (__change_op_cb_for_getsize(mpc) < 0) {
1592 ERR("__change_op_cb_for_getsize failed");
1593 return PKGMGR_R_ESYSTEM;
1596 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1597 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1599 get_type = PM_GET_PKG_SIZE_INFO;
1600 result = comm_client_request(mpc->info.request.cc, "getsize",
1601 g_variant_new("(si)", pkgid, get_type));
1603 return PKGMGR_R_ECOMM;
1605 g_variant_get(result, "(i&s)", &ret, &req_key);
1606 if (req_key == NULL) {
1607 g_variant_unref(result);
1608 return PKGMGR_R_ECOMM;
1610 if (ret != PKGMGR_R_OK) {
1611 g_variant_unref(result);
1615 req_id = _get_request_id();
1616 __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb,
1619 g_variant_unref(result);
1624 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)
1626 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, GLOBAL_USER);
1629 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)
1630 { // total package size info
1631 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
1634 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1636 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);