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.
36 #include <pkgmgr-info.h>
37 #include <iniparser.h>
38 /* For multi-user support */
39 #include <tzplatform_config.h>
41 #include "package-manager.h"
42 #include "pkgmgr_client_debug.h"
43 #include "pkgmgr_client_internal.h"
45 /* API export macro */
47 #define API __attribute__ ((visibility("default")))
50 #define BINSH_NAME "/bin/sh"
53 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
54 #define REGULAR_USER 5000
56 static inline uid_t _getuid(void)
60 if (uid < REGULAR_USER)
66 static int _get_request_id()
68 static int internal_req_id = 1;
70 return internal_req_id++;
73 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
74 pkgmgr_handler event_cb, void *data, const char *req_key)
76 struct cb_info *cb_info;
78 cb_info = calloc(1, sizeof(struct cb_info));
79 if (cb_info == NULL) {
83 cb_info->client = client;
84 cb_info->event_cb = event_cb;
86 cb_info->req_id = _get_request_id();
87 if (req_key != NULL) {
88 cb_info->req_key = strdup(req_key);
89 if (cb_info->req_key == NULL) {
99 static struct cb_info *__create_app_event_cb_info(
100 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
101 void *data, const char *req_key)
103 struct cb_info *cb_info;
105 cb_info = calloc(1, sizeof(struct cb_info));
106 if (cb_info == NULL) {
107 ERR("out of memory");
110 cb_info->client = client;
111 cb_info->app_event_cb = app_event_cb;
112 cb_info->data = data;
113 cb_info->req_id = _get_request_id();
114 if (req_key != NULL) {
115 cb_info->req_key = strdup(req_key);
116 if (cb_info->req_key == NULL) {
117 ERR("out of memory");
126 static struct cb_info *__create_size_info_cb_info(
127 struct pkgmgr_client_t *client,
128 pkgmgr_pkg_size_info_receive_cb size_info_cb,
129 void *data, const char *req_key)
131 struct cb_info *cb_info;
133 cb_info = calloc(1, sizeof(struct cb_info));
134 if (cb_info == NULL) {
135 ERR("out of memory");
138 cb_info->client = client;
139 cb_info->size_info_cb = size_info_cb;
140 cb_info->data = data;
141 cb_info->req_id = _get_request_id();
142 if (req_key != NULL) {
143 cb_info->req_key = strdup(req_key);
144 if (cb_info->req_key == NULL) {
145 ERR("out of memory");
154 static void __free_cb_info(struct cb_info *cb_info)
156 free(cb_info->req_key);
160 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
161 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
165 int ret = PKGMGR_R_ECOMM;
166 long long size_info = 0;
167 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
169 if (pc == NULL || pkgid == NULL) {
170 ERR("invalid parameter");
171 return PKGMGR_R_EINVAL;
174 if (client->pc_type != PC_REQUEST) {
175 ERR("client->pc_type is not PC_REQUEST");
176 return PKGMGR_R_EINVAL;
179 ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
180 g_variant_new("(usi)", uid, pkgid, get_type), &result);
181 if (ret != PKGMGR_R_OK) {
182 ERR("request failed: %d", ret);
186 g_variant_get(result, "(ix)", &ret, &size_info);
187 if (ret != PKGMGR_R_OK) {
188 ERR("request result failed: %d", ret);
189 g_variant_unref(result);
194 ERR("invalid size_info=(%d)", size_info);
197 ret = (int)size_info;
198 DBG("size_info(%lld), return size(%d)", size_info, ret);
201 g_variant_unref(result);
206 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
207 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
208 pkgmgr_handler event_cb, void *data)
212 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
214 ERR("move request failed");
221 static int __check_app_process(pkgmgr_request_service_type service_type,
222 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
225 int ret = PKGMGR_R_ECOMM;
226 pkgmgrinfo_pkginfo_h handle;
228 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
230 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
232 if (uid != GLOBAL_USER)
233 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
235 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
236 retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
238 if (service_type == PM_REQUEST_KILL_APP)
239 ret = pkgmgr_client_connection_send_request(client, "kill",
240 g_variant_new("(us)", uid, pkgid), &result);
241 else if (service_type == PM_REQUEST_CHECK_APP)
242 ret = pkgmgr_client_connection_send_request(client, "check",
243 g_variant_new("(us)", uid, pkgid), &result);
244 if (ret != PKGMGR_R_OK) {
245 ERR("request failed: %d", ret);
249 g_variant_get(result, "(ii)", &ret, &pid);
250 g_variant_unref(result);
251 if (ret != PKGMGR_R_OK) {
252 ERR("request failed, ret=%d", ret);
258 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
264 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
267 int ret = PKGMGR_R_ECOMM;
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);
288 /* just free result here because it cannot return result(reqkey) */
289 g_variant_unref(result);
294 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
296 struct pkgmgr_client_t *client;
298 if (pc_type == PC_BROADCAST) {
299 ERR("broadcast type is not supported");
303 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
304 ERR("invalid parameter");
308 client = calloc(1, sizeof(struct pkgmgr_client_t));
309 if (client == NULL) {
310 ERR("out of memory");
314 client->pc_type = pc_type;
315 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
317 if (pkgmgr_client_connection_connect(client))
320 return (pkgmgr_client *)client;
323 API int pkgmgr_client_free(pkgmgr_client *pc)
325 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
328 ERR("invalid argument");
329 return PKGMGR_R_EINVAL;
332 pkgmgr_client_remove_listen_status(client);
333 pkgmgr_client_connection_disconnect(client);
334 if (client->tep_path)
335 free(client->tep_path);
341 struct manifest_and_type type_map[] = {
342 { "res/wgt/config.xml", "wgt" },
343 { "config.xml", "wgt" },
344 { "tizen-manifest.xml", "tpk" },
348 static char *__get_type_from_path(const char *pkg_path)
350 const char *type = NULL;
354 uf = unzOpen(pkg_path);
356 ERR("failed to open zip file %s", pkg_path);
360 for (i = 0; type_map[i].manifest != NULL; i++) {
361 if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
362 DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
363 type = type_map[i].type;
372 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
375 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
377 if (pc == NULL || tep_path == NULL) {
378 ERR("invalied parameter");
379 return PKGMGR_R_EINVAL;
382 if (client->tep_path)
383 free(client->tep_path);
385 client->tep_path = strdup(tep_path);
386 client->tep_move = tep_move;
391 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
392 const char *descriptor_path, const char *pkg_path,
393 const char *optional_data, pkgmgr_mode mode,
394 pkgmgr_handler event_cb, void *data, uid_t uid)
397 int ret = PKGMGR_R_ECOMM;
398 char *req_key = NULL;
399 GVariantBuilder *builder = NULL;
400 GVariant *args = NULL;
401 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
402 struct cb_info *cb_info;
404 if (pc == NULL || pkg_path == NULL) {
405 ERR("invalid parameter");
406 return PKGMGR_R_EINVAL;
409 if (client->pc_type != PC_REQUEST) {
410 ERR("client type is not PC_REQUEST");
411 return PKGMGR_R_EINVAL;
414 if (access(pkg_path, F_OK) != 0) {
415 ERR("failed to access: %s", pkg_path);
416 return PKGMGR_R_EINVAL;
419 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
420 ERR("failed to access: %s", client->tep_path);
421 return PKGMGR_R_EINVAL;
424 /* build arguments */
425 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
426 if (client->tep_path) {
427 g_variant_builder_add(builder, "s", "-e");
428 g_variant_builder_add(builder, "s", client->tep_path);
429 g_variant_builder_add(builder, "s", "-M");
430 /* TODO: revise tep_move */
431 g_variant_builder_add(builder, "s",
432 client->tep_move ? "tep_move" : "tep_copy");
434 if (client->debug_mode)
435 g_variant_builder_add(builder, "s", "-G");
437 args = g_variant_new("as", builder);
438 g_variant_builder_unref(builder);
440 ret = pkgmgr_client_connection_send_request(client, "install",
441 g_variant_new("(uss@as)", uid, pkg_type ? pkg_type : "",
444 if (ret != PKGMGR_R_OK) {
445 ERR("request failed: %d", ret);
449 g_variant_get(result, "(i&s)", &ret, &req_key);
450 if (req_key == NULL) {
451 g_variant_unref(result);
452 return PKGMGR_R_ECOMM;
454 if (ret != PKGMGR_R_OK) {
455 g_variant_unref(result);
459 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
460 if (cb_info == NULL) {
461 g_variant_unref(result);
462 return PKGMGR_R_ENOMEM;
464 g_variant_unref(result);
465 ret = pkgmgr_client_connection_set_callback(client, cb_info);
466 if (ret != PKGMGR_R_OK) {
467 __free_cb_info(cb_info);
470 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
472 return cb_info->req_id;
475 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
476 const char *descriptor_path, const char *pkg_path,
477 const char *optional_data, pkgmgr_mode mode,
478 pkgmgr_handler event_cb, void *data)
480 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
481 pkg_path, optional_data, mode, event_cb, data,
485 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
486 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
487 pkgmgr_handler event_cb, void *data)
489 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
490 mode, event_cb, data, _getuid());
493 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
494 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
495 pkgmgr_handler event_cb, void *data, uid_t uid)
498 int ret = PKGMGR_R_ECOMM;
499 char *req_key = NULL;
500 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
501 struct cb_info *cb_info;
503 if (pc == NULL || pkgid == NULL) {
504 ERR("invalid parameter");
505 return PKGMGR_R_EINVAL;
508 if (client->pc_type != PC_REQUEST) {
509 ERR("client->pc_type is not PC_REQUEST");
510 return PKGMGR_R_EINVAL;
513 ret = pkgmgr_client_connection_send_request(client, "reinstall",
514 g_variant_new("(us)", uid, pkgid), &result);
515 if (ret != PKGMGR_R_OK) {
516 ERR("request failed: %d", ret);
520 g_variant_get(result, "(i&s)", &ret, &req_key);
521 if (req_key == NULL) {
522 g_variant_unref(result);
523 return PKGMGR_R_ECOMM;
525 if (ret != PKGMGR_R_OK) {
526 g_variant_unref(result);
530 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
531 if (cb_info == NULL) {
532 g_variant_unref(result);
533 return PKGMGR_R_ENOMEM;
535 g_variant_unref(result);
536 ret = pkgmgr_client_connection_set_callback(client, cb_info);
537 if (ret != PKGMGR_R_OK) {
538 __free_cb_info(cb_info);
541 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
543 return cb_info->req_id;
546 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
547 const char *descriptor_path, const char *pkg_path,
548 const char *optional_data, pkgmgr_mode mode,
549 pkgmgr_handler event_cb, void *data, uid_t uid)
552 int ret = PKGMGR_R_ECOMM;
553 char *req_key = NULL;
554 GVariantBuilder *builder = NULL;
555 GVariant *args = NULL;
556 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
557 struct cb_info *cb_info;
559 if (pc == NULL || pkg_path == NULL) {
560 ERR("invalid parameter");
561 return PKGMGR_R_EINVAL;
564 if (client->pc_type != PC_REQUEST) {
565 ERR("client->pc_type is not PC_REQUEST");
566 return PKGMGR_R_EINVAL;
569 if (access(pkg_path, F_OK) != 0) {
570 ERR("failed to access: %s", pkg_path);
571 return PKGMGR_R_EINVAL;
574 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
575 ERR("failed to access: %s", client->tep_path);
576 return PKGMGR_R_EINVAL;
579 /* build arguments */
580 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
581 if (client->tep_path) {
582 g_variant_builder_add(builder, "s", "-e");
583 g_variant_builder_add(builder, "s", client->tep_path);
584 g_variant_builder_add(builder, "s", "-M");
585 /* TODO: revise tep_move */
586 g_variant_builder_add(builder, "s",
587 client->tep_move ? "tep_move" : "tep_copy");
590 args = g_variant_new("as", builder);
591 g_variant_builder_unref(builder);
593 ret = pkgmgr_client_connection_send_request(client, "mount_install",
594 g_variant_new("(uss@as)", uid, pkg_type ? pkg_type : "",
597 if (ret != PKGMGR_R_OK) {
598 ERR("request failed: %d", ret);
602 g_variant_get(result, "(i&s)", &ret, &req_key);
603 if (req_key == NULL) {
604 g_variant_unref(result);
605 return PKGMGR_R_ECOMM;
607 if (ret != PKGMGR_R_OK) {
608 g_variant_unref(result);
612 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
613 if (cb_info == NULL) {
614 g_variant_unref(result);
615 return PKGMGR_R_ENOMEM;
617 g_variant_unref(result);
618 ret = pkgmgr_client_connection_set_callback(client, cb_info);
619 if (ret != PKGMGR_R_OK) {
620 __free_cb_info(cb_info);
623 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
625 return cb_info->req_id;
628 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
629 const char *descriptor_path, const char *pkg_path,
630 const char *optional_data, pkgmgr_mode mode,
631 pkgmgr_handler event_cb, void *data)
633 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
634 pkg_path, optional_data, mode, event_cb, data,
638 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
639 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
642 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
646 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
647 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
648 void *data, uid_t uid)
651 int ret = PKGMGR_R_ECOMM;
652 char *req_key = NULL;
653 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
654 struct cb_info *cb_info;
656 if (pc == NULL || pkgid == NULL) {
657 ERR("invalid parameter");
658 return PKGMGR_R_EINVAL;
661 if (client->pc_type != PC_REQUEST) {
662 ERR("client->pc_type is not PC_REQUEST");
663 return PKGMGR_R_EINVAL;
666 ret = pkgmgr_client_connection_send_request(client, "uninstall",
667 g_variant_new("(us)", uid, pkgid), &result);
668 if (ret != PKGMGR_R_OK) {
669 ERR("request failed: %d", ret);
673 g_variant_get(result, "(i&s)", &ret, &req_key);
674 if (req_key == NULL) {
675 g_variant_unref(result);
676 return PKGMGR_R_ECOMM;
678 if (ret != PKGMGR_R_OK) {
679 g_variant_unref(result);
683 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
684 if (cb_info == NULL) {
685 g_variant_unref(result);
686 return PKGMGR_R_ENOMEM;
688 g_variant_unref(result);
689 ret = pkgmgr_client_connection_set_callback(client, cb_info);
690 if (ret != PKGMGR_R_OK) {
691 __free_cb_info(cb_info);
694 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
696 return cb_info->req_id;
699 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
700 const char *pkgid, pkgmgr_move_type move_type,
701 pkgmgr_handler event_cb, void *data)
703 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
704 event_cb, data, _getuid());
706 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
707 const char *pkgid, pkgmgr_move_type move_type,
708 pkgmgr_handler event_cb, void *data, uid_t uid)
711 int ret = PKGMGR_R_ECOMM;
712 char *req_key = NULL;
713 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
714 struct cb_info *cb_info;
716 if (pc == NULL || pkgid == NULL) {
717 ERR("invalid parameter");
718 return PKGMGR_R_EINVAL;
721 if ((move_type < PM_MOVE_TO_INTERNAL) ||
722 (move_type > PM_MOVE_TO_EXTENDED))
723 return PKGMGR_R_EINVAL;
725 if (client->pc_type != PC_REQUEST) {
726 ERR("client->pc_type is not PC_REQUEST");
727 return PKGMGR_R_EINVAL;
730 ret = pkgmgr_client_connection_send_request(client, "move",
731 g_variant_new("(usi)", uid, pkgid, move_type), &result);
732 if (ret != PKGMGR_R_OK) {
733 ERR("request failed: %d", ret);
737 g_variant_get(result, "(i&s)", &ret, &req_key);
738 if (req_key == NULL) {
739 g_variant_unref(result);
740 return PKGMGR_R_ECOMM;
742 if (ret != PKGMGR_R_OK) {
743 g_variant_unref(result);
747 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
748 if (cb_info == NULL) {
749 g_variant_unref(result);
750 return PKGMGR_R_ERROR;
752 g_variant_unref(result);
753 ret = pkgmgr_client_connection_set_callback(client, cb_info);
754 if (ret != PKGMGR_R_OK) {
755 __free_cb_info(cb_info);
758 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
760 return cb_info->req_id;
763 API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
764 pkg_update_info_t *update_info, uid_t uid)
767 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
770 if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
771 ERR("invalid parameter");
772 return PKGMGR_R_EINVAL;
775 if (client->pc_type != PC_REQUEST) {
776 ERR("client->pc_type is not PC_REQUEST");
777 return PKGMGR_R_EINVAL;
780 ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
781 g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
782 update_info->type), &result);
783 if (ret != PKGMGR_R_OK) {
784 ERR("request failed: %d", ret);
788 g_variant_get(result, "(i)", &ret);
789 if (ret != PKGMGR_R_OK) {
790 g_variant_unref(result);
793 g_variant_unref(result);
798 API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
799 pkg_update_info_t *update_info)
801 return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
805 API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
806 const char *pkgid, uid_t uid)
809 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
812 if (pc == NULL || pkgid == NULL) {
813 ERR("invalid parameter");
814 return PKGMGR_R_EINVAL;
817 if (client->pc_type != PC_REQUEST) {
818 ERR("client->pc_type is not PC_REQUEST");
819 return PKGMGR_R_EINVAL;
822 ret = pkgmgr_client_connection_send_request(client,
823 "unregister_pkg_update_info",
824 g_variant_new("(us)", uid, pkgid), &result);
825 if (ret != PKGMGR_R_OK) {
826 ERR("request failed: %d", ret);
830 g_variant_get(result, "(i)", &ret);
831 if (ret != PKGMGR_R_OK) {
832 g_variant_unref(result);
835 g_variant_unref(result);
840 API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
843 return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
846 API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
850 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
854 ERR("invalid parameter");
855 return PKGMGR_R_EINVAL;
858 if (client->pc_type != PC_REQUEST) {
859 ERR("client->pc_type is not PC_REQUEST");
860 return PKGMGR_R_EINVAL;
863 ret = pkgmgr_client_connection_send_request(client,
864 "unregister_all_pkg_update_info",
865 g_variant_new("(u)", uid), &result);
866 if (ret != PKGMGR_R_OK) {
867 ERR("request failed: %d", ret);
871 g_variant_get(result, "(i)", &ret);
872 if (ret != PKGMGR_R_OK) {
873 g_variant_unref(result);
876 g_variant_unref(result);
881 API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
883 return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
886 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
887 const char *pkgid, uid_t uid)
890 int ret = PKGMGR_R_ECOMM;
891 GVariantBuilder *builder;
892 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
894 if (pc == NULL || pkgid == NULL) {
895 ERR("invalid parameter");
896 return PKGMGR_R_EINVAL;
899 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
900 g_variant_builder_add(builder, "s", pkgid);
902 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
903 g_variant_new("(uas)", uid, builder), &result);
904 g_variant_builder_unref(builder);
905 if (ret != PKGMGR_R_OK) {
906 ERR("request failed: %d", ret);
910 g_variant_get(result, "(is)", &ret, NULL);
911 g_variant_unref(result);
916 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
919 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
922 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
923 const char *pkg_type, const char **pkgids, int n_pkgs,
924 pkgmgr_handler event_cb, void *data, uid_t uid)
927 GVariantBuilder *builder;
928 int ret = PKGMGR_R_ECOMM;
929 char *req_key = NULL;
930 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
931 struct cb_info *cb_info;
934 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
935 ERR("invalid parameter");
936 return PKGMGR_R_EINVAL;
939 if (client->pc_type != PC_REQUEST) {
940 ERR("client type is not PC_REQUEST");
941 return PKGMGR_R_EINVAL;
944 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
945 for (i = 0; i < n_pkgs; i++)
946 g_variant_builder_add(builder, "s", pkgids[i]);
948 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
949 g_variant_new("(uas)", uid, builder), &result);
950 g_variant_builder_unref(builder);
951 if (ret != PKGMGR_R_OK) {
952 ERR("request failed: %d", ret);
956 g_variant_get(result, "(i&s)", &ret, &req_key);
957 if (req_key == NULL) {
958 g_variant_unref(result);
959 return PKGMGR_R_ECOMM;
961 if (ret != PKGMGR_R_OK) {
962 g_variant_unref(result);
966 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
967 if (cb_info == NULL) {
968 g_variant_unref(result);
969 return PKGMGR_R_ERROR;
971 g_variant_unref(result);
972 ret = pkgmgr_client_connection_set_callback(client, cb_info);
973 if (ret != PKGMGR_R_OK) {
974 __free_cb_info(cb_info);
977 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
979 return cb_info->req_id;
982 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
983 const char *pkg_type, const char **pkgids, int n_pkgs,
984 pkgmgr_handler event_cb, void *data)
986 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
987 pkgids, n_pkgs, event_cb, data, _getuid());
990 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
991 const char *pkgid, uid_t uid)
994 GVariantBuilder *builder;
995 int ret = PKGMGR_R_ECOMM;
996 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
998 if (pc == NULL || pkgid == NULL) {
999 ERR("invalid parameter");
1000 return PKGMGR_R_EINVAL;
1003 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1004 g_variant_builder_add(builder, "s", pkgid);
1006 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1007 g_variant_new("(uas)", uid, builder), &result);
1008 g_variant_builder_unref(builder);
1009 if (ret != PKGMGR_R_OK) {
1010 ERR("request failed: %d", ret);
1014 g_variant_get(result, "(is)", &ret, NULL);
1015 g_variant_unref(result);
1020 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1023 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1026 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1027 const char *pkg_type, const char **pkgids, int n_pkgs,
1028 pkgmgr_handler event_cb, void *data, uid_t uid)
1031 GVariantBuilder *builder;
1032 int ret = PKGMGR_R_ECOMM;
1033 char *req_key = NULL;
1034 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1035 struct cb_info *cb_info;
1038 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1039 ERR("invalid parameter");
1040 return PKGMGR_R_EINVAL;
1043 if (client->pc_type != PC_REQUEST) {
1044 ERR("client type is not PC_REQUEST");
1045 return PKGMGR_R_EINVAL;
1048 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1049 for (i = 0; i < n_pkgs; i++)
1050 g_variant_builder_add(builder, "s", pkgids[i]);
1052 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1053 g_variant_new("(uas)", uid, builder), &result);
1054 g_variant_builder_unref(builder);
1055 if (ret != PKGMGR_R_OK) {
1056 ERR("request failed: %d", ret);
1060 g_variant_get(result, "(i&s)", &ret, &req_key);
1061 if (req_key == NULL) {
1062 g_variant_unref(result);
1063 return PKGMGR_R_ECOMM;
1065 if (ret != PKGMGR_R_OK) {
1066 g_variant_unref(result);
1070 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1071 if (cb_info == NULL) {
1072 g_variant_unref(result);
1073 return PKGMGR_R_ERROR;
1075 g_variant_unref(result);
1076 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1077 if (ret != PKGMGR_R_OK) {
1078 __free_cb_info(cb_info);
1081 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1083 return cb_info->req_id;
1086 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1087 const char *pkg_type, const char **pkgids, int n_pkgs,
1088 pkgmgr_handler event_cb, void *data)
1090 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1091 pkgids, n_pkgs, event_cb, data, _getuid());
1094 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1095 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1098 int ret = PKGMGR_R_ECOMM;
1099 char *req_key = NULL;
1100 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1101 struct cb_info *cb_info;
1103 if (pc == NULL || appid == NULL) {
1104 ERR("invalid parameter");
1105 return PKGMGR_R_EINVAL;
1108 ret = pkgmgr_client_connection_send_request(client, "enable_app",
1109 g_variant_new("(us)", uid, appid), &result);
1110 if (ret != PKGMGR_R_OK) {
1111 ERR("request failed: %d", ret);
1115 g_variant_get(result, "(i&s)", &ret, &req_key);
1116 if (req_key == NULL) {
1117 g_variant_unref(result);
1118 return PKGMGR_R_ECOMM;
1120 if (ret != PKGMGR_R_OK) {
1121 g_variant_unref(result);
1125 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1127 if (cb_info == NULL) {
1128 g_variant_unref(result);
1129 return PKGMGR_R_ENOMEM;
1131 g_variant_unref(result);
1132 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1133 if (ret != PKGMGR_R_OK) {
1134 __free_cb_info(cb_info);
1137 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1139 return cb_info->req_id;
1142 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1143 pkgmgr_app_handler app_event_cb, void *data)
1145 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1149 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1150 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1153 GVariantBuilder *builder;
1154 int ret = PKGMGR_R_ECOMM;
1155 char *req_key = NULL;
1156 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1157 struct cb_info *cb_info;
1160 if (pc == NULL || appids == NULL || n_apps < 1) {
1161 ERR("invalid parameter");
1162 return PKGMGR_R_EINVAL;
1165 if (client->pc_type != PC_REQUEST) {
1166 ERR("client type is not PC_REQUEST");
1167 return PKGMGR_R_EINVAL;
1170 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1171 for (i = 0; i < n_apps; i++)
1172 g_variant_builder_add(builder, "s", appids[i]);
1174 ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1175 g_variant_new("(uas)", uid, builder), &result);
1176 g_variant_builder_unref(builder);
1177 if (ret != PKGMGR_R_OK) {
1178 ERR("request failed: %d", ret);
1182 g_variant_get(result, "(i&s)", &ret, &req_key);
1183 if (req_key == NULL) {
1184 g_variant_unref(result);
1185 return PKGMGR_R_ECOMM;
1187 if (ret != PKGMGR_R_OK) {
1188 g_variant_unref(result);
1192 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1193 if (cb_info == NULL) {
1194 g_variant_unref(result);
1195 return PKGMGR_R_ERROR;
1197 g_variant_unref(result);
1198 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1199 if (ret != PKGMGR_R_OK) {
1200 __free_cb_info(cb_info);
1203 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1205 return cb_info->req_id;
1208 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1209 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1211 return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1212 app_event_cb, data, _getuid());
1215 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1216 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1219 int ret = PKGMGR_R_ECOMM;
1220 char *req_key = NULL;
1221 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1222 struct cb_info *cb_info;
1224 if (pc == NULL || appid == NULL) {
1225 ERR("invalid parameter");
1226 return PKGMGR_R_EINVAL;
1229 ret = pkgmgr_client_connection_send_request(client,
1230 "enable_global_app_for_uid",
1231 g_variant_new("(us)", uid, appid), &result);
1232 if (ret != PKGMGR_R_OK) {
1233 ERR("request failed: %d", ret);
1237 g_variant_get(result, "(i&s)", &ret, &req_key);
1238 if (req_key == NULL) {
1239 g_variant_unref(result);
1240 return PKGMGR_R_ECOMM;
1242 if (ret != PKGMGR_R_OK) {
1243 g_variant_unref(result);
1247 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1249 if (cb_info == NULL) {
1250 g_variant_unref(result);
1251 return PKGMGR_R_ENOMEM;
1253 g_variant_unref(result);
1254 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1255 if (ret != PKGMGR_R_OK) {
1256 __free_cb_info(cb_info);
1259 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1261 return cb_info->req_id;
1264 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1265 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1268 int ret = PKGMGR_R_ECOMM;
1269 char *req_key = NULL;
1270 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1271 struct cb_info *cb_info;
1273 if (pc == NULL || appid == NULL) {
1274 ERR("invalid parameter");
1275 return PKGMGR_R_EINVAL;
1278 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1279 g_variant_new("(us)", uid, appid), &result);
1280 if (ret != PKGMGR_R_OK) {
1281 ERR("request failed: %d", ret);
1285 g_variant_get(result, "(i&s)", &ret, &req_key);
1286 if (req_key == NULL) {
1287 g_variant_unref(result);
1288 return PKGMGR_R_ECOMM;
1290 if (ret != PKGMGR_R_OK) {
1291 g_variant_unref(result);
1295 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1297 if (cb_info == NULL) {
1298 g_variant_unref(result);
1299 return PKGMGR_R_ENOMEM;
1301 g_variant_unref(result);
1302 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1303 if (ret != PKGMGR_R_OK) {
1304 __free_cb_info(cb_info);
1307 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1309 return cb_info->req_id;
1312 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1313 pkgmgr_app_handler app_event_cb, void *data)
1315 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1319 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1320 const char **appids, int n_apps,
1321 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1324 GVariantBuilder *builder;
1325 int ret = PKGMGR_R_ECOMM;
1326 char *req_key = NULL;
1327 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1328 struct cb_info *cb_info;
1331 if (pc == NULL || appids == NULL || n_apps < 1) {
1332 ERR("invalid parameter");
1333 return PKGMGR_R_EINVAL;
1336 if (client->pc_type != PC_REQUEST) {
1337 ERR("client type is not PC_REQUEST");
1338 return PKGMGR_R_EINVAL;
1341 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1342 for (i = 0; i < n_apps; i++)
1343 g_variant_builder_add(builder, "s", appids[i]);
1345 ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1346 g_variant_new("(uas)", uid, builder), &result);
1347 g_variant_builder_unref(builder);
1348 if (ret != PKGMGR_R_OK) {
1349 ERR("request failed: %d", ret);
1353 g_variant_get(result, "(i&s)", &ret, &req_key);
1354 if (req_key == NULL) {
1355 g_variant_unref(result);
1356 return PKGMGR_R_ECOMM;
1358 if (ret != PKGMGR_R_OK) {
1359 g_variant_unref(result);
1363 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1364 if (cb_info == NULL) {
1365 g_variant_unref(result);
1366 return PKGMGR_R_ERROR;
1368 g_variant_unref(result);
1369 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1370 if (ret != PKGMGR_R_OK) {
1371 __free_cb_info(cb_info);
1374 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1376 return cb_info->req_id;
1379 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1380 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1382 return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1383 app_event_cb, data, _getuid());
1386 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1387 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1390 int ret = PKGMGR_R_ECOMM;
1391 char *req_key = NULL;
1392 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1393 struct cb_info *cb_info;
1395 if (pc == NULL || appid == NULL) {
1396 ERR("invalid parameter");
1397 return PKGMGR_R_EINVAL;
1400 ret = pkgmgr_client_connection_send_request(client,
1401 "disable_global_app_for_uid",
1402 g_variant_new("(us)", uid, appid), &result);
1403 if (ret != PKGMGR_R_OK) {
1404 ERR("request failed: %d", ret);
1408 g_variant_get(result, "(i&s)", &ret, &req_key);
1409 if (req_key == NULL) {
1410 g_variant_unref(result);
1411 return PKGMGR_R_ECOMM;
1413 if (ret != PKGMGR_R_OK) {
1414 g_variant_unref(result);
1418 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1420 if (cb_info == NULL) {
1421 g_variant_unref(result);
1422 return PKGMGR_R_ENOMEM;
1424 g_variant_unref(result);
1425 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1426 if (ret != PKGMGR_R_OK) {
1427 __free_cb_info(cb_info);
1430 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1432 return cb_info->req_id;
1435 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1436 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1441 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1443 if (pc == NULL || appid == NULL || uid == GLOBAL_USER) {
1444 ERR("invalid parameter");
1445 return PKGMGR_R_EINVAL;
1448 if (client->pc_type != PC_REQUEST) {
1449 ERR("client->pc_type is not PC_REQUEST");
1450 return PKGMGR_R_EINVAL;
1453 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1454 g_variant_new("(us)", uid, appid), &result);
1455 if (ret != PKGMGR_R_OK) {
1456 ERR("request failed: %d", ret);
1460 g_variant_get(result, "(i)", &ret);
1461 g_variant_unref(result);
1466 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1467 const char *appid, pkgmgr_mode mode)
1469 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1473 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1475 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1478 ERR("invalid parameter");
1479 return PKGMGR_R_EINVAL;
1482 client->status_type = status_type;
1487 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1491 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1492 struct cb_info *cb_info;
1494 if (pc == NULL || event_cb == NULL) {
1495 ERR("invalid parameter");
1496 return PKGMGR_R_EINVAL;
1499 if (client->pc_type != PC_LISTENING) {
1500 ERR("client->pc_type is not PC_LISTENING");
1501 return PKGMGR_R_EINVAL;
1504 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1505 if (cb_info == NULL)
1506 return PKGMGR_R_ENOMEM;
1507 cb_info->status_type = client->status_type;
1508 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1509 if (ret != PKGMGR_R_OK) {
1510 __free_cb_info(cb_info);
1513 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1515 return cb_info->req_id;
1518 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1519 pkgmgr_app_handler app_event_cb, void *data)
1522 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1523 struct cb_info *cb_info;
1525 if (pc == NULL || app_event_cb == NULL) {
1526 ERR("invalid parameter");
1527 return PKGMGR_R_EINVAL;
1530 if (client->pc_type != PC_LISTENING) {
1531 ERR("client->pc_type is not PC_LISTENING");
1532 return PKGMGR_R_EINVAL;
1535 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1536 if (cb_info == NULL)
1537 return PKGMGR_R_ENOMEM;
1538 cb_info->status_type = client->status_type;
1539 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1540 if (ret != PKGMGR_R_OK) {
1541 __free_cb_info(cb_info);
1544 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1546 return cb_info->req_id;
1549 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1551 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1554 struct cb_info *cb_info;
1557 ERR("invalid parameter");
1558 return PKGMGR_R_EINVAL;
1561 /* unset all callback */
1562 tmp = client->cb_info_list;
1563 while (tmp != NULL) {
1565 cb_info = (struct cb_info *)tmp->data;
1566 pkgmgr_client_connection_unset_callback(pc, cb_info);
1567 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1569 __free_cb_info(cb_info);
1576 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1577 const char *pkgid, const char *key, const char *val)
1579 /* client cannot broadcast signal */
1583 /* TODO: deprecate(or remove) */
1584 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1585 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1586 const char *pkgid, const char *custom_info,
1587 pkgmgr_handler event_cb, void *data)
1589 return pkgmgr_client_usr_request_service(service_type, service_mode,
1590 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1594 API int pkgmgr_client_usr_request_service(
1595 pkgmgr_request_service_type service_type, int service_mode,
1596 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1597 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1602 /* Check for NULL value of service type */
1603 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1604 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1606 switch (service_type) {
1607 case PM_REQUEST_MOVE:
1608 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1609 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1610 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1612 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1615 case PM_REQUEST_GET_SIZE:
1616 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1617 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1618 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1620 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1623 case PM_REQUEST_KILL_APP:
1624 case PM_REQUEST_CHECK_APP:
1625 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1626 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1628 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1630 ERR("__check_app_process fail \n");
1637 ERR("Wrong Request\n");
1648 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1651 struct pkgmgr_client *client;
1653 client = pkgmgr_client_new(PC_REQUEST);
1654 if (client == NULL) {
1655 ERR("out of memory");
1656 return PKGMGR_R_ENOMEM;
1659 ret = __request_size_info(client, uid);
1661 ERR("__request_size_info fail");
1663 pkgmgr_client_free(client);
1667 API int pkgmgr_client_request_size_info(void)
1669 /* get all package size (data, total) */
1670 return pkgmgr_client_usr_request_size_info(_getuid());
1673 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1677 struct pkgmgr_client_t *client;
1679 if (pkgid == NULL || uid == GLOBAL_USER) {
1680 ERR("invalid parameter");
1681 return PKGMGR_R_EINVAL;
1684 client = pkgmgr_client_new(PC_REQUEST);
1685 if (client == NULL) {
1686 ERR("out of memory");
1687 return PKGMGR_R_ENOMEM;
1690 ret = pkgmgr_client_connection_send_request(client, "clearcache",
1691 g_variant_new("(us)", uid, pkgid), &result);
1692 if (ret != PKGMGR_R_OK) {
1693 ERR("request failed: %d", ret);
1697 g_variant_get(result, "(i)", &ret);
1698 g_variant_unref(result);
1703 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1705 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1708 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1710 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1713 API int pkgmgr_client_clear_all_cache_dir(void)
1715 return pkgmgr_client_usr_clear_cache_dir(
1716 PKG_CLEAR_ALL_CACHE, _getuid());
1719 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1720 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1723 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1727 /* TODO: deprecate(or remove) */
1728 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1729 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1730 void *data, uid_t uid)
1733 int ret = PKGMGR_R_ECOMM;
1734 char *req_key = NULL;
1735 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1736 struct cb_info *cb_info;
1738 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1739 ERR("invalid parameter");
1740 return PKGMGR_R_EINVAL;
1743 if (client->pc_type != PC_REQUEST) {
1744 ERR("client->pc_type is not PC_REQUEST");
1745 return PKGMGR_R_EINVAL;
1749 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1750 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1752 get_type = PM_GET_PKG_SIZE_INFO;
1754 ret = pkgmgr_client_connection_send_request(client, "getsize",
1755 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1756 if (ret != PKGMGR_R_OK) {
1757 ERR("request failed: %d", ret);
1761 g_variant_get(result, "(i&s)", &ret, &req_key);
1762 if (req_key == NULL) {
1763 g_variant_unref(result);
1764 return PKGMGR_R_ECOMM;
1766 if (ret != PKGMGR_R_OK) {
1767 g_variant_unref(result);
1771 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1772 if (cb_info == NULL) {
1773 g_variant_unref(result);
1774 return PKGMGR_R_ENOMEM;
1776 g_variant_unref(result);
1777 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1778 if (ret != PKGMGR_R_OK) {
1779 __free_cb_info(cb_info);
1782 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1787 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1788 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1789 void *user_data, uid_t uid)
1792 int ret = PKGMGR_R_ECOMM;
1793 char *req_key = NULL;
1795 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1796 struct cb_info *cb_info;
1798 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1799 ERR("invalid parameter");
1800 return PKGMGR_R_EINVAL;
1803 if (client->pc_type != PC_REQUEST) {
1804 ERR("client->pc_type is not PC_REQUEST");
1805 return PKGMGR_R_EINVAL;
1808 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1809 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1811 get_type = PM_GET_PKG_SIZE_INFO;
1813 ret = pkgmgr_client_connection_send_request(client, "getsize",
1814 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1815 if (ret != PKGMGR_R_OK) {
1816 ERR("request failed: %d", ret);
1820 g_variant_get(result, "(i&s)", &ret, &req_key);
1821 if (req_key == NULL) {
1822 g_variant_unref(result);
1823 return PKGMGR_R_ECOMM;
1825 if (ret != PKGMGR_R_OK) {
1826 g_variant_unref(result);
1830 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1832 if (cb_info == NULL) {
1833 g_variant_unref(result);
1834 return PKGMGR_R_ENOMEM;
1836 g_variant_unref(result);
1837 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1838 if (ret != PKGMGR_R_OK) {
1839 __free_cb_info(cb_info);
1842 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1847 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1848 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1851 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1852 user_data, _getuid());
1855 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1856 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1857 void *user_data, uid_t uid)
1858 { /* total package size info */
1859 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1860 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1864 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1865 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1867 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1868 (pkgmgr_pkg_size_info_receive_cb)event_cb,
1869 user_data, _getuid());
1872 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1873 const char *resp_data, char **req_data, char **license_url)
1879 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1881 if (pc == NULL || resp_data == NULL || req_data == NULL ||
1882 license_url == NULL) {
1883 ERR("invalid parameter");
1884 return PKGMGR_R_EINVAL;
1887 if (client->pc_type != PC_REQUEST) {
1888 ERR("client->pc_type is not PC_REQUEST");
1889 return PKGMGR_R_EINVAL;
1892 ret = pkgmgr_client_connection_send_request(client,
1893 "generate_license_request",
1894 g_variant_new("(s)", resp_data), &result);
1895 if (ret != PKGMGR_R_OK) {
1896 ERR("request failed: %d", ret);
1900 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1901 if (ret != PKGMGR_R_OK) {
1902 ERR("generate_license_request failed: %d", ret);
1903 g_variant_unref(result);
1907 *req_data = strdup(data);
1908 *license_url = strdup(url);
1910 g_variant_unref(result);
1915 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1919 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1921 if (pc == NULL || resp_data == NULL) {
1922 ERR("invalid parameter");
1923 return PKGMGR_R_EINVAL;
1926 if (client->pc_type != PC_REQUEST) {
1927 ERR("client->pc_type is not PC_REQUEST");
1928 return PKGMGR_R_EINVAL;
1931 ret = pkgmgr_client_connection_send_request(client, "register_license",
1932 g_variant_new("(s)", resp_data), &result);
1933 if (ret != PKGMGR_R_OK) {
1934 ERR("request failed: %d", ret);
1938 g_variant_get(result, "(i)", &ret);
1939 g_variant_unref(result);
1940 if (ret != PKGMGR_R_OK)
1941 ERR("register license failed: %d", ret);
1946 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1947 const char *drm_file_path, const char *decrypted_file_path)
1951 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1953 if (pc == NULL || drm_file_path == NULL ||
1954 decrypted_file_path == NULL) {
1955 ERR("invalid parameter");
1956 return PKGMGR_R_EINVAL;
1959 if (client->pc_type != PC_REQUEST) {
1960 ERR("client->pc_type is not PC_REQUEST");
1961 return PKGMGR_R_EINVAL;
1964 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1965 g_variant_new("(ss)", drm_file_path,
1966 decrypted_file_path), &result);
1967 if (ret != PKGMGR_R_OK) {
1968 ERR("request failed: %d", ret);
1972 g_variant_get(result, "(i)", &ret);
1973 g_variant_unref(result);
1974 if (ret != PKGMGR_R_OK)
1975 ERR("decrypt_package failed: %d", ret);
1980 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1982 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1985 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1986 const char *appid, uid_t uid)
1990 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1992 if (pc == NULL || appid == NULL) {
1993 ERR("Invalid parameter");
1994 return PKGMGR_R_EINVAL;
1997 ret = pkgmgr_client_connection_send_request(client,
1998 "enable_app_splash_screen",
1999 g_variant_new("(us)", uid, appid), &result);
2000 if (ret != PKGMGR_R_OK) {
2001 ERR("request failed: %d", ret);
2005 g_variant_get(result, "(i)", &ret);
2006 g_variant_unref(result);
2007 if (ret != PKGMGR_R_OK)
2008 ERR("enable splash screen failed: %d", ret);
2013 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2016 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2020 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2021 const char *appid, uid_t uid)
2025 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2027 if (pc == NULL || appid == NULL) {
2028 ERR("Invalid parameter");
2029 return PKGMGR_R_EINVAL;
2032 ret = pkgmgr_client_connection_send_request(client,
2033 "disable_app_splash_screen",
2034 g_variant_new("(us)", uid, appid), &result);
2035 if (ret != PKGMGR_R_OK) {
2036 ERR("request failed: %d", ret);
2040 g_variant_get(result, "(i)", &ret);
2041 g_variant_unref(result);
2042 if (ret != PKGMGR_R_OK)
2043 ERR("disable splash screen failed: %d", ret);
2048 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2049 int mode, uid_t uid)
2052 int ret = PKGMGR_R_ECOMM;
2053 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2055 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2056 ERR("invalid parameter");
2057 return PKGMGR_R_EINVAL;
2060 ret = pkgmgr_client_connection_send_request(client,
2061 "set_restriction_mode",
2062 g_variant_new("(usi)", uid, pkgid, mode), &result);
2063 if (ret != PKGMGR_R_OK) {
2064 ERR("request failed: %d", ret);
2068 g_variant_get(result, "(i)", &ret);
2069 g_variant_unref(result);
2074 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2075 const char *pkgid, int mode, uid_t uid)
2077 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2080 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2081 const char *pkgid, int mode)
2083 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2087 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2088 int mode, uid_t uid)
2091 int ret = PKGMGR_R_ECOMM;
2092 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2094 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2095 ERR("invalid parameter");
2096 return PKGMGR_R_EINVAL;
2099 ret = pkgmgr_client_connection_send_request(client,
2100 "unset_restriction_mode",
2101 g_variant_new("(usi)", uid, pkgid, mode), &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);
2114 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2115 const char *pkgid, int mode, uid_t uid)
2117 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2120 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2121 const char *pkgid, int mode)
2123 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2127 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2128 int *mode, uid_t uid)
2131 int ret = PKGMGR_R_ECOMM;
2133 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2135 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2136 ERR("invalid parameter");
2137 return PKGMGR_R_EINVAL;
2140 ret = pkgmgr_client_connection_send_request(client,
2141 "get_restriction_mode",
2142 g_variant_new("(us)", uid, pkgid), &result);
2143 if (ret != PKGMGR_R_OK) {
2144 ERR("request failed: %d", ret);
2148 g_variant_get(result, "(ii)", &m, &ret);
2149 g_variant_unref(result);
2150 if (ret != PKGMGR_R_OK)
2158 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2159 const char *pkgid, int *mode, uid_t uid)
2161 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2164 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2165 const char *pkgid, int *mode)
2167 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2171 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2175 int ret = PKGMGR_R_ECOMM;
2176 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2179 ERR("invalid parameter");
2180 return PKGMGR_R_EINVAL;
2183 ret = pkgmgr_client_connection_send_request(client,
2184 "set_restriction_mode",
2185 g_variant_new("(usi)", uid, "", mode), &result);
2186 if (ret != PKGMGR_R_OK) {
2187 ERR("request failed: %d", ret);
2191 g_variant_get(result, "(i)", &ret);
2192 g_variant_unref(result);
2197 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2199 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2202 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2206 int ret = PKGMGR_R_ECOMM;
2207 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2210 ERR("invalid parameter");
2211 return PKGMGR_R_EINVAL;
2214 ret = pkgmgr_client_connection_send_request(client,
2215 "unset_restriction_mode",
2216 g_variant_new("(usi)", uid, "", mode), &result);
2217 if (ret != PKGMGR_R_OK) {
2218 ERR("request failed: %d", ret);
2222 g_variant_get(result, "(i)", &ret);
2223 g_variant_unref(result);
2228 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2230 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2233 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2234 int *mode, uid_t uid)
2237 int ret = PKGMGR_R_ECOMM;
2239 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2242 ERR("invalid parameter");
2243 return PKGMGR_R_EINVAL;
2246 ret = pkgmgr_client_connection_send_request(client,
2247 "get_restriction_mode",
2248 g_variant_new("(us)", uid, ""), &result);
2249 if (ret != PKGMGR_R_OK) {
2250 ERR("request failed: %d", ret);
2254 g_variant_get(result, "(ii)", &m, &ret);
2255 g_variant_unref(result);
2256 if (ret != PKGMGR_R_OK)
2264 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2266 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2269 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2272 pkg_plugin_set *plugin_set;
2273 package_manager_pkg_detail_info_t *info;
2276 if (pkg_path == NULL) {
2277 ERR("invalid parameter");
2281 pkg_type = __get_type_from_path(pkg_path);
2282 if (pkg_type == NULL) {
2283 ERR("cannot get pkg type");
2287 plugin_set = _package_manager_load_library(pkg_type);
2288 if (plugin_set == NULL) {
2289 ERR("failed to load library for %s", pkg_type);
2294 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2296 ERR("out of memory");
2301 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2303 ERR("get_pkg_detail_info_from_package failed");
2311 return (pkgmgr_info *)info;
2314 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2316 package_manager_pkg_detail_info_t *pkg_info =
2317 (package_manager_pkg_detail_info_t *)info;
2320 ERR("invalid parameter");
2321 return PKGMGR_R_EINVAL;
2324 g_list_free_full(pkg_info->privilege_list, free);
2325 free(pkg_info->icon_buf);
2331 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2332 char *label, uid_t uid)
2336 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2338 if (pc == NULL || appid == NULL || label == NULL) {
2339 ERR("Invalid parameter");
2340 return PKGMGR_R_EINVAL;
2343 ret = pkgmgr_client_connection_send_request(client,
2345 g_variant_new("(uss)", uid, appid, label), &result);
2346 if (ret != PKGMGR_R_OK) {
2347 ERR("Request failed: %d", ret);
2351 g_variant_get(result, "(i)", &ret);
2352 g_variant_unref(result);
2357 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2359 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2362 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2364 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2367 ERR("invalid parameter");
2368 return PKGMGR_R_EINVAL;
2371 client->debug_mode = debug_mode;
2376 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2377 const char *pkgid, uid_t uid)
2380 int ret = PKGMGR_R_ECOMM;
2381 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2384 ERR("invalid parameter");
2385 return PKGMGR_R_EINVAL;
2388 ret = pkgmgr_client_connection_send_request(client,
2389 "migrate_external_image",
2390 g_variant_new("(us)", uid, pkgid), &result);
2391 if (ret != PKGMGR_R_OK) {
2392 ERR("request failed: %d", ret);
2396 g_variant_get(result, "(i)", &ret);
2397 g_variant_unref(result);