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_client_debug.h"
42 #include "pkgmgr_client_internal.h"
44 /* API export macro */
46 #define API __attribute__ ((visibility("default")))
49 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
51 #define BINSH_NAME "/bin/sh"
54 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
55 #define REGULAR_USER 5000
57 static inline uid_t _getuid(void)
61 if (uid < REGULAR_USER)
67 static int _get_request_id()
69 static int internal_req_id = 1;
71 return internal_req_id++;
74 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
75 pkgmgr_handler event_cb, void *data, const char *req_key)
77 struct cb_info *cb_info;
79 cb_info = calloc(1, sizeof(struct cb_info));
80 if (cb_info == NULL) {
84 cb_info->client = client;
85 cb_info->event_cb = event_cb;
87 cb_info->req_id = _get_request_id();
88 if (req_key != NULL) {
89 cb_info->req_key = strdup(req_key);
90 if (cb_info->req_key == NULL) {
100 static struct cb_info *__create_app_event_cb_info(
101 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
102 void *data, const char *req_key)
104 struct cb_info *cb_info;
106 cb_info = calloc(1, sizeof(struct cb_info));
107 if (cb_info == NULL) {
108 ERR("out of memory");
111 cb_info->client = client;
112 cb_info->app_event_cb = app_event_cb;
113 cb_info->data = data;
114 cb_info->req_id = _get_request_id();
115 if (req_key != NULL) {
116 cb_info->req_key = strdup(req_key);
117 if (cb_info->req_key == NULL) {
118 ERR("out of memory");
127 static struct cb_info *__create_size_info_cb_info(
128 struct pkgmgr_client_t *client,
129 pkgmgr_pkg_size_info_receive_cb size_info_cb,
130 void *data, const char *req_key)
132 struct cb_info *cb_info;
134 cb_info = calloc(1, sizeof(struct cb_info));
135 if (cb_info == NULL) {
136 ERR("out of memory");
139 cb_info->client = client;
140 cb_info->size_info_cb = size_info_cb;
141 cb_info->data = data;
142 cb_info->req_id = _get_request_id();
143 if (req_key != NULL) {
144 cb_info->req_key = strdup(req_key);
145 if (cb_info->req_key == NULL) {
146 ERR("out of memory");
155 static void __free_cb_info(struct cb_info *cb_info)
157 free(cb_info->req_key);
161 static int __sync_process(const char *req_key)
164 char info_file[PKG_STRING_LEN_MAX] = {'\0', };
168 char buf[PKG_STRING_LEN_MAX] = {0, };
170 snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
174 if (access(info_file, F_OK) == 0) {
175 fp = fopen(info_file, "r");
177 DBG("file is not generated yet.... wait\n");
178 usleep(100 * 1000); /* 100ms sleep*/
182 if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
183 ERR("failed to read info file");
189 DBG("info_file file is generated, result = %s. \n", buf);
194 DBG("file is not generated yet.... wait\n");
195 usleep(100 * 1000); /* 100ms sleep*/
197 if (check_cnt > 6000) { /* 60s * 10 time over*/
198 ERR("wait time over!!\n");
203 ret = remove(info_file);
205 ERR("file is can not remove[%s, %d]\n", info_file, ret);
210 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
211 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
215 int ret = PKGMGR_R_ECOMM;
216 char *req_key = NULL;
217 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
219 if (pc == NULL || pkgid == NULL) {
220 ERR("invalid parameter");
221 return PKGMGR_R_EINVAL;
224 if (client->pc_type != PC_REQUEST) {
225 ERR("client->pc_type is not PC_REQUEST");
226 return PKGMGR_R_EINVAL;
229 ret = pkgmgr_client_connection_send_request(client, "getsize",
230 g_variant_new("(usi)", uid, pkgid, get_type), &result);
231 if (ret != PKGMGR_R_OK) {
232 ERR("request failed: %d", ret);
236 g_variant_get(result, "(i&s)", &ret, &req_key);
237 if (req_key == NULL) {
238 g_variant_unref(result);
239 return PKGMGR_R_ECOMM;
241 if (ret != PKGMGR_R_OK) {
242 g_variant_unref(result);
246 ret = __sync_process(req_key);
248 ERR("get size failed, ret=%d\n", ret);
250 g_variant_unref(result);
255 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
256 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
257 pkgmgr_handler event_cb, void *data)
261 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
263 ERR("move request failed");
270 static int __check_app_process(pkgmgr_request_service_type service_type,
271 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
274 int ret = PKGMGR_R_ECOMM;
275 pkgmgrinfo_pkginfo_h handle;
277 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
279 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
281 if (uid != GLOBAL_USER)
282 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
284 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
285 retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
287 if (service_type == PM_REQUEST_KILL_APP)
288 ret = pkgmgr_client_connection_send_request(client, "kill",
289 g_variant_new("(us)", uid, pkgid), &result);
290 else if (service_type == PM_REQUEST_CHECK_APP)
291 ret = pkgmgr_client_connection_send_request(client, "check",
292 g_variant_new("(us)", uid, pkgid), &result);
293 if (ret != PKGMGR_R_OK) {
294 ERR("request failed: %d", ret);
298 g_variant_get(result, "(ii)", &ret, &pid);
299 g_variant_unref(result);
300 if (ret != PKGMGR_R_OK) {
301 ERR("request failed, ret=%d", ret);
307 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
313 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
316 int ret = PKGMGR_R_ECOMM;
317 // char *req_key = NULL;
318 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
321 ERR("invalid parameter");
322 return PKGMGR_R_EINVAL;
325 if (client->pc_type != PC_REQUEST) {
326 ERR("client->pc_type is not PC_REQUEST");
327 return PKGMGR_R_EINVAL;
330 ret = pkgmgr_client_connection_send_request(client, "getsize",
331 g_variant_new("(usi)", uid, "size_info",
332 PM_GET_SIZE_INFO), &result);
333 if (ret != PKGMGR_R_OK) {
334 ERR("request failed: %d", ret);
339 g_variant_get(result, "(i&s)", &ret, &req_key);
340 if (req_key == NULL) {
341 g_variant_unref(result);
342 return PKGMGR_R_ECOMM;
346 g_variant_unref(result);
351 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
353 struct pkgmgr_client_t *client;
355 if (pc_type == PC_BROADCAST) {
356 ERR("broadcast type is not supported");
360 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
361 ERR("invalid parameter");
365 client = calloc(1, sizeof(struct pkgmgr_client_t));
366 if (client == NULL) {
367 ERR("out of memory");
371 client->pc_type = pc_type;
372 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
374 if (pkgmgr_client_connection_connect(client))
377 return (pkgmgr_client *)client;
380 API int pkgmgr_client_free(pkgmgr_client *pc)
382 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
385 ERR("invalid argument");
386 return PKGMGR_R_EINVAL;
389 pkgmgr_client_remove_listen_status(client);
390 pkgmgr_client_connection_disconnect(client);
391 if (client->tep_path)
392 free(client->tep_path);
398 static char *__get_type_from_path(const char *pkg_path)
401 char mimetype[255] = { '\0', };
402 char extlist[256] = { '\0', };
405 ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
407 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
411 ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
413 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
417 if (strlen(extlist) == 0)
420 if (strchr(extlist, ','))
421 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
423 pkg_type = strchr(extlist, '.') + 1;
424 return strdup(pkg_type);
427 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
430 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
432 if (pc == NULL || tep_path == NULL) {
433 ERR("invalied parameter");
434 return PKGMGR_R_EINVAL;
437 if (client->tep_path)
438 free(client->tep_path);
440 client->tep_path = strdup(tep_path);
441 client->tep_move = tep_move;
446 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
447 const char *descriptor_path, const char *pkg_path,
448 const char *optional_data, pkgmgr_mode mode,
449 pkgmgr_handler event_cb, void *data, uid_t uid)
452 int ret = PKGMGR_R_ECOMM;
453 char *req_key = NULL;
454 GVariantBuilder *builder = NULL;
455 GVariant *args = NULL;
456 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
458 struct cb_info *cb_info;
460 if (pc == NULL || pkg_path == NULL) {
461 ERR("invalid parameter");
462 return PKGMGR_R_EINVAL;
465 if (client->pc_type != PC_REQUEST) {
466 ERR("client type is not PC_REQUEST");
467 return PKGMGR_R_EINVAL;
470 if (access(pkg_path, F_OK) != 0) {
471 ERR("failed to access: %s", pkg_path);
472 return PKGMGR_R_EINVAL;
475 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
476 ERR("failed to access: %s", client->tep_path);
477 return PKGMGR_R_EINVAL;
480 /* TODO: check pkg's type on server-side */
481 if (pkg_type == NULL)
482 pkgtype = __get_type_from_path(pkg_path);
484 pkgtype = strdup(pkg_type);
486 /* build arguments */
487 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
488 if (client->tep_path) {
489 g_variant_builder_add(builder, "s", "-e");
490 g_variant_builder_add(builder, "s", client->tep_path);
491 g_variant_builder_add(builder, "s", "-M");
492 /* TODO: revise tep_move */
493 g_variant_builder_add(builder, "s",
494 client->tep_move ? "tep_move" : "tep_copy");
497 args = g_variant_new("as", builder);
498 g_variant_builder_unref(builder);
500 ret = pkgmgr_client_connection_send_request(client, "install",
501 g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
503 if (ret != PKGMGR_R_OK) {
504 ERR("request failed: %d", ret);
508 g_variant_get(result, "(i&s)", &ret, &req_key);
509 if (req_key == NULL) {
510 g_variant_unref(result);
511 return PKGMGR_R_ECOMM;
513 if (ret != PKGMGR_R_OK) {
514 g_variant_unref(result);
518 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
519 if (cb_info == NULL) {
520 g_variant_unref(result);
521 return PKGMGR_R_ENOMEM;
523 g_variant_unref(result);
524 ret = pkgmgr_client_connection_set_callback(client, cb_info);
525 if (ret != PKGMGR_R_OK) {
526 __free_cb_info(cb_info);
529 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
531 return cb_info->req_id;
534 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
535 const char *descriptor_path, const char *pkg_path,
536 const char *optional_data, pkgmgr_mode mode,
537 pkgmgr_handler event_cb, void *data)
539 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
540 pkg_path, optional_data, mode, event_cb, data,
544 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
545 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
546 pkgmgr_handler event_cb, void *data)
548 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
549 mode, event_cb, data, _getuid());
552 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
553 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
554 pkgmgr_handler event_cb, void *data, uid_t uid)
557 int ret = PKGMGR_R_ECOMM;
558 char *req_key = NULL;
559 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
561 pkgmgrinfo_pkginfo_h handle;
562 struct cb_info *cb_info;
564 if (pc == NULL || pkgid == NULL) {
565 ERR("invalid parameter");
566 return PKGMGR_R_EINVAL;
569 if (client->pc_type != PC_REQUEST) {
570 ERR("client->pc_type is not PC_REQUEST");
571 return PKGMGR_R_EINVAL;
574 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
576 return PKGMGR_R_EINVAL;
578 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
580 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
581 return PKGMGR_R_ERROR;
584 ret = pkgmgr_client_connection_send_request(client, "reinstall",
585 g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
586 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
587 if (ret != PKGMGR_R_OK) {
588 ERR("request failed: %d", ret);
592 g_variant_get(result, "(i&s)", &ret, &req_key);
593 if (req_key == NULL) {
594 g_variant_unref(result);
595 return PKGMGR_R_ECOMM;
597 if (ret != PKGMGR_R_OK) {
598 g_variant_unref(result);
602 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
603 if (cb_info == NULL) {
604 g_variant_unref(result);
605 return PKGMGR_R_ENOMEM;
607 g_variant_unref(result);
608 ret = pkgmgr_client_connection_set_callback(client, cb_info);
609 if (ret != PKGMGR_R_OK) {
610 __free_cb_info(cb_info);
613 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
615 return cb_info->req_id;
618 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
619 const char *descriptor_path, const char *pkg_path,
620 const char *optional_data, pkgmgr_mode mode,
621 pkgmgr_handler event_cb, void *data, uid_t uid)
624 int ret = PKGMGR_R_ECOMM;
625 char *req_key = NULL;
626 GVariantBuilder *builder = NULL;
627 GVariant *args = NULL;
628 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
630 struct cb_info *cb_info;
632 if (pc == NULL || pkg_path == NULL) {
633 ERR("invalid parameter");
634 return PKGMGR_R_EINVAL;
637 if (client->pc_type != PC_REQUEST) {
638 ERR("client->pc_type is not PC_REQUEST");
639 return PKGMGR_R_EINVAL;
642 if (access(pkg_path, F_OK) != 0) {
643 ERR("failed to access: %s", pkg_path);
644 return PKGMGR_R_EINVAL;
647 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
648 ERR("failed to access: %s", client->tep_path);
649 return PKGMGR_R_EINVAL;
652 /* TODO: check pkg's type on server-side */
653 if (pkg_type == NULL)
654 pkgtype = __get_type_from_path(pkg_path);
656 pkgtype = strdup(pkg_type);
658 /* build arguments */
659 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
660 if (client->tep_path) {
661 g_variant_builder_add(builder, "s", "-e");
662 g_variant_builder_add(builder, "s", client->tep_path);
663 g_variant_builder_add(builder, "s", "-M");
664 /* TODO: revise tep_move */
665 g_variant_builder_add(builder, "s",
666 client->tep_move ? "tep_move" : "tep_copy");
669 args = g_variant_new("as", builder);
670 g_variant_builder_unref(builder);
672 ret = pkgmgr_client_connection_send_request(client, "mount_install",
673 g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
675 if (ret != PKGMGR_R_OK) {
676 ERR("request failed: %d", ret);
680 g_variant_get(result, "(i&s)", &ret, &req_key);
681 if (req_key == NULL) {
682 g_variant_unref(result);
683 return PKGMGR_R_ECOMM;
685 if (ret != PKGMGR_R_OK) {
686 g_variant_unref(result);
690 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
691 if (cb_info == NULL) {
692 g_variant_unref(result);
693 return PKGMGR_R_ENOMEM;
695 g_variant_unref(result);
696 ret = pkgmgr_client_connection_set_callback(client, cb_info);
697 if (ret != PKGMGR_R_OK) {
698 __free_cb_info(cb_info);
701 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
703 return cb_info->req_id;
706 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
707 const char *descriptor_path, const char *pkg_path,
708 const char *optional_data, pkgmgr_mode mode,
709 pkgmgr_handler event_cb, void *data)
711 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
712 pkg_path, optional_data, mode, event_cb, data,
716 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
717 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
720 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
724 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
725 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
726 void *data, uid_t uid)
729 int ret = PKGMGR_R_ECOMM;
730 char *req_key = NULL;
731 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
733 pkgmgrinfo_pkginfo_h handle;
734 struct cb_info *cb_info;
736 if (pc == NULL || pkgid == NULL) {
737 ERR("invalid parameter");
738 return PKGMGR_R_EINVAL;
741 if (client->pc_type != PC_REQUEST) {
742 ERR("client->pc_type is not PC_REQUEST");
743 return PKGMGR_R_EINVAL;
746 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
748 return PKGMGR_R_EINVAL;
750 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
752 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
753 return PKGMGR_R_ERROR;
756 ret = pkgmgr_client_connection_send_request(client, "uninstall",
757 g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
758 if (ret != PKGMGR_R_OK) {
759 ERR("request failed: %d", ret);
760 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
764 g_variant_get(result, "(i&s)", &ret, &req_key);
765 if (req_key == NULL) {
766 g_variant_unref(result);
767 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
768 return PKGMGR_R_ECOMM;
770 if (ret != PKGMGR_R_OK) {
771 g_variant_unref(result);
772 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
776 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
777 if (cb_info == NULL) {
778 g_variant_unref(result);
779 return PKGMGR_R_ENOMEM;
781 g_variant_unref(result);
782 ret = pkgmgr_client_connection_set_callback(client, cb_info);
783 if (ret != PKGMGR_R_OK) {
784 __free_cb_info(cb_info);
787 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
789 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
791 return cb_info->req_id;
794 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
795 const char *pkgid, pkgmgr_move_type move_type,
796 pkgmgr_handler event_cb, void *data)
798 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
799 event_cb, data, _getuid());
801 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
802 const char *pkgid, pkgmgr_move_type move_type,
803 pkgmgr_handler event_cb, void *data, uid_t uid)
806 int ret = PKGMGR_R_ECOMM;
807 char *req_key = NULL;
808 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
809 struct cb_info *cb_info;
811 if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
812 ERR("invalid parameter");
813 return PKGMGR_R_EINVAL;
816 if ((move_type < PM_MOVE_TO_INTERNAL) ||
817 (move_type > PM_MOVE_TO_SDCARD))
818 return PKGMGR_R_EINVAL;
820 if (client->pc_type != PC_REQUEST) {
821 ERR("client->pc_type is not PC_REQUEST");
822 return PKGMGR_R_EINVAL;
825 ret = pkgmgr_client_connection_send_request(client, "move",
826 g_variant_new("(ussi)", uid, pkg_type, pkgid,
827 move_type), &result);
828 if (ret != PKGMGR_R_OK) {
829 ERR("request failed: %d", ret);
833 g_variant_get(result, "(i&s)", &ret, &req_key);
834 if (req_key == NULL) {
835 g_variant_unref(result);
836 return PKGMGR_R_ECOMM;
838 if (ret != PKGMGR_R_OK) {
839 g_variant_unref(result);
843 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
844 if (cb_info == NULL) {
845 g_variant_unref(result);
846 return PKGMGR_R_ERROR;
848 g_variant_unref(result);
849 ret = pkgmgr_client_connection_set_callback(client, cb_info);
850 if (ret != PKGMGR_R_OK) {
851 __free_cb_info(cb_info);
854 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
856 return cb_info->req_id;
859 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
860 const char *pkgid, uid_t uid)
863 int ret = PKGMGR_R_ECOMM;
864 GVariantBuilder *builder;
865 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
867 if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
868 ERR("invalid parameter");
869 return PKGMGR_R_EINVAL;
872 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
873 g_variant_builder_add(builder, "s", pkgid);
875 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
876 g_variant_new("(usas)", uid, pkg_type, builder),
878 g_variant_builder_unref(builder);
879 if (ret != PKGMGR_R_OK) {
880 ERR("request failed: %d", ret);
884 g_variant_get(result, "(is)", &ret, NULL);
885 g_variant_unref(result);
890 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
893 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
896 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
897 const char *pkg_type, const char **pkgids, int n_pkgs,
898 pkgmgr_handler event_cb, void *data, uid_t uid)
901 GVariantBuilder *builder;
902 int ret = PKGMGR_R_ECOMM;
903 char *req_key = NULL;
904 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
905 struct cb_info *cb_info;
908 if (pc == NULL || pkgids == NULL || pkg_type == NULL || n_pkgs < 1) {
909 ERR("invalid parameter");
910 return PKGMGR_R_EINVAL;
913 if (client->pc_type != PC_REQUEST) {
914 ERR("client type is not PC_REQUEST");
915 return PKGMGR_R_EINVAL;
918 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
919 for (i = 0; i < n_pkgs; i++)
920 g_variant_builder_add(builder, "s", pkgids[i]);
922 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
923 g_variant_new("(usas)", uid, pkg_type, builder),
925 g_variant_builder_unref(builder);
926 if (ret != PKGMGR_R_OK) {
927 ERR("request failed: %d", ret);
931 g_variant_get(result, "(i&s)", &ret, &req_key);
932 if (req_key == NULL) {
933 g_variant_unref(result);
934 return PKGMGR_R_ECOMM;
936 if (ret != PKGMGR_R_OK) {
937 g_variant_unref(result);
941 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
942 if (cb_info == NULL) {
943 g_variant_unref(result);
944 return PKGMGR_R_ERROR;
946 g_variant_unref(result);
947 ret = pkgmgr_client_connection_set_callback(client, cb_info);
948 if (ret != PKGMGR_R_OK) {
949 __free_cb_info(cb_info);
952 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
954 return cb_info->req_id;
957 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
958 const char *pkg_type, const char **pkgids, int n_pkgs,
959 pkgmgr_handler event_cb, void *data)
961 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
962 pkgids, n_pkgs, event_cb, data, _getuid());
965 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
966 const char *pkgid, uid_t uid)
969 GVariantBuilder *builder;
970 int ret = PKGMGR_R_ECOMM;
971 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
973 if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
974 ERR("invalid parameter");
975 return PKGMGR_R_EINVAL;
978 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
979 g_variant_builder_add(builder, "s", pkgid);
981 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
982 g_variant_new("(usas)", uid, pkg_type, builder),
984 g_variant_builder_unref(builder);
985 if (ret != PKGMGR_R_OK) {
986 ERR("request failed: %d", ret);
990 g_variant_get(result, "(is)", &ret, NULL);
991 g_variant_unref(result);
996 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
999 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1002 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1003 const char *pkg_type, const char **pkgids, int n_pkgs,
1004 pkgmgr_handler event_cb, void *data, uid_t uid)
1007 GVariantBuilder *builder;
1008 int ret = PKGMGR_R_ECOMM;
1009 char *req_key = NULL;
1010 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1011 struct cb_info *cb_info;
1014 if (pc == NULL || pkgids == NULL || pkg_type == NULL || n_pkgs < 1) {
1015 ERR("invalid parameter");
1016 return PKGMGR_R_EINVAL;
1019 if (client->pc_type != PC_REQUEST) {
1020 ERR("client type is not PC_REQUEST");
1021 return PKGMGR_R_EINVAL;
1024 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1025 for (i = 0; i < n_pkgs; i++)
1026 g_variant_builder_add(builder, "s", pkgids[i]);
1028 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1029 g_variant_new("(usas)", uid, pkg_type, builder), &result);
1030 g_variant_builder_unref(builder);
1031 if (ret != PKGMGR_R_OK) {
1032 ERR("request failed: %d", ret);
1036 g_variant_get(result, "(i&s)", &ret, &req_key);
1037 if (req_key == NULL) {
1038 g_variant_unref(result);
1039 return PKGMGR_R_ECOMM;
1041 if (ret != PKGMGR_R_OK) {
1042 g_variant_unref(result);
1046 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1047 if (cb_info == NULL) {
1048 g_variant_unref(result);
1049 return PKGMGR_R_ERROR;
1051 g_variant_unref(result);
1052 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1053 if (ret != PKGMGR_R_OK) {
1054 __free_cb_info(cb_info);
1057 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1059 return cb_info->req_id;
1062 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1063 const char *pkg_type, const char **pkgids, int n_pkgs,
1064 pkgmgr_handler event_cb, void *data)
1066 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1067 pkgids, n_pkgs, event_cb, data, _getuid());
1070 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1071 pkgmgr_app_handler app_event_cb, uid_t uid)
1074 int ret = PKGMGR_R_ECOMM;
1075 char *req_key = NULL;
1076 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1077 struct cb_info *cb_info;
1079 if (pc == NULL || appid == NULL) {
1080 ERR("invalid parameter");
1081 return PKGMGR_R_EINVAL;
1084 ret = pkgmgr_client_connection_send_request(client, "enable_app",
1085 g_variant_new("(us)", uid, appid), &result);
1086 if (ret != PKGMGR_R_OK) {
1087 ERR("request failed: %d", ret);
1091 g_variant_get(result, "(i&s)", &ret, &req_key);
1092 if (req_key == NULL) {
1093 g_variant_unref(result);
1094 return PKGMGR_R_ECOMM;
1096 if (ret != PKGMGR_R_OK) {
1097 g_variant_unref(result);
1101 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1103 if (cb_info == NULL) {
1104 g_variant_unref(result);
1105 return PKGMGR_R_ENOMEM;
1107 g_variant_unref(result);
1108 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1109 if (ret != PKGMGR_R_OK) {
1110 __free_cb_info(cb_info);
1113 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1118 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1119 pkgmgr_app_handler app_event_cb)
1121 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1125 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1126 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1129 int ret = PKGMGR_R_ECOMM;
1130 char *req_key = NULL;
1131 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1132 struct cb_info *cb_info;
1134 if (pc == NULL || appid == NULL) {
1135 ERR("invalid parameter");
1136 return PKGMGR_R_EINVAL;
1139 ret = pkgmgr_client_connection_send_request(client,
1140 "enable_global_app_for_uid",
1141 g_variant_new("(us)", uid, appid), &result);
1142 if (ret != PKGMGR_R_OK) {
1143 ERR("request failed: %d", ret);
1147 g_variant_get(result, "(i&s)", &ret, &req_key);
1148 if (req_key == NULL) {
1149 g_variant_unref(result);
1150 return PKGMGR_R_ECOMM;
1152 if (ret != PKGMGR_R_OK) {
1153 g_variant_unref(result);
1157 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1159 if (cb_info == NULL) {
1160 g_variant_unref(result);
1161 return PKGMGR_R_ENOMEM;
1163 g_variant_unref(result);
1164 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1165 if (ret != PKGMGR_R_OK) {
1166 __free_cb_info(cb_info);
1169 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1174 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1175 pkgmgr_app_handler app_event_cb, uid_t uid)
1178 int ret = PKGMGR_R_ECOMM;
1179 char *req_key = NULL;
1180 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1181 struct cb_info *cb_info;
1183 if (pc == NULL || appid == NULL) {
1184 ERR("invalid parameter");
1185 return PKGMGR_R_EINVAL;
1188 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1189 g_variant_new("(us)", uid, appid), &result);
1190 if (ret != PKGMGR_R_OK) {
1191 ERR("request failed: %d", ret);
1195 g_variant_get(result, "(i&s)", &ret, &req_key);
1196 if (req_key == NULL) {
1197 g_variant_unref(result);
1198 return PKGMGR_R_ECOMM;
1200 if (ret != PKGMGR_R_OK) {
1201 g_variant_unref(result);
1205 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1207 if (cb_info == NULL) {
1208 g_variant_unref(result);
1209 return PKGMGR_R_ENOMEM;
1211 g_variant_unref(result);
1212 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1213 if (ret != PKGMGR_R_OK) {
1214 __free_cb_info(cb_info);
1217 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1222 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1223 pkgmgr_app_handler app_event_cb)
1225 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1229 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1230 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1233 int ret = PKGMGR_R_ECOMM;
1234 char *req_key = NULL;
1235 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1236 struct cb_info *cb_info;
1238 if (pc == NULL || appid == NULL) {
1239 ERR("invalid parameter");
1240 return PKGMGR_R_EINVAL;
1243 ret = pkgmgr_client_connection_send_request(client,
1244 "disable_global_app_for_uid",
1245 g_variant_new("(us)", uid, appid), &result);
1246 if (ret != PKGMGR_R_OK) {
1247 ERR("request failed: %d", ret);
1251 g_variant_get(result, "(i&s)", &ret, &req_key);
1252 if (req_key == NULL) {
1253 g_variant_unref(result);
1254 return PKGMGR_R_ECOMM;
1256 if (ret != PKGMGR_R_OK) {
1257 g_variant_unref(result);
1261 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1263 if (cb_info == NULL) {
1264 g_variant_unref(result);
1265 return PKGMGR_R_ENOMEM;
1267 g_variant_unref(result);
1268 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1269 if (ret != PKGMGR_R_OK) {
1270 __free_cb_info(cb_info);
1273 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1278 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1279 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1284 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1286 if (pc == NULL || pkg_type == NULL || appid == NULL) {
1287 ERR("invalid parameter");
1288 return PKGMGR_R_EINVAL;
1291 if (client->pc_type != PC_REQUEST) {
1292 ERR("client->pc_type is not PC_REQUEST");
1293 return PKGMGR_R_EINVAL;
1296 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1297 g_variant_new("(uss)", uid, pkg_type, appid), &result);
1298 if (ret == PKGMGR_R_OK) {
1299 ERR("request failed: %d", ret);
1303 g_variant_get(result, "(i)", &ret);
1304 g_variant_unref(result);
1309 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1310 const char *appid, pkgmgr_mode mode)
1312 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1316 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1318 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1321 ERR("invalid parameter");
1322 return PKGMGR_R_EINVAL;
1325 client->status_type = status_type;
1330 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1334 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1335 struct cb_info *cb_info;
1337 if (pc == NULL || event_cb == NULL) {
1338 ERR("invalid parameter");
1339 return PKGMGR_R_EINVAL;
1342 if (client->pc_type != PC_LISTENING) {
1343 ERR("client->pc_type is not PC_LISTENING");
1344 return PKGMGR_R_EINVAL;
1347 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1348 if (cb_info == NULL)
1349 return PKGMGR_R_ENOMEM;
1350 cb_info->status_type = client->status_type;
1351 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1352 if (ret != PKGMGR_R_OK) {
1353 __free_cb_info(cb_info);
1356 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1358 return cb_info->req_id;
1361 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1362 pkgmgr_app_handler app_event_cb, void *data)
1365 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1366 struct cb_info *cb_info;
1368 if (pc == NULL || app_event_cb == NULL) {
1369 ERR("invalid parameter");
1370 return PKGMGR_R_EINVAL;
1373 if (client->pc_type != PC_LISTENING) {
1374 ERR("client->pc_type is not PC_LISTENING");
1375 return PKGMGR_R_EINVAL;
1378 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1379 if (cb_info == NULL)
1380 return PKGMGR_R_ENOMEM;
1381 cb_info->status_type = client->status_type;
1382 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1383 if (ret != PKGMGR_R_OK) {
1384 __free_cb_info(cb_info);
1387 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1389 return cb_info->req_id;
1392 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1394 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1397 struct cb_info *cb_info;
1400 ERR("invalid parameter");
1401 return PKGMGR_R_EINVAL;
1404 /* unset all callback */
1405 tmp = client->cb_info_list;
1406 while (tmp != NULL) {
1408 cb_info = (struct cb_info *)tmp->data;
1409 pkgmgr_client_connection_unset_callback(pc, cb_info);
1410 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1412 __free_cb_info(cb_info);
1419 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1420 const char *pkgid, const char *key, const char *val)
1422 /* client cannot broadcast signal */
1426 /* TODO: deprecate(or remove) */
1427 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1428 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1429 const char *pkgid, const char *custom_info,
1430 pkgmgr_handler event_cb, void *data)
1432 return pkgmgr_client_usr_request_service(service_type, service_mode,
1433 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1437 API int pkgmgr_client_usr_request_service(
1438 pkgmgr_request_service_type service_type, int service_mode,
1439 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1440 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1445 /* Check for NULL value of service type */
1446 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1447 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1449 switch (service_type) {
1450 case PM_REQUEST_MOVE:
1451 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1452 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1453 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1455 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1458 case PM_REQUEST_GET_SIZE:
1459 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1460 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1461 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1463 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1466 case PM_REQUEST_KILL_APP:
1467 case PM_REQUEST_CHECK_APP:
1468 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1469 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1471 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1473 ERR("__check_app_process fail \n");
1480 ERR("Wrong Request\n");
1491 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1494 struct pkgmgr_client *client;
1496 client = pkgmgr_client_new(PC_REQUEST);
1497 if (client == NULL) {
1498 ERR("out of memory");
1499 return PKGMGR_R_ENOMEM;
1502 ret = __request_size_info(client, uid);
1504 ERR("__request_size_info fail");
1506 pkgmgr_client_free(client);
1510 API int pkgmgr_client_request_size_info(void)
1512 /* get all package size (data, total) */
1513 return pkgmgr_client_usr_request_size_info(_getuid());
1516 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1520 struct pkgmgr_client_t *client;
1522 if (pkgid == NULL) {
1523 ERR("invalid parameter");
1524 return PKGMGR_R_EINVAL;
1527 client = pkgmgr_client_new(PC_REQUEST);
1528 if (client == NULL) {
1529 ERR("out of memory");
1530 return PKGMGR_R_ENOMEM;
1533 ret = pkgmgr_client_connection_send_request(client, "clearcache",
1534 g_variant_new("(us)", uid, pkgid), &result);
1535 if (ret != PKGMGR_R_OK) {
1536 ERR("request failed: %d", ret);
1540 g_variant_get(result, "(i)", &ret);
1541 g_variant_unref(result);
1546 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1548 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1551 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1553 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1556 API int pkgmgr_client_clear_all_cache_dir(void)
1558 return pkgmgr_client_usr_clear_cache_dir(
1559 PKG_CLEAR_ALL_CACHE, getuid());
1562 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1563 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1566 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1570 /* TODO: deprecate(or remove) */
1571 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1572 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1573 void *data, uid_t uid)
1576 int ret = PKGMGR_R_ECOMM;
1577 char *req_key = NULL;
1578 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1579 struct cb_info *cb_info;
1581 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1582 ERR("invalid parameter");
1583 return PKGMGR_R_EINVAL;
1586 if (client->pc_type != PC_REQUEST) {
1587 ERR("client->pc_type is not PC_REQUEST");
1588 return PKGMGR_R_EINVAL;
1592 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1593 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1595 get_type = PM_GET_PKG_SIZE_INFO;
1597 ret = pkgmgr_client_connection_send_request(client, "getsize",
1598 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1599 if (ret != PKGMGR_R_OK) {
1600 ERR("request failed: %d", ret);
1604 g_variant_get(result, "(i&s)", &ret, &req_key);
1605 if (req_key == NULL) {
1606 g_variant_unref(result);
1607 return PKGMGR_R_ECOMM;
1609 if (ret != PKGMGR_R_OK) {
1610 g_variant_unref(result);
1614 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1615 if (cb_info == NULL) {
1616 g_variant_unref(result);
1617 return PKGMGR_R_ENOMEM;
1619 g_variant_unref(result);
1620 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1621 if (ret != PKGMGR_R_OK) {
1622 __free_cb_info(cb_info);
1625 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1630 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1631 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1632 void *user_data, uid_t uid)
1635 int ret = PKGMGR_R_ECOMM;
1636 char *req_key = NULL;
1638 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1639 struct cb_info *cb_info;
1641 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1642 ERR("invalid parameter");
1643 return PKGMGR_R_EINVAL;
1646 if (client->pc_type != PC_REQUEST) {
1647 ERR("client->pc_type is not PC_REQUEST");
1648 return PKGMGR_R_EINVAL;
1651 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1652 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1654 get_type = PM_GET_PKG_SIZE_INFO;
1656 ret = pkgmgr_client_connection_send_request(client, "getsize",
1657 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1658 if (ret != PKGMGR_R_OK) {
1659 ERR("request failed: %d", ret);
1663 g_variant_get(result, "(i&s)", &ret, &req_key);
1664 if (req_key == NULL) {
1665 g_variant_unref(result);
1666 return PKGMGR_R_ECOMM;
1668 if (ret != PKGMGR_R_OK) {
1669 g_variant_unref(result);
1673 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1675 if (cb_info == NULL) {
1676 g_variant_unref(result);
1677 return PKGMGR_R_ENOMEM;
1679 g_variant_unref(result);
1680 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1681 if (ret != PKGMGR_R_OK) {
1682 __free_cb_info(cb_info);
1685 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1690 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1691 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1694 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1695 user_data, _getuid());
1698 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1699 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1700 void *user_data, uid_t uid)
1701 { /* total package size info */
1702 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1703 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1707 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1708 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1710 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1711 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1712 user_data, _getuid());
1715 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1716 const char *resp_data, char **req_data, char **license_url)
1722 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1724 if (pc == NULL || resp_data == NULL || req_data == NULL ||
1725 license_url == NULL) {
1726 ERR("invalid parameter");
1727 return PKGMGR_R_EINVAL;
1730 if (client->pc_type != PC_REQUEST) {
1731 ERR("client->pc_type is not PC_REQUEST");
1732 return PKGMGR_R_EINVAL;
1735 ret = pkgmgr_client_connection_send_request(client,
1736 "generate_license_request",
1737 g_variant_new("(s)", resp_data), &result);
1738 if (ret != PKGMGR_R_OK) {
1739 ERR("request failed: %d", ret);
1743 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1744 if (ret != PKGMGR_R_OK) {
1745 ERR("generate_license_request failed: %d", ret);
1746 g_variant_unref(result);
1750 *req_data = strdup(data);
1751 *license_url = strdup(url);
1753 g_variant_unref(result);
1758 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1762 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1764 if (pc == NULL || resp_data == NULL) {
1765 ERR("invalid parameter");
1766 return PKGMGR_R_EINVAL;
1769 if (client->pc_type != PC_REQUEST) {
1770 ERR("client->pc_type is not PC_REQUEST");
1771 return PKGMGR_R_EINVAL;
1774 ret = pkgmgr_client_connection_send_request(client, "register_license",
1775 g_variant_new("(s)", resp_data), &result);
1776 if (ret != PKGMGR_R_OK) {
1777 ERR("request failed: %d", ret);
1781 g_variant_get(result, "(i)", &ret);
1782 g_variant_unref(result);
1783 if (ret != PKGMGR_R_OK)
1784 ERR("register license failed: %d", ret);
1789 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1790 const char *drm_file_path, const char *decrypted_file_path)
1794 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1796 if (pc == NULL || drm_file_path == NULL ||
1797 decrypted_file_path == NULL) {
1798 ERR("invalid parameter");
1799 return PKGMGR_R_EINVAL;
1802 if (client->pc_type != PC_REQUEST) {
1803 ERR("client->pc_type is not PC_REQUEST");
1804 return PKGMGR_R_EINVAL;
1807 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1808 g_variant_new("(ss)", drm_file_path,
1809 decrypted_file_path), &result);
1810 if (ret != PKGMGR_R_OK) {
1811 ERR("request failed: %d", ret);
1815 g_variant_get(result, "(i)", &ret);
1816 g_variant_unref(result);
1817 if (ret != PKGMGR_R_OK)
1818 ERR("decrypt_package failed: %d", ret);
1823 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1825 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1828 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1829 const char *appid, uid_t uid)
1833 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1835 if (pc == NULL || appid == NULL) {
1836 ERR("Invalid parameter");
1837 return PKGMGR_R_EINVAL;
1840 ret = pkgmgr_client_connection_send_request(client,
1841 "enable_app_splash_screen",
1842 g_variant_new("(us)", uid, appid), &result);
1843 if (ret != PKGMGR_R_OK) {
1844 ERR("request failed: %d", ret);
1848 g_variant_get(result, "(i)", &ret);
1849 g_variant_unref(result);
1850 if (ret != PKGMGR_R_OK)
1851 ERR("enable splash screen failed: %d", ret);
1856 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1859 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1863 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1864 const char *appid, uid_t uid)
1868 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1870 if (pc == NULL || appid == NULL) {
1871 ERR("Invalid parameter");
1872 return PKGMGR_R_EINVAL;
1875 ret = pkgmgr_client_connection_send_request(client,
1876 "disable_app_splash_screen",
1877 g_variant_new("(us)", uid, appid), &result);
1878 if (ret != PKGMGR_R_OK) {
1879 ERR("request failed: %d", ret);
1883 g_variant_get(result, "(i)", &ret);
1884 g_variant_unref(result);
1885 if (ret != PKGMGR_R_OK)
1886 ERR("disable splash screen failed: %d", ret);
1891 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1892 int mode, uid_t uid)
1895 int ret = PKGMGR_R_ECOMM;
1896 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1898 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1899 ERR("invalid parameter");
1900 return PKGMGR_R_EINVAL;
1903 ret = pkgmgr_client_connection_send_request(client,
1904 "set_restriction_mode",
1905 g_variant_new("(usi)", uid, pkgid, mode), &result);
1906 if (ret != PKGMGR_R_OK) {
1907 ERR("request failed: %d", ret);
1911 g_variant_get(result, "(i)", &ret);
1912 g_variant_unref(result);
1917 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1918 const char *pkgid, int mode, uid_t uid)
1920 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1923 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1924 const char *pkgid, int mode)
1926 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1930 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1931 int mode, uid_t uid)
1934 int ret = PKGMGR_R_ECOMM;
1935 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1937 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1938 ERR("invalid parameter");
1939 return PKGMGR_R_EINVAL;
1942 ret = pkgmgr_client_connection_send_request(client,
1943 "unset_restriction_mode",
1944 g_variant_new("(usi)", uid, pkgid, mode), &result);
1945 if (ret != PKGMGR_R_OK) {
1946 ERR("request failed: %d", ret);
1950 g_variant_get(result, "(i)", &ret);
1951 g_variant_unref(result);
1957 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1958 const char *pkgid, int mode, uid_t uid)
1960 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1963 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1964 const char *pkgid, int mode)
1966 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1970 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1971 int *mode, uid_t uid)
1974 int ret = PKGMGR_R_ECOMM;
1976 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1978 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1979 ERR("invalid parameter");
1980 return PKGMGR_R_EINVAL;
1983 ret = pkgmgr_client_connection_send_request(client,
1984 "get_restriction_mode",
1985 g_variant_new("(us)", uid, pkgid), &result);
1986 if (ret != PKGMGR_R_OK) {
1987 ERR("request failed: %d", ret);
1991 g_variant_get(result, "(ii)", &m, &ret);
1992 g_variant_unref(result);
1993 if (ret != PKGMGR_R_OK)
2001 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2002 const char *pkgid, int *mode, uid_t uid)
2004 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2007 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2008 const char *pkgid, int *mode)
2010 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2014 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2018 int ret = PKGMGR_R_ECOMM;
2019 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2022 ERR("invalid parameter");
2023 return PKGMGR_R_EINVAL;
2026 ret = pkgmgr_client_connection_send_request(client,
2027 "set_restriction_mode",
2028 g_variant_new("(usi)", uid, "", mode), &result);
2029 if (ret != PKGMGR_R_OK) {
2030 ERR("request failed: %d", ret);
2034 g_variant_get(result, "(i)", &ret);
2035 g_variant_unref(result);
2040 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2042 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2045 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2049 int ret = PKGMGR_R_ECOMM;
2050 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2053 ERR("invalid parameter");
2054 return PKGMGR_R_EINVAL;
2057 ret = pkgmgr_client_connection_send_request(client,
2058 "unset_restriction_mode",
2059 g_variant_new("(usi)", uid, "", mode), &result);
2060 if (ret != PKGMGR_R_OK) {
2061 ERR("request failed: %d", ret);
2065 g_variant_get(result, "(i)", &ret);
2066 g_variant_unref(result);
2071 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2073 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2076 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2077 int *mode, uid_t uid)
2080 int ret = PKGMGR_R_ECOMM;
2082 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2085 ERR("invalid parameter");
2086 return PKGMGR_R_EINVAL;
2089 ret = pkgmgr_client_connection_send_request(client,
2090 "get_restriction_mode",
2091 g_variant_new("(us)", uid, ""), &result);
2092 if (ret != PKGMGR_R_OK) {
2093 ERR("request failed: %d", ret);
2097 g_variant_get(result, "(ii)", &m, &ret);
2098 g_variant_unref(result);
2099 if (ret != PKGMGR_R_OK)
2107 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2109 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2112 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2115 pkg_plugin_set *plugin_set;
2116 package_manager_pkg_detail_info_t *info;
2119 if (pkg_path == NULL) {
2120 ERR("invalid parameter");
2124 pkg_type = __get_type_from_path(pkg_path);
2125 if (pkg_type == NULL) {
2126 ERR("cannot get pkg type");
2130 plugin_set = _package_manager_load_library(pkg_type);
2131 if (plugin_set == NULL) {
2132 ERR("failed to load library for %s", pkg_type);
2137 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2139 ERR("out of memory");
2144 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2146 ERR("get_pkg_detail_info_from_package failed");
2154 return (pkgmgr_info *)info;
2157 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2159 package_manager_pkg_detail_info_t *pkg_info =
2160 (package_manager_pkg_detail_info_t *)info;
2163 ERR("invalid parameter");
2164 return PKGMGR_R_EINVAL;
2167 free(pkg_info->icon_buf);