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 BINSH_NAME "/bin/sh"
52 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
53 #define REGULAR_USER 5000
55 static inline uid_t _getuid(void)
59 if (uid < REGULAR_USER)
65 static int _get_request_id()
67 static int internal_req_id = 1;
69 return internal_req_id++;
72 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
73 pkgmgr_handler event_cb, void *data, const char *req_key)
75 struct cb_info *cb_info;
77 cb_info = calloc(1, sizeof(struct cb_info));
78 if (cb_info == NULL) {
82 cb_info->client = client;
83 cb_info->event_cb = event_cb;
85 cb_info->req_id = _get_request_id();
86 if (req_key != NULL) {
87 cb_info->req_key = strdup(req_key);
88 if (cb_info->req_key == NULL) {
98 static struct cb_info *__create_app_event_cb_info(
99 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
100 void *data, const char *req_key)
102 struct cb_info *cb_info;
104 cb_info = calloc(1, sizeof(struct cb_info));
105 if (cb_info == NULL) {
106 ERR("out of memory");
109 cb_info->client = client;
110 cb_info->app_event_cb = app_event_cb;
111 cb_info->data = data;
112 cb_info->req_id = _get_request_id();
113 if (req_key != NULL) {
114 cb_info->req_key = strdup(req_key);
115 if (cb_info->req_key == NULL) {
116 ERR("out of memory");
125 static struct cb_info *__create_size_info_cb_info(
126 struct pkgmgr_client_t *client,
127 pkgmgr_pkg_size_info_receive_cb size_info_cb,
128 void *data, const char *req_key)
130 struct cb_info *cb_info;
132 cb_info = calloc(1, sizeof(struct cb_info));
133 if (cb_info == NULL) {
134 ERR("out of memory");
137 cb_info->client = client;
138 cb_info->size_info_cb = size_info_cb;
139 cb_info->data = data;
140 cb_info->req_id = _get_request_id();
141 if (req_key != NULL) {
142 cb_info->req_key = strdup(req_key);
143 if (cb_info->req_key == NULL) {
144 ERR("out of memory");
153 static void __free_cb_info(struct cb_info *cb_info)
155 free(cb_info->req_key);
159 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
160 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
164 int ret = PKGMGR_R_ECOMM;
165 long long size_info = 0;
166 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
168 if (pc == NULL || pkgid == NULL) {
169 ERR("invalid parameter");
170 return PKGMGR_R_EINVAL;
173 if (client->pc_type != PC_REQUEST) {
174 ERR("client->pc_type is not PC_REQUEST");
175 return PKGMGR_R_EINVAL;
178 ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
179 g_variant_new("(usi)", uid, pkgid, get_type), &result);
180 if (ret != PKGMGR_R_OK) {
181 ERR("request failed: %d", ret);
185 g_variant_get(result, "(ix)", &ret, &size_info);
186 if (ret != PKGMGR_R_OK) {
187 ERR("request result failed: %d", ret);
188 g_variant_unref(result);
193 ERR("invalid size_info=(%d)", size_info);
196 ret = (int)size_info;
197 DBG("size_info(%lld), return size(%d)", size_info, ret);
200 g_variant_unref(result);
205 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
206 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
207 pkgmgr_handler event_cb, void *data)
211 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
213 ERR("move request failed");
220 static int __check_app_process(pkgmgr_request_service_type service_type,
221 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
224 int ret = PKGMGR_R_ECOMM;
225 pkgmgrinfo_pkginfo_h handle;
227 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
229 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
231 if (uid != GLOBAL_USER)
232 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
234 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
235 retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
237 if (service_type == PM_REQUEST_KILL_APP)
238 ret = pkgmgr_client_connection_send_request(client, "kill",
239 g_variant_new("(us)", uid, pkgid), &result);
240 else if (service_type == PM_REQUEST_CHECK_APP)
241 ret = pkgmgr_client_connection_send_request(client, "check",
242 g_variant_new("(us)", uid, pkgid), &result);
243 if (ret != PKGMGR_R_OK) {
244 ERR("request failed: %d", ret);
248 g_variant_get(result, "(ii)", &ret, &pid);
249 g_variant_unref(result);
250 if (ret != PKGMGR_R_OK) {
251 ERR("request failed, ret=%d", ret);
257 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
263 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
266 int ret = PKGMGR_R_ECOMM;
267 // char *req_key = NULL;
268 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
271 ERR("invalid parameter");
272 return PKGMGR_R_EINVAL;
275 if (client->pc_type != PC_REQUEST) {
276 ERR("client->pc_type is not PC_REQUEST");
277 return PKGMGR_R_EINVAL;
280 ret = pkgmgr_client_connection_send_request(client, "getsize",
281 g_variant_new("(usi)", uid, "size_info",
282 PM_GET_SIZE_INFO), &result);
283 if (ret != PKGMGR_R_OK) {
284 ERR("request failed: %d", ret);
289 g_variant_get(result, "(i&s)", &ret, &req_key);
290 if (req_key == NULL) {
291 g_variant_unref(result);
292 return PKGMGR_R_ECOMM;
296 g_variant_unref(result);
301 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
303 struct pkgmgr_client_t *client;
305 if (pc_type == PC_BROADCAST) {
306 ERR("broadcast type is not supported");
310 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
311 ERR("invalid parameter");
315 client = calloc(1, sizeof(struct pkgmgr_client_t));
316 if (client == NULL) {
317 ERR("out of memory");
321 client->pc_type = pc_type;
322 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
324 if (pkgmgr_client_connection_connect(client))
327 return (pkgmgr_client *)client;
330 API int pkgmgr_client_free(pkgmgr_client *pc)
332 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
335 ERR("invalid argument");
336 return PKGMGR_R_EINVAL;
339 pkgmgr_client_remove_listen_status(client);
340 pkgmgr_client_connection_disconnect(client);
341 if (client->tep_path)
342 free(client->tep_path);
348 static char *__get_type_from_path(const char *pkg_path)
351 char mimetype[255] = { '\0', };
352 char extlist[256] = { '\0', };
355 ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
357 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
361 ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
363 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
367 if (strlen(extlist) == 0)
370 if (strchr(extlist, ','))
371 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
373 pkg_type = strchr(extlist, '.') + 1;
374 return strdup(pkg_type);
377 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
380 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
382 if (pc == NULL || tep_path == NULL) {
383 ERR("invalied parameter");
384 return PKGMGR_R_EINVAL;
387 if (client->tep_path)
388 free(client->tep_path);
390 client->tep_path = strdup(tep_path);
391 client->tep_move = tep_move;
396 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
397 const char *descriptor_path, const char *pkg_path,
398 const char *optional_data, pkgmgr_mode mode,
399 pkgmgr_handler event_cb, void *data, uid_t uid)
402 int ret = PKGMGR_R_ECOMM;
403 char *req_key = NULL;
404 GVariantBuilder *builder = NULL;
405 GVariant *args = NULL;
406 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
407 char *pkgtype = NULL;
408 struct cb_info *cb_info;
410 if (pc == NULL || pkg_path == NULL) {
411 ERR("invalid parameter");
412 return PKGMGR_R_EINVAL;
415 if (client->pc_type != PC_REQUEST) {
416 ERR("client type is not PC_REQUEST");
417 return PKGMGR_R_EINVAL;
420 if (access(pkg_path, F_OK) != 0) {
421 ERR("failed to access: %s", pkg_path);
422 return PKGMGR_R_EINVAL;
425 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
426 ERR("failed to access: %s", client->tep_path);
427 return PKGMGR_R_EINVAL;
431 pkgtype = strdup(pkg_type);
433 /* build arguments */
434 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
435 if (client->tep_path) {
436 g_variant_builder_add(builder, "s", "-e");
437 g_variant_builder_add(builder, "s", client->tep_path);
438 g_variant_builder_add(builder, "s", "-M");
439 /* TODO: revise tep_move */
440 g_variant_builder_add(builder, "s",
441 client->tep_move ? "tep_move" : "tep_copy");
443 if (client->debug_mode)
444 g_variant_builder_add(builder, "s", "-G");
446 args = g_variant_new("as", builder);
447 g_variant_builder_unref(builder);
449 ret = pkgmgr_client_connection_send_request(client, "install",
450 g_variant_new("(uss@as)", uid, pkgtype ? pkgtype : "",
453 if (ret != PKGMGR_R_OK) {
454 ERR("request failed: %d", ret);
458 g_variant_get(result, "(i&s)", &ret, &req_key);
459 if (req_key == NULL) {
460 g_variant_unref(result);
461 return PKGMGR_R_ECOMM;
463 if (ret != PKGMGR_R_OK) {
464 g_variant_unref(result);
468 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
469 if (cb_info == NULL) {
470 g_variant_unref(result);
471 return PKGMGR_R_ENOMEM;
473 g_variant_unref(result);
474 ret = pkgmgr_client_connection_set_callback(client, cb_info);
475 if (ret != PKGMGR_R_OK) {
476 __free_cb_info(cb_info);
479 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
481 return cb_info->req_id;
484 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
485 const char *descriptor_path, const char *pkg_path,
486 const char *optional_data, pkgmgr_mode mode,
487 pkgmgr_handler event_cb, void *data)
489 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
490 pkg_path, optional_data, mode, event_cb, data,
494 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
495 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
496 pkgmgr_handler event_cb, void *data)
498 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
499 mode, event_cb, data, _getuid());
502 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
503 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
504 pkgmgr_handler event_cb, void *data, uid_t uid)
507 int ret = PKGMGR_R_ECOMM;
508 char *req_key = NULL;
509 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
510 struct cb_info *cb_info;
512 if (pc == NULL || pkgid == NULL) {
513 ERR("invalid parameter");
514 return PKGMGR_R_EINVAL;
517 if (client->pc_type != PC_REQUEST) {
518 ERR("client->pc_type is not PC_REQUEST");
519 return PKGMGR_R_EINVAL;
522 ret = pkgmgr_client_connection_send_request(client, "reinstall",
523 g_variant_new("(us)", uid, pkgid), &result);
524 if (ret != PKGMGR_R_OK) {
525 ERR("request failed: %d", ret);
529 g_variant_get(result, "(i&s)", &ret, &req_key);
530 if (req_key == NULL) {
531 g_variant_unref(result);
532 return PKGMGR_R_ECOMM;
534 if (ret != PKGMGR_R_OK) {
535 g_variant_unref(result);
539 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
540 if (cb_info == NULL) {
541 g_variant_unref(result);
542 return PKGMGR_R_ENOMEM;
544 g_variant_unref(result);
545 ret = pkgmgr_client_connection_set_callback(client, cb_info);
546 if (ret != PKGMGR_R_OK) {
547 __free_cb_info(cb_info);
550 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
552 return cb_info->req_id;
555 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
556 const char *descriptor_path, const char *pkg_path,
557 const char *optional_data, pkgmgr_mode mode,
558 pkgmgr_handler event_cb, void *data, uid_t uid)
561 int ret = PKGMGR_R_ECOMM;
562 char *req_key = NULL;
563 GVariantBuilder *builder = NULL;
564 GVariant *args = NULL;
565 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
566 char *pkgtype = NULL;
567 struct cb_info *cb_info;
569 if (pc == NULL || pkg_path == NULL) {
570 ERR("invalid parameter");
571 return PKGMGR_R_EINVAL;
574 if (client->pc_type != PC_REQUEST) {
575 ERR("client->pc_type is not PC_REQUEST");
576 return PKGMGR_R_EINVAL;
579 if (access(pkg_path, F_OK) != 0) {
580 ERR("failed to access: %s", pkg_path);
581 return PKGMGR_R_EINVAL;
584 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
585 ERR("failed to access: %s", client->tep_path);
586 return PKGMGR_R_EINVAL;
590 pkgtype = strdup(pkg_type);
592 /* build arguments */
593 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
594 if (client->tep_path) {
595 g_variant_builder_add(builder, "s", "-e");
596 g_variant_builder_add(builder, "s", client->tep_path);
597 g_variant_builder_add(builder, "s", "-M");
598 /* TODO: revise tep_move */
599 g_variant_builder_add(builder, "s",
600 client->tep_move ? "tep_move" : "tep_copy");
603 args = g_variant_new("as", builder);
604 g_variant_builder_unref(builder);
606 ret = pkgmgr_client_connection_send_request(client, "mount_install",
607 g_variant_new("(uss@as)", uid, pkgtype ? pkgtype : "",
610 if (ret != PKGMGR_R_OK) {
611 ERR("request failed: %d", ret);
615 g_variant_get(result, "(i&s)", &ret, &req_key);
616 if (req_key == NULL) {
617 g_variant_unref(result);
618 return PKGMGR_R_ECOMM;
620 if (ret != PKGMGR_R_OK) {
621 g_variant_unref(result);
625 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
626 if (cb_info == NULL) {
627 g_variant_unref(result);
628 return PKGMGR_R_ENOMEM;
630 g_variant_unref(result);
631 ret = pkgmgr_client_connection_set_callback(client, cb_info);
632 if (ret != PKGMGR_R_OK) {
633 __free_cb_info(cb_info);
636 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
638 return cb_info->req_id;
641 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
642 const char *descriptor_path, const char *pkg_path,
643 const char *optional_data, pkgmgr_mode mode,
644 pkgmgr_handler event_cb, void *data)
646 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
647 pkg_path, optional_data, mode, event_cb, data,
651 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
652 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
655 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
659 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
660 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
661 void *data, uid_t uid)
664 int ret = PKGMGR_R_ECOMM;
665 char *req_key = NULL;
666 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
667 struct cb_info *cb_info;
669 if (pc == NULL || pkgid == NULL) {
670 ERR("invalid parameter");
671 return PKGMGR_R_EINVAL;
674 if (client->pc_type != PC_REQUEST) {
675 ERR("client->pc_type is not PC_REQUEST");
676 return PKGMGR_R_EINVAL;
679 ret = pkgmgr_client_connection_send_request(client, "uninstall",
680 g_variant_new("(us)", uid, pkgid), &result);
681 if (ret != PKGMGR_R_OK) {
682 ERR("request failed: %d", ret);
686 g_variant_get(result, "(i&s)", &ret, &req_key);
687 if (req_key == NULL) {
688 g_variant_unref(result);
689 return PKGMGR_R_ECOMM;
691 if (ret != PKGMGR_R_OK) {
692 g_variant_unref(result);
696 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
697 if (cb_info == NULL) {
698 g_variant_unref(result);
699 return PKGMGR_R_ENOMEM;
701 g_variant_unref(result);
702 ret = pkgmgr_client_connection_set_callback(client, cb_info);
703 if (ret != PKGMGR_R_OK) {
704 __free_cb_info(cb_info);
707 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
709 return cb_info->req_id;
712 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
713 const char *pkgid, pkgmgr_move_type move_type,
714 pkgmgr_handler event_cb, void *data)
716 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
717 event_cb, data, _getuid());
719 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
720 const char *pkgid, pkgmgr_move_type move_type,
721 pkgmgr_handler event_cb, void *data, uid_t uid)
724 int ret = PKGMGR_R_ECOMM;
725 char *req_key = NULL;
726 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
727 struct cb_info *cb_info;
729 if (pc == NULL || pkgid == NULL) {
730 ERR("invalid parameter");
731 return PKGMGR_R_EINVAL;
734 if ((move_type < PM_MOVE_TO_INTERNAL) ||
735 (move_type > PM_MOVE_TO_SDCARD))
736 return PKGMGR_R_EINVAL;
738 if (client->pc_type != PC_REQUEST) {
739 ERR("client->pc_type is not PC_REQUEST");
740 return PKGMGR_R_EINVAL;
743 ret = pkgmgr_client_connection_send_request(client, "move",
744 g_variant_new("(usi)", uid, pkgid, move_type), &result);
745 if (ret != PKGMGR_R_OK) {
746 ERR("request failed: %d", ret);
750 g_variant_get(result, "(i&s)", &ret, &req_key);
751 if (req_key == NULL) {
752 g_variant_unref(result);
753 return PKGMGR_R_ECOMM;
755 if (ret != PKGMGR_R_OK) {
756 g_variant_unref(result);
760 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
761 if (cb_info == NULL) {
762 g_variant_unref(result);
763 return PKGMGR_R_ERROR;
765 g_variant_unref(result);
766 ret = pkgmgr_client_connection_set_callback(client, cb_info);
767 if (ret != PKGMGR_R_OK) {
768 __free_cb_info(cb_info);
771 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
773 return cb_info->req_id;
776 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
777 const char *pkgid, uid_t uid)
780 int ret = PKGMGR_R_ECOMM;
781 GVariantBuilder *builder;
782 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
784 if (pc == NULL || pkgid == NULL) {
785 ERR("invalid parameter");
786 return PKGMGR_R_EINVAL;
789 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
790 g_variant_builder_add(builder, "s", pkgid);
792 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
793 g_variant_new("(uas)", uid, builder), &result);
794 g_variant_builder_unref(builder);
795 if (ret != PKGMGR_R_OK) {
796 ERR("request failed: %d", ret);
800 g_variant_get(result, "(is)", &ret, NULL);
801 g_variant_unref(result);
806 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
809 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
812 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
813 const char *pkg_type, const char **pkgids, int n_pkgs,
814 pkgmgr_handler event_cb, void *data, uid_t uid)
817 GVariantBuilder *builder;
818 int ret = PKGMGR_R_ECOMM;
819 char *req_key = NULL;
820 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
821 struct cb_info *cb_info;
824 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
825 ERR("invalid parameter");
826 return PKGMGR_R_EINVAL;
829 if (client->pc_type != PC_REQUEST) {
830 ERR("client type is not PC_REQUEST");
831 return PKGMGR_R_EINVAL;
834 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
835 for (i = 0; i < n_pkgs; i++)
836 g_variant_builder_add(builder, "s", pkgids[i]);
838 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
839 g_variant_new("(uas)", uid, builder), &result);
840 g_variant_builder_unref(builder);
841 if (ret != PKGMGR_R_OK) {
842 ERR("request failed: %d", ret);
846 g_variant_get(result, "(i&s)", &ret, &req_key);
847 if (req_key == NULL) {
848 g_variant_unref(result);
849 return PKGMGR_R_ECOMM;
851 if (ret != PKGMGR_R_OK) {
852 g_variant_unref(result);
856 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
857 if (cb_info == NULL) {
858 g_variant_unref(result);
859 return PKGMGR_R_ERROR;
861 g_variant_unref(result);
862 ret = pkgmgr_client_connection_set_callback(client, cb_info);
863 if (ret != PKGMGR_R_OK) {
864 __free_cb_info(cb_info);
867 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
869 return cb_info->req_id;
872 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
873 const char *pkg_type, const char **pkgids, int n_pkgs,
874 pkgmgr_handler event_cb, void *data)
876 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
877 pkgids, n_pkgs, event_cb, data, _getuid());
880 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
881 const char *pkgid, uid_t uid)
884 GVariantBuilder *builder;
885 int ret = PKGMGR_R_ECOMM;
886 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
888 if (pc == NULL || pkgid == NULL) {
889 ERR("invalid parameter");
890 return PKGMGR_R_EINVAL;
893 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
894 g_variant_builder_add(builder, "s", pkgid);
896 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
897 g_variant_new("(uas)", uid, builder), &result);
898 g_variant_builder_unref(builder);
899 if (ret != PKGMGR_R_OK) {
900 ERR("request failed: %d", ret);
904 g_variant_get(result, "(is)", &ret, NULL);
905 g_variant_unref(result);
910 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
913 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
916 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
917 const char *pkg_type, const char **pkgids, int n_pkgs,
918 pkgmgr_handler event_cb, void *data, uid_t uid)
921 GVariantBuilder *builder;
922 int ret = PKGMGR_R_ECOMM;
923 char *req_key = NULL;
924 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
925 struct cb_info *cb_info;
928 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
929 ERR("invalid parameter");
930 return PKGMGR_R_EINVAL;
933 if (client->pc_type != PC_REQUEST) {
934 ERR("client type is not PC_REQUEST");
935 return PKGMGR_R_EINVAL;
938 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
939 for (i = 0; i < n_pkgs; i++)
940 g_variant_builder_add(builder, "s", pkgids[i]);
942 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
943 g_variant_new("(uas)", uid, builder), &result);
944 g_variant_builder_unref(builder);
945 if (ret != PKGMGR_R_OK) {
946 ERR("request failed: %d", ret);
950 g_variant_get(result, "(i&s)", &ret, &req_key);
951 if (req_key == NULL) {
952 g_variant_unref(result);
953 return PKGMGR_R_ECOMM;
955 if (ret != PKGMGR_R_OK) {
956 g_variant_unref(result);
960 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
961 if (cb_info == NULL) {
962 g_variant_unref(result);
963 return PKGMGR_R_ERROR;
965 g_variant_unref(result);
966 ret = pkgmgr_client_connection_set_callback(client, cb_info);
967 if (ret != PKGMGR_R_OK) {
968 __free_cb_info(cb_info);
971 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
973 return cb_info->req_id;
976 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
977 const char *pkg_type, const char **pkgids, int n_pkgs,
978 pkgmgr_handler event_cb, void *data)
980 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
981 pkgids, n_pkgs, event_cb, data, _getuid());
984 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
985 pkgmgr_app_handler app_event_cb, uid_t uid)
988 int ret = PKGMGR_R_ECOMM;
989 char *req_key = NULL;
990 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
991 struct cb_info *cb_info;
993 if (pc == NULL || appid == NULL) {
994 ERR("invalid parameter");
995 return PKGMGR_R_EINVAL;
998 ret = pkgmgr_client_connection_send_request(client, "enable_app",
999 g_variant_new("(us)", uid, appid), &result);
1000 if (ret != PKGMGR_R_OK) {
1001 ERR("request failed: %d", ret);
1005 g_variant_get(result, "(i&s)", &ret, &req_key);
1006 if (req_key == NULL) {
1007 g_variant_unref(result);
1008 return PKGMGR_R_ECOMM;
1010 if (ret != PKGMGR_R_OK) {
1011 g_variant_unref(result);
1015 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1017 if (cb_info == NULL) {
1018 g_variant_unref(result);
1019 return PKGMGR_R_ENOMEM;
1021 g_variant_unref(result);
1022 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1023 if (ret != PKGMGR_R_OK) {
1024 __free_cb_info(cb_info);
1027 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1032 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1033 pkgmgr_app_handler app_event_cb)
1035 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1039 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1040 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1043 int ret = PKGMGR_R_ECOMM;
1044 char *req_key = NULL;
1045 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1046 struct cb_info *cb_info;
1048 if (pc == NULL || appid == NULL) {
1049 ERR("invalid parameter");
1050 return PKGMGR_R_EINVAL;
1053 ret = pkgmgr_client_connection_send_request(client,
1054 "enable_global_app_for_uid",
1055 g_variant_new("(us)", uid, appid), &result);
1056 if (ret != PKGMGR_R_OK) {
1057 ERR("request failed: %d", ret);
1061 g_variant_get(result, "(i&s)", &ret, &req_key);
1062 if (req_key == NULL) {
1063 g_variant_unref(result);
1064 return PKGMGR_R_ECOMM;
1066 if (ret != PKGMGR_R_OK) {
1067 g_variant_unref(result);
1071 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1073 if (cb_info == NULL) {
1074 g_variant_unref(result);
1075 return PKGMGR_R_ENOMEM;
1077 g_variant_unref(result);
1078 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1079 if (ret != PKGMGR_R_OK) {
1080 __free_cb_info(cb_info);
1083 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1088 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1089 pkgmgr_app_handler app_event_cb, uid_t uid)
1092 int ret = PKGMGR_R_ECOMM;
1093 char *req_key = NULL;
1094 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1095 struct cb_info *cb_info;
1097 if (pc == NULL || appid == NULL) {
1098 ERR("invalid parameter");
1099 return PKGMGR_R_EINVAL;
1102 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1103 g_variant_new("(us)", uid, appid), &result);
1104 if (ret != PKGMGR_R_OK) {
1105 ERR("request failed: %d", ret);
1109 g_variant_get(result, "(i&s)", &ret, &req_key);
1110 if (req_key == NULL) {
1111 g_variant_unref(result);
1112 return PKGMGR_R_ECOMM;
1114 if (ret != PKGMGR_R_OK) {
1115 g_variant_unref(result);
1119 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1121 if (cb_info == NULL) {
1122 g_variant_unref(result);
1123 return PKGMGR_R_ENOMEM;
1125 g_variant_unref(result);
1126 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1127 if (ret != PKGMGR_R_OK) {
1128 __free_cb_info(cb_info);
1131 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1136 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1137 pkgmgr_app_handler app_event_cb)
1139 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1143 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1144 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1147 int ret = PKGMGR_R_ECOMM;
1148 char *req_key = NULL;
1149 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1150 struct cb_info *cb_info;
1152 if (pc == NULL || appid == NULL) {
1153 ERR("invalid parameter");
1154 return PKGMGR_R_EINVAL;
1157 ret = pkgmgr_client_connection_send_request(client,
1158 "disable_global_app_for_uid",
1159 g_variant_new("(us)", uid, appid), &result);
1160 if (ret != PKGMGR_R_OK) {
1161 ERR("request failed: %d", ret);
1165 g_variant_get(result, "(i&s)", &ret, &req_key);
1166 if (req_key == NULL) {
1167 g_variant_unref(result);
1168 return PKGMGR_R_ECOMM;
1170 if (ret != PKGMGR_R_OK) {
1171 g_variant_unref(result);
1175 cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1177 if (cb_info == NULL) {
1178 g_variant_unref(result);
1179 return PKGMGR_R_ENOMEM;
1181 g_variant_unref(result);
1182 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1183 if (ret != PKGMGR_R_OK) {
1184 __free_cb_info(cb_info);
1187 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1192 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1193 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1198 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1200 if (pc == NULL || appid == NULL) {
1201 ERR("invalid parameter");
1202 return PKGMGR_R_EINVAL;
1205 if (client->pc_type != PC_REQUEST) {
1206 ERR("client->pc_type is not PC_REQUEST");
1207 return PKGMGR_R_EINVAL;
1210 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1211 g_variant_new("(us)", uid, appid), &result);
1212 if (ret == PKGMGR_R_OK) {
1213 ERR("request failed: %d", ret);
1217 g_variant_get(result, "(i)", &ret);
1218 g_variant_unref(result);
1223 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1224 const char *appid, pkgmgr_mode mode)
1226 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1230 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1232 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1235 ERR("invalid parameter");
1236 return PKGMGR_R_EINVAL;
1239 client->status_type = status_type;
1244 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1248 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1249 struct cb_info *cb_info;
1251 if (pc == NULL || event_cb == NULL) {
1252 ERR("invalid parameter");
1253 return PKGMGR_R_EINVAL;
1256 if (client->pc_type != PC_LISTENING) {
1257 ERR("client->pc_type is not PC_LISTENING");
1258 return PKGMGR_R_EINVAL;
1261 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1262 if (cb_info == NULL)
1263 return PKGMGR_R_ENOMEM;
1264 cb_info->status_type = client->status_type;
1265 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1266 if (ret != PKGMGR_R_OK) {
1267 __free_cb_info(cb_info);
1270 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1272 return cb_info->req_id;
1275 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1276 pkgmgr_app_handler app_event_cb, void *data)
1279 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1280 struct cb_info *cb_info;
1282 if (pc == NULL || app_event_cb == NULL) {
1283 ERR("invalid parameter");
1284 return PKGMGR_R_EINVAL;
1287 if (client->pc_type != PC_LISTENING) {
1288 ERR("client->pc_type is not PC_LISTENING");
1289 return PKGMGR_R_EINVAL;
1292 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1293 if (cb_info == NULL)
1294 return PKGMGR_R_ENOMEM;
1295 cb_info->status_type = client->status_type;
1296 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1297 if (ret != PKGMGR_R_OK) {
1298 __free_cb_info(cb_info);
1301 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1303 return cb_info->req_id;
1306 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1308 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1311 struct cb_info *cb_info;
1314 ERR("invalid parameter");
1315 return PKGMGR_R_EINVAL;
1318 /* unset all callback */
1319 tmp = client->cb_info_list;
1320 while (tmp != NULL) {
1322 cb_info = (struct cb_info *)tmp->data;
1323 pkgmgr_client_connection_unset_callback(pc, cb_info);
1324 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1326 __free_cb_info(cb_info);
1333 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1334 const char *pkgid, const char *key, const char *val)
1336 /* client cannot broadcast signal */
1340 /* TODO: deprecate(or remove) */
1341 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1342 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1343 const char *pkgid, const char *custom_info,
1344 pkgmgr_handler event_cb, void *data)
1346 return pkgmgr_client_usr_request_service(service_type, service_mode,
1347 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1351 API int pkgmgr_client_usr_request_service(
1352 pkgmgr_request_service_type service_type, int service_mode,
1353 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1354 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1359 /* Check for NULL value of service type */
1360 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1361 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1363 switch (service_type) {
1364 case PM_REQUEST_MOVE:
1365 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1366 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1367 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1369 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1372 case PM_REQUEST_GET_SIZE:
1373 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1374 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1375 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1377 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1380 case PM_REQUEST_KILL_APP:
1381 case PM_REQUEST_CHECK_APP:
1382 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1383 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1385 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1387 ERR("__check_app_process fail \n");
1394 ERR("Wrong Request\n");
1405 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1408 struct pkgmgr_client *client;
1410 client = pkgmgr_client_new(PC_REQUEST);
1411 if (client == NULL) {
1412 ERR("out of memory");
1413 return PKGMGR_R_ENOMEM;
1416 ret = __request_size_info(client, uid);
1418 ERR("__request_size_info fail");
1420 pkgmgr_client_free(client);
1424 API int pkgmgr_client_request_size_info(void)
1426 /* get all package size (data, total) */
1427 return pkgmgr_client_usr_request_size_info(_getuid());
1430 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1434 struct pkgmgr_client_t *client;
1436 if (pkgid == NULL) {
1437 ERR("invalid parameter");
1438 return PKGMGR_R_EINVAL;
1441 client = pkgmgr_client_new(PC_REQUEST);
1442 if (client == NULL) {
1443 ERR("out of memory");
1444 return PKGMGR_R_ENOMEM;
1447 ret = pkgmgr_client_connection_send_request(client, "clearcache",
1448 g_variant_new("(us)", uid, pkgid), &result);
1449 if (ret != PKGMGR_R_OK) {
1450 ERR("request failed: %d", ret);
1454 g_variant_get(result, "(i)", &ret);
1455 g_variant_unref(result);
1460 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1462 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1465 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1467 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1470 API int pkgmgr_client_clear_all_cache_dir(void)
1472 return pkgmgr_client_usr_clear_cache_dir(
1473 PKG_CLEAR_ALL_CACHE, getuid());
1476 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1477 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1480 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1484 /* TODO: deprecate(or remove) */
1485 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1486 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1487 void *data, uid_t uid)
1490 int ret = PKGMGR_R_ECOMM;
1491 char *req_key = NULL;
1492 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1493 struct cb_info *cb_info;
1495 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1496 ERR("invalid parameter");
1497 return PKGMGR_R_EINVAL;
1500 if (client->pc_type != PC_REQUEST) {
1501 ERR("client->pc_type is not PC_REQUEST");
1502 return PKGMGR_R_EINVAL;
1506 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1507 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1509 get_type = PM_GET_PKG_SIZE_INFO;
1511 ret = pkgmgr_client_connection_send_request(client, "getsize",
1512 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1513 if (ret != PKGMGR_R_OK) {
1514 ERR("request failed: %d", ret);
1518 g_variant_get(result, "(i&s)", &ret, &req_key);
1519 if (req_key == NULL) {
1520 g_variant_unref(result);
1521 return PKGMGR_R_ECOMM;
1523 if (ret != PKGMGR_R_OK) {
1524 g_variant_unref(result);
1528 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1529 if (cb_info == NULL) {
1530 g_variant_unref(result);
1531 return PKGMGR_R_ENOMEM;
1533 g_variant_unref(result);
1534 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1535 if (ret != PKGMGR_R_OK) {
1536 __free_cb_info(cb_info);
1539 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1544 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1545 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1546 void *user_data, uid_t uid)
1549 int ret = PKGMGR_R_ECOMM;
1550 char *req_key = NULL;
1552 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1553 struct cb_info *cb_info;
1555 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1556 ERR("invalid parameter");
1557 return PKGMGR_R_EINVAL;
1560 if (client->pc_type != PC_REQUEST) {
1561 ERR("client->pc_type is not PC_REQUEST");
1562 return PKGMGR_R_EINVAL;
1565 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1566 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1568 get_type = PM_GET_PKG_SIZE_INFO;
1570 ret = pkgmgr_client_connection_send_request(client, "getsize",
1571 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1572 if (ret != PKGMGR_R_OK) {
1573 ERR("request failed: %d", ret);
1577 g_variant_get(result, "(i&s)", &ret, &req_key);
1578 if (req_key == NULL) {
1579 g_variant_unref(result);
1580 return PKGMGR_R_ECOMM;
1582 if (ret != PKGMGR_R_OK) {
1583 g_variant_unref(result);
1587 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1589 if (cb_info == NULL) {
1590 g_variant_unref(result);
1591 return PKGMGR_R_ENOMEM;
1593 g_variant_unref(result);
1594 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1595 if (ret != PKGMGR_R_OK) {
1596 __free_cb_info(cb_info);
1599 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1604 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1605 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1608 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1609 user_data, _getuid());
1612 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1613 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1614 void *user_data, uid_t uid)
1615 { /* total package size info */
1616 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1617 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1621 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1622 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1624 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1625 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1626 user_data, _getuid());
1629 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1630 const char *resp_data, char **req_data, char **license_url)
1636 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1638 if (pc == NULL || resp_data == NULL || req_data == NULL ||
1639 license_url == NULL) {
1640 ERR("invalid parameter");
1641 return PKGMGR_R_EINVAL;
1644 if (client->pc_type != PC_REQUEST) {
1645 ERR("client->pc_type is not PC_REQUEST");
1646 return PKGMGR_R_EINVAL;
1649 ret = pkgmgr_client_connection_send_request(client,
1650 "generate_license_request",
1651 g_variant_new("(s)", resp_data), &result);
1652 if (ret != PKGMGR_R_OK) {
1653 ERR("request failed: %d", ret);
1657 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1658 if (ret != PKGMGR_R_OK) {
1659 ERR("generate_license_request failed: %d", ret);
1660 g_variant_unref(result);
1664 *req_data = strdup(data);
1665 *license_url = strdup(url);
1667 g_variant_unref(result);
1672 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1676 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1678 if (pc == NULL || resp_data == NULL) {
1679 ERR("invalid parameter");
1680 return PKGMGR_R_EINVAL;
1683 if (client->pc_type != PC_REQUEST) {
1684 ERR("client->pc_type is not PC_REQUEST");
1685 return PKGMGR_R_EINVAL;
1688 ret = pkgmgr_client_connection_send_request(client, "register_license",
1689 g_variant_new("(s)", resp_data), &result);
1690 if (ret != PKGMGR_R_OK) {
1691 ERR("request failed: %d", ret);
1695 g_variant_get(result, "(i)", &ret);
1696 g_variant_unref(result);
1697 if (ret != PKGMGR_R_OK)
1698 ERR("register license failed: %d", ret);
1703 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1704 const char *drm_file_path, const char *decrypted_file_path)
1708 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1710 if (pc == NULL || drm_file_path == NULL ||
1711 decrypted_file_path == NULL) {
1712 ERR("invalid parameter");
1713 return PKGMGR_R_EINVAL;
1716 if (client->pc_type != PC_REQUEST) {
1717 ERR("client->pc_type is not PC_REQUEST");
1718 return PKGMGR_R_EINVAL;
1721 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1722 g_variant_new("(ss)", drm_file_path,
1723 decrypted_file_path), &result);
1724 if (ret != PKGMGR_R_OK) {
1725 ERR("request failed: %d", ret);
1729 g_variant_get(result, "(i)", &ret);
1730 g_variant_unref(result);
1731 if (ret != PKGMGR_R_OK)
1732 ERR("decrypt_package failed: %d", ret);
1737 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1739 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1742 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1743 const char *appid, uid_t uid)
1747 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1749 if (pc == NULL || appid == NULL) {
1750 ERR("Invalid parameter");
1751 return PKGMGR_R_EINVAL;
1754 ret = pkgmgr_client_connection_send_request(client,
1755 "enable_app_splash_screen",
1756 g_variant_new("(us)", uid, appid), &result);
1757 if (ret != PKGMGR_R_OK) {
1758 ERR("request failed: %d", ret);
1762 g_variant_get(result, "(i)", &ret);
1763 g_variant_unref(result);
1764 if (ret != PKGMGR_R_OK)
1765 ERR("enable splash screen failed: %d", ret);
1770 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1773 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1777 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1778 const char *appid, uid_t uid)
1782 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1784 if (pc == NULL || appid == NULL) {
1785 ERR("Invalid parameter");
1786 return PKGMGR_R_EINVAL;
1789 ret = pkgmgr_client_connection_send_request(client,
1790 "disable_app_splash_screen",
1791 g_variant_new("(us)", uid, appid), &result);
1792 if (ret != PKGMGR_R_OK) {
1793 ERR("request failed: %d", ret);
1797 g_variant_get(result, "(i)", &ret);
1798 g_variant_unref(result);
1799 if (ret != PKGMGR_R_OK)
1800 ERR("disable splash screen failed: %d", ret);
1805 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1806 int mode, uid_t uid)
1809 int ret = PKGMGR_R_ECOMM;
1810 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1812 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1813 ERR("invalid parameter");
1814 return PKGMGR_R_EINVAL;
1817 ret = pkgmgr_client_connection_send_request(client,
1818 "set_restriction_mode",
1819 g_variant_new("(usi)", uid, pkgid, mode), &result);
1820 if (ret != PKGMGR_R_OK) {
1821 ERR("request failed: %d", ret);
1825 g_variant_get(result, "(i)", &ret);
1826 g_variant_unref(result);
1831 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1832 const char *pkgid, int mode, uid_t uid)
1834 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1837 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1838 const char *pkgid, int mode)
1840 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1844 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1845 int mode, uid_t uid)
1848 int ret = PKGMGR_R_ECOMM;
1849 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1851 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1852 ERR("invalid parameter");
1853 return PKGMGR_R_EINVAL;
1856 ret = pkgmgr_client_connection_send_request(client,
1857 "unset_restriction_mode",
1858 g_variant_new("(usi)", uid, pkgid, mode), &result);
1859 if (ret != PKGMGR_R_OK) {
1860 ERR("request failed: %d", ret);
1864 g_variant_get(result, "(i)", &ret);
1865 g_variant_unref(result);
1871 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1872 const char *pkgid, int mode, uid_t uid)
1874 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1877 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1878 const char *pkgid, int mode)
1880 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1884 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1885 int *mode, uid_t uid)
1888 int ret = PKGMGR_R_ECOMM;
1890 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1892 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1893 ERR("invalid parameter");
1894 return PKGMGR_R_EINVAL;
1897 ret = pkgmgr_client_connection_send_request(client,
1898 "get_restriction_mode",
1899 g_variant_new("(us)", uid, pkgid), &result);
1900 if (ret != PKGMGR_R_OK) {
1901 ERR("request failed: %d", ret);
1905 g_variant_get(result, "(ii)", &m, &ret);
1906 g_variant_unref(result);
1907 if (ret != PKGMGR_R_OK)
1915 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
1916 const char *pkgid, int *mode, uid_t uid)
1918 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
1921 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
1922 const char *pkgid, int *mode)
1924 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
1928 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
1932 int ret = PKGMGR_R_ECOMM;
1933 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1936 ERR("invalid parameter");
1937 return PKGMGR_R_EINVAL;
1940 ret = pkgmgr_client_connection_send_request(client,
1941 "set_restriction_mode",
1942 g_variant_new("(usi)", uid, "", mode), &result);
1943 if (ret != PKGMGR_R_OK) {
1944 ERR("request failed: %d", ret);
1948 g_variant_get(result, "(i)", &ret);
1949 g_variant_unref(result);
1954 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
1956 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
1959 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
1963 int ret = PKGMGR_R_ECOMM;
1964 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1967 ERR("invalid parameter");
1968 return PKGMGR_R_EINVAL;
1971 ret = pkgmgr_client_connection_send_request(client,
1972 "unset_restriction_mode",
1973 g_variant_new("(usi)", uid, "", mode), &result);
1974 if (ret != PKGMGR_R_OK) {
1975 ERR("request failed: %d", ret);
1979 g_variant_get(result, "(i)", &ret);
1980 g_variant_unref(result);
1985 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
1987 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
1990 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
1991 int *mode, uid_t uid)
1994 int ret = PKGMGR_R_ECOMM;
1996 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1999 ERR("invalid parameter");
2000 return PKGMGR_R_EINVAL;
2003 ret = pkgmgr_client_connection_send_request(client,
2004 "get_restriction_mode",
2005 g_variant_new("(us)", uid, ""), &result);
2006 if (ret != PKGMGR_R_OK) {
2007 ERR("request failed: %d", ret);
2011 g_variant_get(result, "(ii)", &m, &ret);
2012 g_variant_unref(result);
2013 if (ret != PKGMGR_R_OK)
2021 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2023 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2026 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2029 pkg_plugin_set *plugin_set;
2030 package_manager_pkg_detail_info_t *info;
2033 if (pkg_path == NULL) {
2034 ERR("invalid parameter");
2038 pkg_type = __get_type_from_path(pkg_path);
2039 if (pkg_type == NULL) {
2040 ERR("cannot get pkg type");
2044 plugin_set = _package_manager_load_library(pkg_type);
2045 if (plugin_set == NULL) {
2046 ERR("failed to load library for %s", pkg_type);
2051 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2053 ERR("out of memory");
2058 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2060 ERR("get_pkg_detail_info_from_package failed");
2068 return (pkgmgr_info *)info;
2071 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2073 package_manager_pkg_detail_info_t *pkg_info =
2074 (package_manager_pkg_detail_info_t *)info;
2077 ERR("invalid parameter");
2078 return PKGMGR_R_EINVAL;
2081 free(pkg_info->icon_buf);
2087 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2088 char *label, uid_t uid)
2092 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2094 if (pc == NULL || appid == NULL || label == NULL) {
2095 ERR("Invalid parameter");
2096 return PKGMGR_R_EINVAL;
2099 ret = pkgmgr_client_connection_send_request(client,
2101 g_variant_new("(uss)", uid, appid, label), &result);
2102 if (ret != PKGMGR_R_OK) {
2103 ERR("Request failed: %d", ret);
2107 g_variant_get(result, "(i)", &ret);
2108 g_variant_unref(result);
2113 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2115 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2118 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2120 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2123 ERR("invalid parameter");
2124 return PKGMGR_R_EINVAL;
2127 client->debug_mode = debug_mode;