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, "(i)", &ret);
299 g_variant_unref(result);
300 if (ret != PKGMGR_R_OK) {
301 ERR("request failed, ret=%d", ret);
306 pid = __sync_process(pkgid);
309 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
315 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
318 int ret = PKGMGR_R_ECOMM;
319 // char *req_key = NULL;
320 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
323 ERR("invalid parameter");
324 return PKGMGR_R_EINVAL;
327 if (client->pc_type != PC_REQUEST) {
328 ERR("client->pc_type is not PC_REQUEST");
329 return PKGMGR_R_EINVAL;
332 ret = pkgmgr_client_connection_send_request(client, "getsize",
333 g_variant_new("(usi)", uid, "size_info",
334 PM_GET_SIZE_INFO), &result);
335 if (ret != PKGMGR_R_OK) {
336 ERR("request failed: %d", ret);
341 g_variant_get(result, "(i&s)", &ret, &req_key);
342 if (req_key == NULL) {
343 g_variant_unref(result);
344 return PKGMGR_R_ECOMM;
348 g_variant_unref(result);
353 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
355 struct pkgmgr_client_t *client;
357 if (pc_type == PC_BROADCAST) {
358 ERR("broadcast type is not supported");
362 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
363 ERR("invalid parameter");
367 client = calloc(1, sizeof(struct pkgmgr_client_t));
368 if (client == NULL) {
369 ERR("out of memory");
373 client->pc_type = pc_type;
374 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
376 if (pkgmgr_client_connection_connect(client))
379 return (pkgmgr_client *)client;
382 API int pkgmgr_client_free(pkgmgr_client *pc)
384 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
387 ERR("invalid argument");
388 return PKGMGR_R_EINVAL;
391 pkgmgr_client_remove_listen_status(client);
392 pkgmgr_client_connection_disconnect(client);
393 if (client->tep_path)
394 free(client->tep_path);
400 static char *__get_type_from_path(const char *pkg_path)
403 char mimetype[255] = { '\0', };
404 char extlist[256] = { '\0', };
407 ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
409 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
413 ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
415 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
419 if (strlen(extlist) == 0)
422 if (strchr(extlist, ','))
423 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
425 pkg_type = strchr(extlist, '.') + 1;
426 return strdup(pkg_type);
429 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
432 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
434 if (pc == NULL || tep_path == NULL) {
435 ERR("invalied parameter");
436 return PKGMGR_R_EINVAL;
439 if (client->tep_path)
440 free(client->tep_path);
442 client->tep_path = strdup(tep_path);
443 client->tep_move = tep_move;
448 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
449 const char *descriptor_path, const char *pkg_path,
450 const char *optional_data, pkgmgr_mode mode,
451 pkgmgr_handler event_cb, void *data, uid_t uid)
454 int ret = PKGMGR_R_ECOMM;
455 char *req_key = NULL;
456 GVariantBuilder *builder = NULL;
457 GVariant *args = NULL;
458 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
460 struct cb_info *cb_info;
462 if (pc == NULL || pkg_path == NULL) {
463 ERR("invalid parameter");
464 return PKGMGR_R_EINVAL;
467 if (client->pc_type != PC_REQUEST) {
468 ERR("client type is not PC_REQUEST");
469 return PKGMGR_R_EINVAL;
472 if (access(pkg_path, F_OK) != 0) {
473 ERR("failed to access: %s", pkg_path);
474 return PKGMGR_R_EINVAL;
477 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
478 ERR("failed to access: %s", client->tep_path);
479 return PKGMGR_R_EINVAL;
482 /* TODO: check pkg's type on server-side */
483 if (pkg_type == NULL)
484 pkgtype = __get_type_from_path(pkg_path);
486 pkgtype = strdup(pkg_type);
488 /* build arguments */
489 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
490 if (client->tep_path) {
491 g_variant_builder_add(builder, "s", "-e");
492 g_variant_builder_add(builder, "s", client->tep_path);
493 g_variant_builder_add(builder, "s", "-M");
494 /* TODO: revise tep_move */
495 g_variant_builder_add(builder, "s",
496 client->tep_move ? "tep_move" : "tep_copy");
499 args = g_variant_new("as", builder);
500 g_variant_builder_unref(builder);
502 ret = pkgmgr_client_connection_send_request(client, "install",
503 g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
505 if (ret != PKGMGR_R_OK) {
506 ERR("request failed: %d", ret);
510 g_variant_get(result, "(i&s)", &ret, &req_key);
511 if (req_key == NULL) {
512 g_variant_unref(result);
513 return PKGMGR_R_ECOMM;
515 if (ret != PKGMGR_R_OK) {
516 g_variant_unref(result);
520 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
521 if (cb_info == NULL) {
522 g_variant_unref(result);
523 return PKGMGR_R_ENOMEM;
525 g_variant_unref(result);
526 ret = pkgmgr_client_connection_set_callback(client, cb_info);
527 if (ret != PKGMGR_R_OK) {
528 __free_cb_info(cb_info);
531 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
533 return cb_info->req_id;
536 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
537 const char *descriptor_path, const char *pkg_path,
538 const char *optional_data, pkgmgr_mode mode,
539 pkgmgr_handler event_cb, void *data)
541 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
542 pkg_path, optional_data, mode, event_cb, data,
546 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
547 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
548 pkgmgr_handler event_cb, void *data)
550 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
551 mode, event_cb, data, _getuid());
554 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
555 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
556 pkgmgr_handler event_cb, void *data, uid_t uid)
559 int ret = PKGMGR_R_ECOMM;
560 char *req_key = NULL;
561 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
563 pkgmgrinfo_pkginfo_h handle;
564 struct cb_info *cb_info;
566 if (pc == NULL || pkgid == NULL) {
567 ERR("invalid parameter");
568 return PKGMGR_R_EINVAL;
571 if (client->pc_type != PC_REQUEST) {
572 ERR("client->pc_type is not PC_REQUEST");
573 return PKGMGR_R_EINVAL;
576 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
578 return PKGMGR_R_EINVAL;
580 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
582 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
583 return PKGMGR_R_ERROR;
586 ret = pkgmgr_client_connection_send_request(client, "reinstall",
587 g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
588 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
589 if (ret != PKGMGR_R_OK) {
590 ERR("request failed: %d", ret);
594 g_variant_get(result, "(i&s)", &ret, &req_key);
595 if (req_key == NULL) {
596 g_variant_unref(result);
597 return PKGMGR_R_ECOMM;
599 if (ret != PKGMGR_R_OK) {
600 g_variant_unref(result);
604 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
605 if (cb_info == NULL) {
606 g_variant_unref(result);
607 return PKGMGR_R_ENOMEM;
609 g_variant_unref(result);
610 ret = pkgmgr_client_connection_set_callback(client, cb_info);
611 if (ret != PKGMGR_R_OK) {
612 __free_cb_info(cb_info);
615 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
617 return cb_info->req_id;
620 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
621 const char *descriptor_path, const char *pkg_path,
622 const char *optional_data, pkgmgr_mode mode,
623 pkgmgr_handler event_cb, void *data, uid_t uid)
626 int ret = PKGMGR_R_ECOMM;
627 char *req_key = NULL;
628 GVariantBuilder *builder = NULL;
629 GVariant *args = NULL;
630 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
632 struct cb_info *cb_info;
634 if (pc == NULL || pkg_path == NULL) {
635 ERR("invalid parameter");
636 return PKGMGR_R_EINVAL;
639 if (client->pc_type != PC_REQUEST) {
640 ERR("client->pc_type is not PC_REQUEST");
641 return PKGMGR_R_EINVAL;
644 if (access(pkg_path, F_OK) != 0) {
645 ERR("failed to access: %s", pkg_path);
646 return PKGMGR_R_EINVAL;
649 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
650 ERR("failed to access: %s", client->tep_path);
651 return PKGMGR_R_EINVAL;
654 /* TODO: check pkg's type on server-side */
655 if (pkg_type == NULL)
656 pkgtype = __get_type_from_path(pkg_path);
658 pkgtype = strdup(pkg_type);
660 /* build arguments */
661 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
662 if (client->tep_path) {
663 g_variant_builder_add(builder, "s", "-e");
664 g_variant_builder_add(builder, "s", client->tep_path);
665 g_variant_builder_add(builder, "s", "-M");
666 /* TODO: revise tep_move */
667 g_variant_builder_add(builder, "s",
668 client->tep_move ? "tep_move" : "tep_copy");
671 args = g_variant_new("as", builder);
672 g_variant_builder_unref(builder);
674 ret = pkgmgr_client_connection_send_request(client, "mount_install",
675 g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
677 if (ret != PKGMGR_R_OK) {
678 ERR("request failed: %d", ret);
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;
687 if (ret != PKGMGR_R_OK) {
688 g_variant_unref(result);
692 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
693 if (cb_info == NULL) {
694 g_variant_unref(result);
695 return PKGMGR_R_ENOMEM;
697 g_variant_unref(result);
698 ret = pkgmgr_client_connection_set_callback(client, cb_info);
699 if (ret != PKGMGR_R_OK) {
700 __free_cb_info(cb_info);
703 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
705 return cb_info->req_id;
708 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
709 const char *descriptor_path, const char *pkg_path,
710 const char *optional_data, pkgmgr_mode mode,
711 pkgmgr_handler event_cb, void *data)
713 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
714 pkg_path, optional_data, mode, event_cb, data,
718 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
719 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
722 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
726 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
727 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
728 void *data, uid_t uid)
731 int ret = PKGMGR_R_ECOMM;
732 char *req_key = NULL;
733 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
735 pkgmgrinfo_pkginfo_h handle;
736 struct cb_info *cb_info;
738 if (pc == NULL || pkgid == NULL) {
739 ERR("invalid parameter");
740 return PKGMGR_R_EINVAL;
743 if (client->pc_type != PC_REQUEST) {
744 ERR("client->pc_type is not PC_REQUEST");
745 return PKGMGR_R_EINVAL;
748 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
750 return PKGMGR_R_EINVAL;
752 ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
754 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
755 return PKGMGR_R_ERROR;
758 ret = pkgmgr_client_connection_send_request(client, "uninstall",
759 g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
760 if (ret != PKGMGR_R_OK) {
761 ERR("request failed: %d", ret);
762 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
766 g_variant_get(result, "(i&s)", &ret, &req_key);
767 if (req_key == NULL) {
768 g_variant_unref(result);
769 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
770 return PKGMGR_R_ECOMM;
772 if (ret != PKGMGR_R_OK) {
773 g_variant_unref(result);
774 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
778 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
779 if (cb_info == NULL) {
780 g_variant_unref(result);
781 return PKGMGR_R_ENOMEM;
783 g_variant_unref(result);
784 ret = pkgmgr_client_connection_set_callback(client, cb_info);
785 if (ret != PKGMGR_R_OK) {
786 __free_cb_info(cb_info);
789 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
791 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
793 return cb_info->req_id;
796 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
797 const char *pkgid, pkgmgr_move_type move_type,
798 pkgmgr_handler event_cb, void *data)
800 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
801 event_cb, data, _getuid());
803 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
804 const char *pkgid, pkgmgr_move_type move_type,
805 pkgmgr_handler event_cb, void *data, uid_t uid)
808 int ret = PKGMGR_R_ECOMM;
809 char *req_key = NULL;
810 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
811 struct cb_info *cb_info;
813 if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
814 ERR("invalid parameter");
815 return PKGMGR_R_EINVAL;
818 if ((move_type < PM_MOVE_TO_INTERNAL) ||
819 (move_type > PM_MOVE_TO_SDCARD))
820 return PKGMGR_R_EINVAL;
822 if (client->pc_type != PC_REQUEST) {
823 ERR("client->pc_type is not PC_REQUEST");
824 return PKGMGR_R_EINVAL;
827 ret = pkgmgr_client_connection_send_request(client, "move",
828 g_variant_new("(ussi)", uid, pkg_type, pkgid,
829 move_type), &result);
830 if (ret != PKGMGR_R_OK) {
831 ERR("request failed: %d", ret);
835 g_variant_get(result, "(i&s)", &ret, &req_key);
836 if (req_key == NULL) {
837 g_variant_unref(result);
838 return PKGMGR_R_ECOMM;
840 if (ret != PKGMGR_R_OK) {
841 g_variant_unref(result);
845 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
846 if (cb_info == NULL) {
847 g_variant_unref(result);
848 return PKGMGR_R_ERROR;
850 g_variant_unref(result);
851 ret = pkgmgr_client_connection_set_callback(client, cb_info);
852 if (ret != PKGMGR_R_OK) {
853 __free_cb_info(cb_info);
856 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
858 return cb_info->req_id;
861 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
862 const char *pkgid, uid_t uid)
865 int ret = PKGMGR_R_ECOMM;
866 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
868 if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
869 ERR("invalid parameter");
870 return PKGMGR_R_EINVAL;
873 ret = pkgmgr_client_connection_send_request(client, "enable_pkg",
874 g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
875 if (ret != PKGMGR_R_OK) {
876 ERR("request failed: %d", ret);
880 g_variant_get(result, "(i)", &ret);
881 g_variant_unref(result);
886 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
889 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
892 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
893 const char *pkgid, uid_t uid)
896 int ret = PKGMGR_R_ECOMM;
897 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
899 if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
900 ERR("invalid parameter");
901 return PKGMGR_R_EINVAL;
904 ret = pkgmgr_client_connection_send_request(client, "disable_pkg",
905 g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
906 if (ret != PKGMGR_R_OK) {
907 ERR("request failed: %d", ret);
911 g_variant_get(result, "(i)", &ret);
912 g_variant_unref(result);
917 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
920 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
923 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
924 pkgmgr_app_handler app_event_cb, uid_t uid)
927 int ret = PKGMGR_R_ECOMM;
928 char *req_key = NULL;
929 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
930 struct cb_info *cb_info;
932 if (pc == NULL || appid == NULL) {
933 ERR("invalid parameter");
934 return PKGMGR_R_EINVAL;
937 ret = pkgmgr_client_connection_send_request(client, "enable_app",
938 g_variant_new("(us)", uid, appid), &result);
939 if (ret != PKGMGR_R_OK) {
940 ERR("request failed: %d", ret);
944 g_variant_get(result, "(i&s)", &ret, &req_key);
945 if (req_key == NULL) {
946 g_variant_unref(result);
947 return PKGMGR_R_ECOMM;
949 if (ret != PKGMGR_R_OK) {
950 g_variant_unref(result);
954 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
956 if (cb_info == NULL) {
957 g_variant_unref(result);
958 return PKGMGR_R_ENOMEM;
960 g_variant_unref(result);
961 ret = pkgmgr_client_connection_set_callback(client, cb_info);
962 if (ret != PKGMGR_R_OK) {
963 __free_cb_info(cb_info);
966 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
971 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
972 pkgmgr_app_handler app_event_cb)
974 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
978 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
979 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
982 int ret = PKGMGR_R_ECOMM;
983 char *req_key = NULL;
984 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
985 struct cb_info *cb_info;
987 if (pc == NULL || appid == NULL) {
988 ERR("invalid parameter");
989 return PKGMGR_R_EINVAL;
992 ret = pkgmgr_client_connection_send_request(client,
993 "enable_global_app_for_uid",
994 g_variant_new("(us)", uid, appid), &result);
995 if (ret != PKGMGR_R_OK) {
996 ERR("request failed: %d", ret);
1000 g_variant_get(result, "(i&s)", &ret, &req_key);
1001 if (req_key == NULL) {
1002 g_variant_unref(result);
1003 return PKGMGR_R_ECOMM;
1005 if (ret != PKGMGR_R_OK) {
1006 g_variant_unref(result);
1010 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1012 if (cb_info == NULL) {
1013 g_variant_unref(result);
1014 return PKGMGR_R_ENOMEM;
1016 g_variant_unref(result);
1017 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1018 if (ret != PKGMGR_R_OK) {
1019 __free_cb_info(cb_info);
1022 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1027 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1028 pkgmgr_app_handler app_event_cb, uid_t uid)
1031 int ret = PKGMGR_R_ECOMM;
1032 char *req_key = NULL;
1033 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1034 struct cb_info *cb_info;
1036 if (pc == NULL || appid == NULL) {
1037 ERR("invalid parameter");
1038 return PKGMGR_R_EINVAL;
1041 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1042 g_variant_new("(us)", uid, appid), &result);
1043 if (ret != PKGMGR_R_OK) {
1044 ERR("request failed: %d", ret);
1048 g_variant_get(result, "(i&s)", &ret, &req_key);
1049 if (req_key == NULL) {
1050 g_variant_unref(result);
1051 return PKGMGR_R_ECOMM;
1053 if (ret != PKGMGR_R_OK) {
1054 g_variant_unref(result);
1058 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1060 if (cb_info == NULL) {
1061 g_variant_unref(result);
1062 return PKGMGR_R_ENOMEM;
1064 g_variant_unref(result);
1065 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1066 if (ret != PKGMGR_R_OK) {
1067 __free_cb_info(cb_info);
1070 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1075 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1076 pkgmgr_app_handler app_event_cb)
1078 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1082 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1083 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1086 int ret = PKGMGR_R_ECOMM;
1087 char *req_key = NULL;
1088 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1089 struct cb_info *cb_info;
1091 if (pc == NULL || appid == NULL) {
1092 ERR("invalid parameter");
1093 return PKGMGR_R_EINVAL;
1096 ret = pkgmgr_client_connection_send_request(client,
1097 "disable_global_app_for_uid",
1098 g_variant_new("(us)", uid, appid), &result);
1099 if (ret != PKGMGR_R_OK) {
1100 ERR("request failed: %d", ret);
1104 g_variant_get(result, "(i&s)", &ret, &req_key);
1105 if (req_key == NULL) {
1106 g_variant_unref(result);
1107 return PKGMGR_R_ECOMM;
1109 if (ret != PKGMGR_R_OK) {
1110 g_variant_unref(result);
1114 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1116 if (cb_info == NULL) {
1117 g_variant_unref(result);
1118 return PKGMGR_R_ENOMEM;
1120 g_variant_unref(result);
1121 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1122 if (ret != PKGMGR_R_OK) {
1123 __free_cb_info(cb_info);
1126 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1131 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1132 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1137 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1139 if (pc == NULL || pkg_type == NULL || appid == NULL) {
1140 ERR("invalid parameter");
1141 return PKGMGR_R_EINVAL;
1144 if (client->pc_type != PC_REQUEST) {
1145 ERR("client->pc_type is not PC_REQUEST");
1146 return PKGMGR_R_EINVAL;
1149 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1150 g_variant_new("(uss)", uid, pkg_type, appid), &result);
1151 if (ret == PKGMGR_R_OK) {
1152 ERR("request failed: %d", ret);
1156 g_variant_get(result, "(i)", &ret);
1157 g_variant_unref(result);
1162 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1163 const char *appid, pkgmgr_mode mode)
1165 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1169 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1171 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1174 ERR("invalid parameter");
1175 return PKGMGR_R_EINVAL;
1178 client->status_type = status_type;
1183 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1187 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1188 struct cb_info *cb_info;
1190 if (pc == NULL || event_cb == NULL) {
1191 ERR("invalid parameter");
1192 return PKGMGR_R_EINVAL;
1195 if (client->pc_type != PC_LISTENING) {
1196 ERR("client->pc_type is not PC_LISTENING");
1197 return PKGMGR_R_EINVAL;
1200 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1201 if (cb_info == NULL)
1202 return PKGMGR_R_ENOMEM;
1203 cb_info->status_type = client->status_type;
1204 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1205 if (ret != PKGMGR_R_OK) {
1206 __free_cb_info(cb_info);
1209 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1211 return cb_info->req_id;
1214 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1215 pkgmgr_app_handler app_event_cb, void *data)
1218 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1219 struct cb_info *cb_info;
1221 if (pc == NULL || app_event_cb == NULL) {
1222 ERR("invalid parameter");
1223 return PKGMGR_R_EINVAL;
1226 if (client->pc_type != PC_LISTENING) {
1227 ERR("client->pc_type is not PC_LISTENING");
1228 return PKGMGR_R_EINVAL;
1231 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1232 if (cb_info == NULL)
1233 return PKGMGR_R_ENOMEM;
1234 cb_info->status_type = client->status_type;
1235 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1236 if (ret != PKGMGR_R_OK) {
1237 __free_cb_info(cb_info);
1240 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1242 return cb_info->req_id;
1245 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1247 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1250 struct cb_info *cb_info;
1253 ERR("invalid parameter");
1254 return PKGMGR_R_EINVAL;
1257 /* unset all callback */
1258 tmp = client->cb_info_list;
1259 while (tmp != NULL) {
1261 cb_info = (struct cb_info *)tmp->data;
1262 pkgmgr_client_connection_unset_callback(pc, cb_info);
1263 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1271 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1272 const char *pkgid, const char *key, const char *val)
1274 /* client cannot broadcast signal */
1278 /* TODO: deprecate(or remove) */
1279 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1280 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1281 const char *pkgid, const char *custom_info,
1282 pkgmgr_handler event_cb, void *data)
1284 return pkgmgr_client_usr_request_service(service_type, service_mode,
1285 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1289 API int pkgmgr_client_usr_request_service(
1290 pkgmgr_request_service_type service_type, int service_mode,
1291 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1292 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1297 /* Check for NULL value of service type */
1298 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1299 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1301 switch (service_type) {
1302 case PM_REQUEST_MOVE:
1303 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1304 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1305 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1307 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1310 case PM_REQUEST_GET_SIZE:
1311 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1312 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1313 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1315 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1318 case PM_REQUEST_KILL_APP:
1319 case PM_REQUEST_CHECK_APP:
1320 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1321 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1323 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1325 ERR("__check_app_process fail \n");
1332 ERR("Wrong Request\n");
1343 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1346 struct pkgmgr_client *client;
1348 client = pkgmgr_client_new(PC_REQUEST);
1349 if (client == NULL) {
1350 ERR("out of memory");
1351 return PKGMGR_R_ENOMEM;
1354 ret = __request_size_info(client, uid);
1356 ERR("__request_size_info fail");
1358 pkgmgr_client_free(client);
1362 API int pkgmgr_client_request_size_info(void)
1364 /* get all package size (data, total) */
1365 return pkgmgr_client_usr_request_size_info(_getuid());
1368 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1372 struct pkgmgr_client_t *client;
1374 if (pkgid == NULL) {
1375 ERR("invalid parameter");
1376 return PKGMGR_R_EINVAL;
1379 client = pkgmgr_client_new(PC_REQUEST);
1380 if (client == NULL) {
1381 ERR("out of memory");
1382 return PKGMGR_R_ENOMEM;
1385 ret = pkgmgr_client_connection_send_request(client, "clearcache",
1386 g_variant_new("(us)", uid, pkgid), &result);
1387 if (ret != PKGMGR_R_OK) {
1388 ERR("request failed: %d", ret);
1392 g_variant_get(result, "(i)", &ret);
1393 g_variant_unref(result);
1398 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1400 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1403 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1405 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1408 API int pkgmgr_client_clear_all_cache_dir(void)
1410 return pkgmgr_client_usr_clear_cache_dir(
1411 PKG_CLEAR_ALL_CACHE, getuid());
1414 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1415 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1418 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1422 /* TODO: deprecate(or remove) */
1423 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1424 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1425 void *data, uid_t uid)
1428 int ret = PKGMGR_R_ECOMM;
1429 char *req_key = NULL;
1430 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1431 struct cb_info *cb_info;
1433 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1434 ERR("invalid parameter");
1435 return PKGMGR_R_EINVAL;
1438 if (client->pc_type != PC_REQUEST) {
1439 ERR("client->pc_type is not PC_REQUEST");
1440 return PKGMGR_R_EINVAL;
1444 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1445 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1447 get_type = PM_GET_PKG_SIZE_INFO;
1449 ret = pkgmgr_client_connection_send_request(client, "getsize",
1450 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1451 if (ret != PKGMGR_R_OK) {
1452 ERR("request failed: %d", ret);
1456 g_variant_get(result, "(i&s)", &ret, &req_key);
1457 if (req_key == NULL) {
1458 g_variant_unref(result);
1459 return PKGMGR_R_ECOMM;
1461 if (ret != PKGMGR_R_OK) {
1462 g_variant_unref(result);
1466 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1467 if (cb_info == NULL) {
1468 g_variant_unref(result);
1469 return PKGMGR_R_ENOMEM;
1471 g_variant_unref(result);
1472 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1473 if (ret != PKGMGR_R_OK) {
1474 __free_cb_info(cb_info);
1477 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1482 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1483 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1484 void *user_data, uid_t uid)
1487 int ret = PKGMGR_R_ECOMM;
1488 char *req_key = NULL;
1490 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1491 struct cb_info *cb_info;
1493 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1494 ERR("invalid parameter");
1495 return PKGMGR_R_EINVAL;
1498 if (client->pc_type != PC_REQUEST) {
1499 ERR("client->pc_type is not PC_REQUEST");
1500 return PKGMGR_R_EINVAL;
1503 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1504 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1506 get_type = PM_GET_PKG_SIZE_INFO;
1508 ret = pkgmgr_client_connection_send_request(client, "getsize",
1509 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1510 if (ret != PKGMGR_R_OK) {
1511 ERR("request failed: %d", ret);
1515 g_variant_get(result, "(i&s)", &ret, &req_key);
1516 if (req_key == NULL) {
1517 g_variant_unref(result);
1518 return PKGMGR_R_ECOMM;
1520 if (ret != PKGMGR_R_OK) {
1521 g_variant_unref(result);
1525 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1527 if (cb_info == NULL) {
1528 g_variant_unref(result);
1529 return PKGMGR_R_ENOMEM;
1531 g_variant_unref(result);
1532 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1533 if (ret != PKGMGR_R_OK) {
1534 __free_cb_info(cb_info);
1537 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1542 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1543 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1546 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1547 user_data, _getuid());
1550 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1551 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1552 void *user_data, uid_t uid)
1553 { /* total package size info */
1554 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1555 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1559 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1560 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1562 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1563 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1564 user_data, _getuid());
1567 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1568 const char *resp_data, char **req_data, char **license_url)
1574 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1576 if (pc == NULL || resp_data == NULL || req_data == NULL ||
1577 license_url == NULL) {
1578 ERR("invalid parameter");
1579 return PKGMGR_R_EINVAL;
1582 if (client->pc_type != PC_REQUEST) {
1583 ERR("client->pc_type is not PC_REQUEST");
1584 return PKGMGR_R_EINVAL;
1587 ret = pkgmgr_client_connection_send_request(client,
1588 "generate_license_request",
1589 g_variant_new("(s)", resp_data), &result);
1590 if (ret != PKGMGR_R_OK) {
1591 ERR("request failed: %d", ret);
1595 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1596 if (ret != PKGMGR_R_OK) {
1597 ERR("generate_license_request failed: %d", ret);
1598 g_variant_unref(result);
1602 *req_data = strdup(data);
1603 *license_url = strdup(url);
1605 g_variant_unref(result);
1610 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1614 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1616 if (pc == NULL || resp_data == NULL) {
1617 ERR("invalid parameter");
1618 return PKGMGR_R_EINVAL;
1621 if (client->pc_type != PC_REQUEST) {
1622 ERR("client->pc_type is not PC_REQUEST");
1623 return PKGMGR_R_EINVAL;
1626 ret = pkgmgr_client_connection_send_request(client, "register_license",
1627 g_variant_new("(s)", resp_data), &result);
1628 if (ret != PKGMGR_R_OK) {
1629 ERR("request failed: %d", ret);
1633 g_variant_get(result, "(i)", &ret);
1634 g_variant_unref(result);
1635 if (ret != PKGMGR_R_OK)
1636 ERR("register license failed: %d", ret);
1641 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1642 const char *drm_file_path, const char *decrypted_file_path)
1646 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1648 if (pc == NULL || drm_file_path == NULL ||
1649 decrypted_file_path == NULL) {
1650 ERR("invalid parameter");
1651 return PKGMGR_R_EINVAL;
1654 if (client->pc_type != PC_REQUEST) {
1655 ERR("client->pc_type is not PC_REQUEST");
1656 return PKGMGR_R_EINVAL;
1659 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1660 g_variant_new("(ss)", drm_file_path,
1661 decrypted_file_path), &result);
1662 if (ret != PKGMGR_R_OK) {
1663 ERR("request failed: %d", ret);
1667 g_variant_get(result, "(i)", &ret);
1668 g_variant_unref(result);
1669 if (ret != PKGMGR_R_OK)
1670 ERR("decrypt_package failed: %d", ret);
1675 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1677 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1680 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1681 const char *appid, uid_t uid)
1685 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1687 if (pc == NULL || appid == NULL) {
1688 ERR("Invalid parameter");
1689 return PKGMGR_R_EINVAL;
1692 ret = pkgmgr_client_connection_send_request(client,
1693 "enable_app_splash_screen",
1694 g_variant_new("(us)", uid, appid), &result);
1695 if (ret != PKGMGR_R_OK) {
1696 ERR("request failed: %d", ret);
1700 g_variant_get(result, "(i)", &ret);
1701 g_variant_unref(result);
1702 if (ret != PKGMGR_R_OK)
1703 ERR("enable splash screen failed: %d", ret);
1708 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1711 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1715 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1716 const char *appid, uid_t uid)
1720 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1722 if (pc == NULL || appid == NULL) {
1723 ERR("Invalid parameter");
1724 return PKGMGR_R_EINVAL;
1727 ret = pkgmgr_client_connection_send_request(client,
1728 "disable_app_splash_screen",
1729 g_variant_new("(us)", uid, appid), &result);
1730 if (ret != PKGMGR_R_OK) {
1731 ERR("request failed: %d", ret);
1735 g_variant_get(result, "(i)", &ret);
1736 g_variant_unref(result);
1737 if (ret != PKGMGR_R_OK)
1738 ERR("disable splash screen failed: %d", ret);
1743 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1744 int mode, uid_t uid)
1747 int ret = PKGMGR_R_ECOMM;
1748 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1750 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1751 ERR("invalid parameter");
1752 return PKGMGR_R_EINVAL;
1755 ret = pkgmgr_client_connection_send_request(client,
1756 "set_restriction_mode",
1757 g_variant_new("(usi)", uid, pkgid, mode), &result);
1758 if (ret != PKGMGR_R_OK) {
1759 ERR("request failed: %d", ret);
1763 g_variant_get(result, "(i)", &ret);
1764 g_variant_unref(result);
1769 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1770 const char *pkgid, int mode, uid_t uid)
1772 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1775 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1776 const char *pkgid, int mode)
1778 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1782 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1783 int mode, uid_t uid)
1786 int ret = PKGMGR_R_ECOMM;
1787 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1789 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1790 ERR("invalid parameter");
1791 return PKGMGR_R_EINVAL;
1794 ret = pkgmgr_client_connection_send_request(client,
1795 "unset_restriction_mode",
1796 g_variant_new("(usi)", uid, pkgid, mode), &result);
1797 if (ret != PKGMGR_R_OK) {
1798 ERR("request failed: %d", ret);
1802 g_variant_get(result, "(i)", &ret);
1803 g_variant_unref(result);
1809 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1810 const char *pkgid, int mode, uid_t uid)
1812 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1815 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1816 const char *pkgid, int mode)
1818 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1822 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1823 int *mode, uid_t uid)
1826 int ret = PKGMGR_R_ECOMM;
1828 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1830 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1831 ERR("invalid parameter");
1832 return PKGMGR_R_EINVAL;
1835 ret = pkgmgr_client_connection_send_request(client,
1836 "get_restriction_mode",
1837 g_variant_new("(us)", uid, pkgid), &result);
1838 if (ret != PKGMGR_R_OK) {
1839 ERR("request failed: %d", ret);
1843 g_variant_get(result, "(ii)", &m, &ret);
1844 g_variant_unref(result);
1845 if (ret != PKGMGR_R_OK)
1853 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
1854 const char *pkgid, int *mode, uid_t uid)
1856 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
1859 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
1860 const char *pkgid, int *mode)
1862 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
1866 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
1870 int ret = PKGMGR_R_ECOMM;
1871 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1874 ERR("invalid parameter");
1875 return PKGMGR_R_EINVAL;
1878 ret = pkgmgr_client_connection_send_request(client,
1879 "set_restriction_mode",
1880 g_variant_new("(usi)", uid, "", mode), &result);
1881 if (ret != PKGMGR_R_OK) {
1882 ERR("request failed: %d", ret);
1886 g_variant_get(result, "(i)", &ret);
1887 g_variant_unref(result);
1892 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
1894 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
1897 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
1901 int ret = PKGMGR_R_ECOMM;
1902 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1905 ERR("invalid parameter");
1906 return PKGMGR_R_EINVAL;
1909 ret = pkgmgr_client_connection_send_request(client,
1910 "unset_restriction_mode",
1911 g_variant_new("(usi)", uid, "", mode), &result);
1912 if (ret != PKGMGR_R_OK) {
1913 ERR("request failed: %d", ret);
1917 g_variant_get(result, "(i)", &ret);
1918 g_variant_unref(result);
1923 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
1925 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
1928 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
1929 int *mode, uid_t uid)
1932 int ret = PKGMGR_R_ECOMM;
1934 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1937 ERR("invalid parameter");
1938 return PKGMGR_R_EINVAL;
1941 ret = pkgmgr_client_connection_send_request(client,
1942 "get_restriction_mode",
1943 g_variant_new("(us)", uid, ""), &result);
1944 if (ret != PKGMGR_R_OK) {
1945 ERR("request failed: %d", ret);
1949 g_variant_get(result, "(ii)", &m, &ret);
1950 g_variant_unref(result);
1951 if (ret != PKGMGR_R_OK)
1959 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
1961 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());