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 gboolean __free_cb_info_at_main_thread(gpointer user_data)
156 struct cb_info *cb_info = (struct cb_info *)user_data;
157 g_list_free(cb_info->sid_list);
158 free(cb_info->req_key);
161 return G_SOURCE_REMOVE;
164 static void __free_cb_info(struct cb_info *cb_info)
166 g_idle_add(__free_cb_info_at_main_thread, cb_info);
169 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
170 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
174 int ret = PKGMGR_R_ECOMM;
175 long long size_info = 0;
176 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
178 if (pc == NULL || pkgid == NULL) {
179 ERR("invalid parameter");
180 return PKGMGR_R_EINVAL;
183 if (client->pc_type != PC_REQUEST) {
184 ERR("client->pc_type is not PC_REQUEST");
185 return PKGMGR_R_EINVAL;
188 ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
189 g_variant_new("(usi)", uid, pkgid, get_type), &result);
190 if (ret != PKGMGR_R_OK) {
191 ERR("request failed: %d", ret);
195 g_variant_get(result, "(ix)", &ret, &size_info);
196 if (ret != PKGMGR_R_OK) {
197 ERR("request result failed: %d", ret);
198 g_variant_unref(result);
203 ERR("invalid size_info=(%lld)", size_info);
206 ret = (int)size_info;
207 DBG("size_info(%lld), return size(%d)", size_info, ret);
210 g_variant_unref(result);
215 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
216 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
217 pkgmgr_handler event_cb, void *data)
221 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
223 ERR("move request failed");
230 static int __check_app_process(pkgmgr_request_service_type service_type,
231 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
234 int ret = PKGMGR_R_ECOMM;
235 pkgmgrinfo_pkginfo_h handle;
237 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
239 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
241 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
242 if (ret != PMINFO_R_OK) {
243 ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
244 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
245 return PKGMGR_R_ERROR;
248 if (service_type == PM_REQUEST_KILL_APP) {
249 ret = pkgmgr_client_connection_send_request(client, "kill",
250 g_variant_new("(us)", uid, pkgid), &result);
251 } else if (service_type == PM_REQUEST_CHECK_APP) {
252 ret = pkgmgr_client_connection_send_request(client, "check",
253 g_variant_new("(us)", uid, pkgid), &result);
255 ERR("unexpected service type: %d", service_type);
256 ret = PKGMGR_R_ERROR;
259 if (ret != PKGMGR_R_OK) {
260 ERR("request failed: %d", ret);
264 g_variant_get(result, "(ii)", &ret, &pid);
265 g_variant_unref(result);
266 if (ret != PKGMGR_R_OK) {
267 ERR("request failed, ret=%d", ret);
273 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
279 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
281 struct pkgmgr_client_t *client;
283 if (pc_type == PC_BROADCAST) {
284 ERR("broadcast type is not supported");
288 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
289 ERR("invalid parameter");
293 client = calloc(1, sizeof(struct pkgmgr_client_t));
294 if (client == NULL) {
295 ERR("out of memory");
299 client->pc_type = pc_type;
300 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
302 if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) {
307 return (pkgmgr_client *)client;
310 API int pkgmgr_client_free(pkgmgr_client *pc)
312 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
315 ERR("invalid argument");
316 return PKGMGR_R_EINVAL;
319 pkgmgr_client_remove_listen_status(client);
320 pkgmgr_client_connection_disconnect(client);
321 if (client->tep_path)
322 free(client->tep_path);
328 struct manifest_and_type type_map[] = {
329 { "res/wgt/config.xml", "wgt" },
330 { "config.xml", "wgt" },
331 { "tizen-manifest.xml", "tpk" },
335 static char *__get_type_from_path(const char *pkg_path)
337 const char *type = NULL;
341 uf = unzOpen(pkg_path);
343 ERR("failed to open zip file %s", pkg_path);
347 for (i = 0; type_map[i].manifest != NULL; i++) {
348 if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
349 DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
350 type = type_map[i].type;
356 return type ? strdup(type) : NULL;
359 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
362 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
364 if (pc == NULL || tep_path == NULL) {
365 ERR("invalied parameter");
366 return PKGMGR_R_EINVAL;
369 if (client->tep_path)
370 free(client->tep_path);
372 client->tep_path = strdup(tep_path);
373 client->tep_move = tep_move;
378 API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
379 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
380 void *data, uid_t uid)
383 GVariantBuilder *pkgs_builder;
385 GVariantBuilder *args_builder;
388 char *req_key = NULL;
389 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
390 struct cb_info *cb_info;
393 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
394 ERR("invalid parameter");
395 return PKGMGR_R_EINVAL;
398 if (client->pc_type != PC_REQUEST) {
399 ERR("client type is not PC_REQUEST");
400 return PKGMGR_R_EINVAL;
403 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
404 for (i = 0; i < n_pkgs; i++)
405 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
406 pkgs = g_variant_new("as", pkgs_builder);
407 g_variant_builder_unref(pkgs_builder);
409 args_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
410 if (client->debug_mode)
411 g_variant_builder_add(args_builder, "s", "-G");
412 if (client->skip_optimization)
413 g_variant_builder_add(args_builder, "s", "-S");
414 args = g_variant_new("as", args_builder);
415 g_variant_builder_unref(args_builder);
417 ret = pkgmgr_client_connection_send_request(client, "install_pkgs",
418 g_variant_new("(u@as@as)", uid, pkgs, args), &result);
419 if (ret != PKGMGR_R_OK) {
420 ERR("request failed: %d", ret);
424 g_variant_get(result, "(i&s)", &ret, &req_key);
425 if (req_key == NULL) {
426 g_variant_unref(result);
427 return PKGMGR_R_ECOMM;
429 if (ret != PKGMGR_R_OK) {
430 g_variant_unref(result);
434 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
435 if (cb_info == NULL) {
436 g_variant_unref(result);
437 return PKGMGR_R_ERROR;
439 g_variant_unref(result);
440 ret = pkgmgr_client_connection_set_callback(client, cb_info);
441 if (ret != PKGMGR_R_OK) {
442 __free_cb_info(cb_info);
445 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
447 return cb_info->req_id;
450 API int pkgmgr_client_install_packages(pkgmgr_client *pc,
451 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
454 return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
455 event_cb, data, _getuid());
458 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
459 const char *descriptor_path, const char *pkg_path,
460 const char *optional_data, pkgmgr_mode mode,
461 pkgmgr_handler event_cb, void *data, uid_t uid)
464 int ret = PKGMGR_R_ECOMM;
465 char *req_key = NULL;
466 GVariantBuilder *builder = NULL;
467 GVariant *args = NULL;
468 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
469 struct cb_info *cb_info;
471 if (pc == NULL || pkg_path == NULL) {
472 ERR("invalid parameter");
473 return PKGMGR_R_EINVAL;
476 if (client->pc_type != PC_REQUEST) {
477 ERR("client type is not PC_REQUEST");
478 return PKGMGR_R_EINVAL;
481 if (access(pkg_path, F_OK) != 0) {
482 ERR("failed to access: %s", pkg_path);
483 return PKGMGR_R_EINVAL;
486 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
487 ERR("failed to access: %s", client->tep_path);
488 return PKGMGR_R_EINVAL;
491 /* build arguments */
492 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
493 if (client->tep_path) {
494 g_variant_builder_add(builder, "s", "-e");
495 g_variant_builder_add(builder, "s", client->tep_path);
496 g_variant_builder_add(builder, "s", "-M");
497 /* TODO: revise tep_move */
498 g_variant_builder_add(builder, "s",
499 client->tep_move ? "tep_move" : "tep_copy");
501 if (client->debug_mode)
502 g_variant_builder_add(builder, "s", "-G");
503 if (client->skip_optimization)
504 g_variant_builder_add(builder, "s", "-S");
506 args = g_variant_new("as", builder);
507 g_variant_builder_unref(builder);
509 ret = pkgmgr_client_connection_send_request(client, "install",
510 g_variant_new("(uss@as)", uid, pkg_type ? pkg_type : "",
513 if (ret != PKGMGR_R_OK) {
514 ERR("request failed: %d", ret);
518 g_variant_get(result, "(i&s)", &ret, &req_key);
519 if (req_key == NULL) {
520 g_variant_unref(result);
521 return PKGMGR_R_ECOMM;
523 if (ret != PKGMGR_R_OK) {
524 g_variant_unref(result);
528 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
529 if (cb_info == NULL) {
530 g_variant_unref(result);
531 return PKGMGR_R_ENOMEM;
533 g_variant_unref(result);
534 ret = pkgmgr_client_connection_set_callback(client, cb_info);
535 if (ret != PKGMGR_R_OK) {
536 __free_cb_info(cb_info);
539 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
541 return cb_info->req_id;
544 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
545 const char *descriptor_path, const char *pkg_path,
546 const char *optional_data, pkgmgr_mode mode,
547 pkgmgr_handler event_cb, void *data)
549 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
550 pkg_path, optional_data, mode, event_cb, data,
554 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
555 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
556 pkgmgr_handler event_cb, void *data)
558 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
559 mode, event_cb, data, _getuid());
562 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
563 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
564 pkgmgr_handler event_cb, void *data, uid_t uid)
567 int ret = PKGMGR_R_ECOMM;
568 char *req_key = NULL;
569 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
570 struct cb_info *cb_info;
572 if (pc == NULL || pkgid == NULL) {
573 ERR("invalid parameter");
574 return PKGMGR_R_EINVAL;
577 if (client->pc_type != PC_REQUEST) {
578 ERR("client->pc_type is not PC_REQUEST");
579 return PKGMGR_R_EINVAL;
582 ret = pkgmgr_client_connection_send_request(client, "reinstall",
583 g_variant_new("(us)", uid, pkgid), &result);
584 if (ret != PKGMGR_R_OK) {
585 ERR("request failed: %d", ret);
589 g_variant_get(result, "(i&s)", &ret, &req_key);
590 if (req_key == NULL) {
591 g_variant_unref(result);
592 return PKGMGR_R_ECOMM;
594 if (ret != PKGMGR_R_OK) {
595 g_variant_unref(result);
599 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
600 if (cb_info == NULL) {
601 g_variant_unref(result);
602 return PKGMGR_R_ENOMEM;
604 g_variant_unref(result);
605 ret = pkgmgr_client_connection_set_callback(client, cb_info);
606 if (ret != PKGMGR_R_OK) {
607 __free_cb_info(cb_info);
610 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
612 return cb_info->req_id;
615 API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
616 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
617 void *data, uid_t uid)
620 GVariantBuilder *pkgs_builder;
622 int ret = PKGMGR_R_ECOMM;
623 char *req_key = NULL;
624 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
625 struct cb_info *cb_info;
628 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
629 ERR("invalid parameter");
630 return PKGMGR_R_EINVAL;
633 if (client->pc_type != PC_REQUEST) {
634 ERR("client->pc_type is not PC_REQUEST");
635 return PKGMGR_R_EINVAL;
638 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
639 for (i = 0; i < n_pkgs; i++)
640 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
641 pkgs = g_variant_new("as", pkgs_builder);
642 g_variant_builder_unref(pkgs_builder);
644 ret = pkgmgr_client_connection_send_request(client,
645 "mount_install_pkgs",
646 g_variant_new("(u@as)", uid, pkgs), &result);
647 if (ret != PKGMGR_R_OK) {
648 ERR("request failed: %d", ret);
652 g_variant_get(result, "(i&s)", &ret, &req_key);
653 if (req_key == NULL) {
654 g_variant_unref(result);
655 return PKGMGR_R_ECOMM;
657 if (ret != PKGMGR_R_OK) {
658 g_variant_unref(result);
662 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
663 if (cb_info == NULL) {
664 g_variant_unref(result);
665 return PKGMGR_R_ENOMEM;
667 g_variant_unref(result);
668 ret = pkgmgr_client_connection_set_callback(client, cb_info);
669 if (ret != PKGMGR_R_OK) {
670 __free_cb_info(cb_info);
673 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
675 return cb_info->req_id;
678 API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
679 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
682 return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
683 event_cb, data, _getuid());
686 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
687 const char *descriptor_path, const char *pkg_path,
688 const char *optional_data, pkgmgr_mode mode,
689 pkgmgr_handler event_cb, void *data, uid_t uid)
692 int ret = PKGMGR_R_ECOMM;
693 char *req_key = NULL;
694 GVariantBuilder *builder = NULL;
695 GVariant *args = NULL;
696 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
697 struct cb_info *cb_info;
699 if (pc == NULL || pkg_path == NULL) {
700 ERR("invalid parameter");
701 return PKGMGR_R_EINVAL;
704 if (client->pc_type != PC_REQUEST) {
705 ERR("client->pc_type is not PC_REQUEST");
706 return PKGMGR_R_EINVAL;
709 if (access(pkg_path, F_OK) != 0) {
710 ERR("failed to access: %s", pkg_path);
711 return PKGMGR_R_EINVAL;
714 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
715 ERR("failed to access: %s", client->tep_path);
716 return PKGMGR_R_EINVAL;
719 /* build arguments */
720 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
721 if (client->tep_path) {
722 g_variant_builder_add(builder, "s", "-e");
723 g_variant_builder_add(builder, "s", client->tep_path);
724 g_variant_builder_add(builder, "s", "-M");
725 /* TODO: revise tep_move */
726 g_variant_builder_add(builder, "s",
727 client->tep_move ? "tep_move" : "tep_copy");
730 args = g_variant_new("as", builder);
731 g_variant_builder_unref(builder);
733 ret = pkgmgr_client_connection_send_request(client, "mount_install",
734 g_variant_new("(uss@as)", uid, pkg_type ? pkg_type : "",
737 if (ret != PKGMGR_R_OK) {
738 ERR("request failed: %d", ret);
742 g_variant_get(result, "(i&s)", &ret, &req_key);
743 if (req_key == NULL) {
744 g_variant_unref(result);
745 return PKGMGR_R_ECOMM;
747 if (ret != PKGMGR_R_OK) {
748 g_variant_unref(result);
752 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
753 if (cb_info == NULL) {
754 g_variant_unref(result);
755 return PKGMGR_R_ENOMEM;
757 g_variant_unref(result);
758 ret = pkgmgr_client_connection_set_callback(client, cb_info);
759 if (ret != PKGMGR_R_OK) {
760 __free_cb_info(cb_info);
763 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
765 return cb_info->req_id;
768 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
769 const char *descriptor_path, const char *pkg_path,
770 const char *optional_data, pkgmgr_mode mode,
771 pkgmgr_handler event_cb, void *data)
773 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
774 pkg_path, optional_data, mode, event_cb, data,
778 API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
779 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
780 void *data, uid_t uid)
783 GVariantBuilder *pkgs_builder;
785 int ret = PKGMGR_R_ECOMM;
786 char *req_key = NULL;
787 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
788 struct cb_info *cb_info;
791 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
792 ERR("invalid parameter");
793 return PKGMGR_R_EINVAL;
796 if (client->pc_type != PC_REQUEST) {
797 ERR("client->pc_type is not PC_REQUEST");
798 return PKGMGR_R_EINVAL;
801 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
802 for (i = 0; i < n_pkgs; i++)
803 g_variant_builder_add(pkgs_builder, "s", pkgids[i]);
804 pkgs = g_variant_new("as", pkgs_builder);
805 g_variant_builder_unref(pkgs_builder);
807 ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs",
808 g_variant_new("(u@as)", uid, pkgs), &result);
809 if (ret != PKGMGR_R_OK) {
810 ERR("request failed: %d", ret);
814 g_variant_get(result, "(i&s)", &ret, &req_key);
815 if (req_key == NULL) {
816 g_variant_unref(result);
817 return PKGMGR_R_ECOMM;
819 if (ret != PKGMGR_R_OK) {
820 g_variant_unref(result);
824 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
825 if (cb_info == NULL) {
826 g_variant_unref(result);
827 return PKGMGR_R_ENOMEM;
829 g_variant_unref(result);
830 ret = pkgmgr_client_connection_set_callback(client, cb_info);
831 if (ret != PKGMGR_R_OK) {
832 __free_cb_info(cb_info);
835 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
837 return cb_info->req_id;
840 API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
841 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
844 return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
845 event_cb, data, _getuid());
848 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
849 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
852 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
856 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
857 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
858 void *data, uid_t uid)
861 int ret = PKGMGR_R_ECOMM;
862 char *req_key = NULL;
863 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
864 struct cb_info *cb_info;
866 if (pc == NULL || pkgid == NULL) {
867 ERR("invalid parameter");
868 return PKGMGR_R_EINVAL;
871 if (client->pc_type != PC_REQUEST) {
872 ERR("client->pc_type is not PC_REQUEST");
873 return PKGMGR_R_EINVAL;
876 ret = pkgmgr_client_connection_send_request(client, "uninstall",
877 g_variant_new("(us)", uid, pkgid), &result);
878 if (ret != PKGMGR_R_OK) {
879 ERR("request failed: %d", ret);
883 g_variant_get(result, "(i&s)", &ret, &req_key);
884 if (req_key == NULL) {
885 g_variant_unref(result);
886 return PKGMGR_R_ECOMM;
888 if (ret != PKGMGR_R_OK) {
889 g_variant_unref(result);
893 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
894 if (cb_info == NULL) {
895 g_variant_unref(result);
896 return PKGMGR_R_ENOMEM;
898 g_variant_unref(result);
899 ret = pkgmgr_client_connection_set_callback(client, cb_info);
900 if (ret != PKGMGR_R_OK) {
901 __free_cb_info(cb_info);
904 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
906 return cb_info->req_id;
909 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
910 const char *pkgid, pkgmgr_move_type move_type,
911 pkgmgr_handler event_cb, void *data)
913 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
914 event_cb, data, _getuid());
916 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
917 const char *pkgid, pkgmgr_move_type move_type,
918 pkgmgr_handler event_cb, void *data, uid_t uid)
921 int ret = PKGMGR_R_ECOMM;
922 char *req_key = NULL;
923 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
924 struct cb_info *cb_info;
926 if (pc == NULL || pkgid == NULL) {
927 ERR("invalid parameter");
928 return PKGMGR_R_EINVAL;
931 if ((move_type < PM_MOVE_TO_INTERNAL) ||
932 (move_type > PM_MOVE_TO_EXTENDED))
933 return PKGMGR_R_EINVAL;
935 if (client->pc_type != PC_REQUEST) {
936 ERR("client->pc_type is not PC_REQUEST");
937 return PKGMGR_R_EINVAL;
940 ret = pkgmgr_client_connection_send_request(client, "move",
941 g_variant_new("(usi)", uid, pkgid, move_type), &result);
942 if (ret != PKGMGR_R_OK) {
943 ERR("request failed: %d", ret);
947 g_variant_get(result, "(i&s)", &ret, &req_key);
948 if (req_key == NULL) {
949 g_variant_unref(result);
950 return PKGMGR_R_ECOMM;
952 if (ret != PKGMGR_R_OK) {
953 g_variant_unref(result);
957 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
958 if (cb_info == NULL) {
959 g_variant_unref(result);
960 return PKGMGR_R_ERROR;
962 g_variant_unref(result);
963 ret = pkgmgr_client_connection_set_callback(client, cb_info);
964 if (ret != PKGMGR_R_OK) {
965 __free_cb_info(cb_info);
968 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
970 return cb_info->req_id;
973 API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
974 pkg_update_info_t *update_info, uid_t uid)
977 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
980 if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
981 ERR("invalid parameter");
982 return PKGMGR_R_EINVAL;
985 if (client->pc_type != PC_REQUEST) {
986 ERR("client->pc_type is not PC_REQUEST");
987 return PKGMGR_R_EINVAL;
990 ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
991 g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
992 update_info->type), &result);
993 if (ret != PKGMGR_R_OK) {
994 ERR("request failed: %d", ret);
998 g_variant_get(result, "(i)", &ret);
999 if (ret != PKGMGR_R_OK) {
1000 g_variant_unref(result);
1003 g_variant_unref(result);
1008 API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
1009 pkg_update_info_t *update_info)
1011 return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
1015 API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
1016 const char *pkgid, uid_t uid)
1019 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1022 if (pc == NULL || pkgid == NULL) {
1023 ERR("invalid parameter");
1024 return PKGMGR_R_EINVAL;
1027 if (client->pc_type != PC_REQUEST) {
1028 ERR("client->pc_type is not PC_REQUEST");
1029 return PKGMGR_R_EINVAL;
1032 ret = pkgmgr_client_connection_send_request(client,
1033 "unregister_pkg_update_info",
1034 g_variant_new("(us)", uid, pkgid), &result);
1035 if (ret != PKGMGR_R_OK) {
1036 ERR("request failed: %d", ret);
1040 g_variant_get(result, "(i)", &ret);
1041 if (ret != PKGMGR_R_OK) {
1042 g_variant_unref(result);
1045 g_variant_unref(result);
1050 API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
1053 return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
1056 API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
1060 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1064 ERR("invalid parameter");
1065 return PKGMGR_R_EINVAL;
1068 if (client->pc_type != PC_REQUEST) {
1069 ERR("client->pc_type is not PC_REQUEST");
1070 return PKGMGR_R_EINVAL;
1073 ret = pkgmgr_client_connection_send_request(client,
1074 "unregister_all_pkg_update_info",
1075 g_variant_new("(u)", uid), &result);
1076 if (ret != PKGMGR_R_OK) {
1077 ERR("request failed: %d", ret);
1081 g_variant_get(result, "(i)", &ret);
1082 if (ret != PKGMGR_R_OK) {
1083 g_variant_unref(result);
1086 g_variant_unref(result);
1091 API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
1093 return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
1096 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1097 const char *pkgid, uid_t uid)
1100 int ret = PKGMGR_R_ECOMM;
1101 GVariantBuilder *builder;
1102 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1104 if (pc == NULL || pkgid == NULL) {
1105 ERR("invalid parameter");
1106 return PKGMGR_R_EINVAL;
1109 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1110 g_variant_builder_add(builder, "s", pkgid);
1112 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1113 g_variant_new("(uas)", uid, builder), &result);
1114 g_variant_builder_unref(builder);
1115 if (ret != PKGMGR_R_OK) {
1116 ERR("request failed: %d", ret);
1120 g_variant_get(result, "(is)", &ret, NULL);
1121 g_variant_unref(result);
1126 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1129 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
1132 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
1133 const char *pkg_type, const char **pkgids, int n_pkgs,
1134 pkgmgr_handler event_cb, void *data, uid_t uid)
1137 GVariantBuilder *builder;
1138 int ret = PKGMGR_R_ECOMM;
1139 char *req_key = NULL;
1140 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1141 struct cb_info *cb_info;
1144 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1145 ERR("invalid parameter");
1146 return PKGMGR_R_EINVAL;
1149 if (client->pc_type != PC_REQUEST) {
1150 ERR("client type is not PC_REQUEST");
1151 return PKGMGR_R_EINVAL;
1154 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1155 for (i = 0; i < n_pkgs; i++)
1156 g_variant_builder_add(builder, "s", pkgids[i]);
1158 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1159 g_variant_new("(uas)", uid, builder), &result);
1160 g_variant_builder_unref(builder);
1161 if (ret != PKGMGR_R_OK) {
1162 ERR("request failed: %d", ret);
1166 g_variant_get(result, "(i&s)", &ret, &req_key);
1167 if (req_key == NULL) {
1168 g_variant_unref(result);
1169 return PKGMGR_R_ECOMM;
1171 if (ret != PKGMGR_R_OK) {
1172 g_variant_unref(result);
1176 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1177 if (cb_info == NULL) {
1178 g_variant_unref(result);
1179 return PKGMGR_R_ERROR;
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);
1189 return cb_info->req_id;
1192 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
1193 const char *pkg_type, const char **pkgids, int n_pkgs,
1194 pkgmgr_handler event_cb, void *data)
1196 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
1197 pkgids, n_pkgs, event_cb, data, _getuid());
1200 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1201 const char *pkgid, uid_t uid)
1204 GVariantBuilder *builder;
1205 int ret = PKGMGR_R_ECOMM;
1206 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1208 if (pc == NULL || pkgid == NULL) {
1209 ERR("invalid parameter");
1210 return PKGMGR_R_EINVAL;
1213 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1214 g_variant_builder_add(builder, "s", pkgid);
1216 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1217 g_variant_new("(uas)", uid, builder), &result);
1218 g_variant_builder_unref(builder);
1219 if (ret != PKGMGR_R_OK) {
1220 ERR("request failed: %d", ret);
1224 g_variant_get(result, "(is)", &ret, NULL);
1225 g_variant_unref(result);
1230 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1233 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1236 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1237 const char *pkg_type, const char **pkgids, int n_pkgs,
1238 pkgmgr_handler event_cb, void *data, uid_t uid)
1241 GVariantBuilder *builder;
1242 int ret = PKGMGR_R_ECOMM;
1243 char *req_key = NULL;
1244 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1245 struct cb_info *cb_info;
1248 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1249 ERR("invalid parameter");
1250 return PKGMGR_R_EINVAL;
1253 if (client->pc_type != PC_REQUEST) {
1254 ERR("client type is not PC_REQUEST");
1255 return PKGMGR_R_EINVAL;
1258 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1259 for (i = 0; i < n_pkgs; i++)
1260 g_variant_builder_add(builder, "s", pkgids[i]);
1262 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1263 g_variant_new("(uas)", uid, builder), &result);
1264 g_variant_builder_unref(builder);
1265 if (ret != PKGMGR_R_OK) {
1266 ERR("request failed: %d", ret);
1270 g_variant_get(result, "(i&s)", &ret, &req_key);
1271 if (req_key == NULL) {
1272 g_variant_unref(result);
1273 return PKGMGR_R_ECOMM;
1275 if (ret != PKGMGR_R_OK) {
1276 g_variant_unref(result);
1280 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1281 if (cb_info == NULL) {
1282 g_variant_unref(result);
1283 return PKGMGR_R_ERROR;
1285 g_variant_unref(result);
1286 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1287 if (ret != PKGMGR_R_OK) {
1288 __free_cb_info(cb_info);
1291 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1293 return cb_info->req_id;
1296 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1297 const char *pkg_type, const char **pkgids, int n_pkgs,
1298 pkgmgr_handler event_cb, void *data)
1300 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1301 pkgids, n_pkgs, event_cb, data, _getuid());
1304 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1305 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1308 int ret = PKGMGR_R_ECOMM;
1309 char *req_key = NULL;
1310 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1311 struct cb_info *cb_info;
1313 if (pc == NULL || appid == NULL) {
1314 ERR("invalid parameter");
1315 return PKGMGR_R_EINVAL;
1318 ret = pkgmgr_client_connection_send_request(client, "enable_app",
1319 g_variant_new("(us)", uid, appid), &result);
1320 if (ret != PKGMGR_R_OK) {
1321 ERR("request failed: %d", ret);
1325 g_variant_get(result, "(i&s)", &ret, &req_key);
1326 if (req_key == NULL) {
1327 g_variant_unref(result);
1328 return PKGMGR_R_ECOMM;
1330 if (ret != PKGMGR_R_OK) {
1331 g_variant_unref(result);
1335 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1337 if (cb_info == NULL) {
1338 g_variant_unref(result);
1339 return PKGMGR_R_ENOMEM;
1341 g_variant_unref(result);
1342 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1343 if (ret != PKGMGR_R_OK) {
1344 __free_cb_info(cb_info);
1347 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1349 return cb_info->req_id;
1352 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1353 pkgmgr_app_handler app_event_cb, void *data)
1355 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1359 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1360 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1363 GVariantBuilder *builder;
1364 int ret = PKGMGR_R_ECOMM;
1365 char *req_key = NULL;
1366 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1367 struct cb_info *cb_info;
1370 if (pc == NULL || appids == NULL || n_apps < 1) {
1371 ERR("invalid parameter");
1372 return PKGMGR_R_EINVAL;
1375 if (client->pc_type != PC_REQUEST) {
1376 ERR("client type is not PC_REQUEST");
1377 return PKGMGR_R_EINVAL;
1380 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1381 for (i = 0; i < n_apps; i++)
1382 g_variant_builder_add(builder, "s", appids[i]);
1384 ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1385 g_variant_new("(uas)", uid, builder), &result);
1386 g_variant_builder_unref(builder);
1387 if (ret != PKGMGR_R_OK) {
1388 ERR("request failed: %d", ret);
1392 g_variant_get(result, "(i&s)", &ret, &req_key);
1393 if (req_key == NULL) {
1394 g_variant_unref(result);
1395 return PKGMGR_R_ECOMM;
1397 if (ret != PKGMGR_R_OK) {
1398 g_variant_unref(result);
1402 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1403 if (cb_info == NULL) {
1404 g_variant_unref(result);
1405 return PKGMGR_R_ERROR;
1407 g_variant_unref(result);
1408 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1409 if (ret != PKGMGR_R_OK) {
1410 __free_cb_info(cb_info);
1413 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1415 return cb_info->req_id;
1418 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1419 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1421 return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1422 app_event_cb, data, _getuid());
1425 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1426 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1429 int ret = PKGMGR_R_ECOMM;
1430 char *req_key = NULL;
1431 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1432 struct cb_info *cb_info;
1434 if (pc == NULL || appid == NULL) {
1435 ERR("invalid parameter");
1436 return PKGMGR_R_EINVAL;
1439 ret = pkgmgr_client_connection_send_request(client,
1440 "enable_global_app_for_uid",
1441 g_variant_new("(us)", uid, appid), &result);
1442 if (ret != PKGMGR_R_OK) {
1443 ERR("request failed: %d", ret);
1447 g_variant_get(result, "(i&s)", &ret, &req_key);
1448 if (req_key == NULL) {
1449 g_variant_unref(result);
1450 return PKGMGR_R_ECOMM;
1452 if (ret != PKGMGR_R_OK) {
1453 g_variant_unref(result);
1457 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1459 if (cb_info == NULL) {
1460 g_variant_unref(result);
1461 return PKGMGR_R_ENOMEM;
1463 g_variant_unref(result);
1464 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1465 if (ret != PKGMGR_R_OK) {
1466 __free_cb_info(cb_info);
1469 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1471 return cb_info->req_id;
1474 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1475 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1478 int ret = PKGMGR_R_ECOMM;
1479 char *req_key = NULL;
1480 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1481 struct cb_info *cb_info;
1483 if (pc == NULL || appid == NULL) {
1484 ERR("invalid parameter");
1485 return PKGMGR_R_EINVAL;
1488 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1489 g_variant_new("(us)", uid, appid), &result);
1490 if (ret != PKGMGR_R_OK) {
1491 ERR("request failed: %d", ret);
1495 g_variant_get(result, "(i&s)", &ret, &req_key);
1496 if (req_key == NULL) {
1497 g_variant_unref(result);
1498 return PKGMGR_R_ECOMM;
1500 if (ret != PKGMGR_R_OK) {
1501 g_variant_unref(result);
1505 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1507 if (cb_info == NULL) {
1508 g_variant_unref(result);
1509 return PKGMGR_R_ENOMEM;
1511 g_variant_unref(result);
1512 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1513 if (ret != PKGMGR_R_OK) {
1514 __free_cb_info(cb_info);
1517 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1519 return cb_info->req_id;
1522 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1523 pkgmgr_app_handler app_event_cb, void *data)
1525 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1529 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1530 const char **appids, int n_apps,
1531 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1534 GVariantBuilder *builder;
1535 int ret = PKGMGR_R_ECOMM;
1536 char *req_key = NULL;
1537 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1538 struct cb_info *cb_info;
1541 if (pc == NULL || appids == NULL || n_apps < 1) {
1542 ERR("invalid parameter");
1543 return PKGMGR_R_EINVAL;
1546 if (client->pc_type != PC_REQUEST) {
1547 ERR("client type is not PC_REQUEST");
1548 return PKGMGR_R_EINVAL;
1551 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1552 for (i = 0; i < n_apps; i++)
1553 g_variant_builder_add(builder, "s", appids[i]);
1555 ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1556 g_variant_new("(uas)", uid, builder), &result);
1557 g_variant_builder_unref(builder);
1558 if (ret != PKGMGR_R_OK) {
1559 ERR("request failed: %d", ret);
1563 g_variant_get(result, "(i&s)", &ret, &req_key);
1564 if (req_key == NULL) {
1565 g_variant_unref(result);
1566 return PKGMGR_R_ECOMM;
1568 if (ret != PKGMGR_R_OK) {
1569 g_variant_unref(result);
1573 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1574 if (cb_info == NULL) {
1575 g_variant_unref(result);
1576 return PKGMGR_R_ERROR;
1578 g_variant_unref(result);
1579 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1580 if (ret != PKGMGR_R_OK) {
1581 __free_cb_info(cb_info);
1584 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1586 return cb_info->req_id;
1589 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1590 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1592 return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1593 app_event_cb, data, _getuid());
1596 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1597 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1600 int ret = PKGMGR_R_ECOMM;
1601 char *req_key = NULL;
1602 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1603 struct cb_info *cb_info;
1605 if (pc == NULL || appid == NULL) {
1606 ERR("invalid parameter");
1607 return PKGMGR_R_EINVAL;
1610 ret = pkgmgr_client_connection_send_request(client,
1611 "disable_global_app_for_uid",
1612 g_variant_new("(us)", uid, appid), &result);
1613 if (ret != PKGMGR_R_OK) {
1614 ERR("request failed: %d", ret);
1618 g_variant_get(result, "(i&s)", &ret, &req_key);
1619 if (req_key == NULL) {
1620 g_variant_unref(result);
1621 return PKGMGR_R_ECOMM;
1623 if (ret != PKGMGR_R_OK) {
1624 g_variant_unref(result);
1628 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1630 if (cb_info == NULL) {
1631 g_variant_unref(result);
1632 return PKGMGR_R_ENOMEM;
1634 g_variant_unref(result);
1635 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1636 if (ret != PKGMGR_R_OK) {
1637 __free_cb_info(cb_info);
1640 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1642 return cb_info->req_id;
1645 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1646 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1651 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1653 if (pc == NULL || appid == NULL || uid == GLOBAL_USER) {
1654 ERR("invalid parameter");
1655 return PKGMGR_R_EINVAL;
1658 if (client->pc_type != PC_REQUEST) {
1659 ERR("client->pc_type is not PC_REQUEST");
1660 return PKGMGR_R_EINVAL;
1663 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1664 g_variant_new("(us)", uid, appid), &result);
1665 if (ret != PKGMGR_R_OK) {
1666 ERR("request failed: %d", ret);
1670 g_variant_get(result, "(i)", &ret);
1671 g_variant_unref(result);
1676 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1677 const char *appid, pkgmgr_mode mode)
1679 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1683 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1685 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1688 ERR("invalid parameter");
1689 return PKGMGR_R_EINVAL;
1692 client->status_type = status_type;
1697 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1701 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1702 struct cb_info *cb_info;
1704 if (pc == NULL || event_cb == NULL) {
1705 ERR("invalid parameter");
1706 return PKGMGR_R_EINVAL;
1709 if (client->pc_type != PC_LISTENING) {
1710 ERR("client->pc_type is not PC_LISTENING");
1711 return PKGMGR_R_EINVAL;
1714 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1715 if (cb_info == NULL)
1716 return PKGMGR_R_ENOMEM;
1717 cb_info->status_type = client->status_type;
1718 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1719 if (ret != PKGMGR_R_OK) {
1720 __free_cb_info(cb_info);
1723 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1725 return cb_info->req_id;
1728 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1729 pkgmgr_app_handler app_event_cb, void *data)
1732 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1733 struct cb_info *cb_info;
1735 if (pc == NULL || app_event_cb == NULL) {
1736 ERR("invalid parameter");
1737 return PKGMGR_R_EINVAL;
1740 if (client->pc_type != PC_LISTENING) {
1741 ERR("client->pc_type is not PC_LISTENING");
1742 return PKGMGR_R_EINVAL;
1745 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1746 if (cb_info == NULL)
1747 return PKGMGR_R_ENOMEM;
1748 cb_info->status_type = client->status_type;
1749 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1750 if (ret != PKGMGR_R_OK) {
1751 __free_cb_info(cb_info);
1754 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1756 return cb_info->req_id;
1759 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1761 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1764 struct cb_info *cb_info;
1767 ERR("invalid parameter");
1768 return PKGMGR_R_EINVAL;
1771 /* unset all callback */
1772 tmp = client->cb_info_list;
1773 while (tmp != NULL) {
1775 cb_info = (struct cb_info *)tmp->data;
1776 pkgmgr_client_connection_unset_callback(pc, cb_info);
1777 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1779 __free_cb_info(cb_info);
1786 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1787 const char *pkgid, const char *key, const char *val)
1789 /* client cannot broadcast signal */
1793 /* TODO: deprecate(or remove) */
1794 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1795 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1796 const char *pkgid, const char *custom_info,
1797 pkgmgr_handler event_cb, void *data)
1799 return pkgmgr_client_usr_request_service(service_type, service_mode,
1800 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1804 API int pkgmgr_client_usr_request_service(
1805 pkgmgr_request_service_type service_type, int service_mode,
1806 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1807 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1812 /* Check for NULL value of service type */
1813 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1814 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1816 switch (service_type) {
1817 case PM_REQUEST_MOVE:
1818 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1819 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1820 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1822 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1825 case PM_REQUEST_GET_SIZE:
1826 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1827 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1828 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1830 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1833 case PM_REQUEST_KILL_APP:
1834 case PM_REQUEST_CHECK_APP:
1835 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1836 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1838 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1840 ERR("__check_app_process fail \n");
1847 ERR("Wrong Request\n");
1857 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1861 struct pkgmgr_client_t *client;
1863 if (pkgid == NULL || uid == GLOBAL_USER) {
1864 ERR("invalid parameter");
1865 return PKGMGR_R_EINVAL;
1868 client = pkgmgr_client_new(PC_REQUEST);
1869 if (client == NULL) {
1870 ERR("out of memory");
1871 return PKGMGR_R_ENOMEM;
1874 ret = pkgmgr_client_connection_send_request(client, "clearcache",
1875 g_variant_new("(us)", uid, pkgid), &result);
1876 if (ret != PKGMGR_R_OK) {
1877 ERR("request failed: %d", ret);
1878 pkgmgr_client_free(client);
1882 g_variant_get(result, "(i)", &ret);
1883 g_variant_unref(result);
1884 pkgmgr_client_free(client);
1889 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1891 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1894 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1896 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1899 API int pkgmgr_client_clear_all_cache_dir(void)
1901 return pkgmgr_client_usr_clear_cache_dir(
1902 PKG_CLEAR_ALL_CACHE, _getuid());
1905 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1906 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1909 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1913 /* TODO: deprecate(or remove) */
1914 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1915 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1916 void *data, uid_t uid)
1919 int ret = PKGMGR_R_ECOMM;
1920 char *req_key = NULL;
1921 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1922 struct cb_info *cb_info;
1924 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1925 ERR("invalid parameter");
1926 return PKGMGR_R_EINVAL;
1929 if (client->pc_type != PC_REQUEST) {
1930 ERR("client->pc_type is not PC_REQUEST");
1931 return PKGMGR_R_EINVAL;
1935 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1936 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1938 get_type = PM_GET_PKG_SIZE_INFO;
1940 ret = pkgmgr_client_connection_send_request(client, "getsize",
1941 g_variant_new("(usi)", uid, pkgid, get_type), &result);
1942 if (ret != PKGMGR_R_OK) {
1943 ERR("request failed: %d", ret);
1947 g_variant_get(result, "(i&s)", &ret, &req_key);
1948 if (req_key == NULL) {
1949 g_variant_unref(result);
1950 return PKGMGR_R_ECOMM;
1952 if (ret != PKGMGR_R_OK) {
1953 g_variant_unref(result);
1957 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1958 if (cb_info == NULL) {
1959 g_variant_unref(result);
1960 return PKGMGR_R_ENOMEM;
1962 g_variant_unref(result);
1963 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1964 if (ret != PKGMGR_R_OK) {
1965 __free_cb_info(cb_info);
1968 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1973 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1974 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1975 void *user_data, uid_t uid)
1978 int ret = PKGMGR_R_ECOMM;
1979 char *req_key = NULL;
1981 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1982 struct cb_info *cb_info;
1984 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1985 ERR("invalid parameter");
1986 return PKGMGR_R_EINVAL;
1989 if (client->pc_type != PC_REQUEST) {
1990 ERR("client->pc_type is not PC_REQUEST");
1991 return PKGMGR_R_EINVAL;
1994 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1995 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1997 get_type = PM_GET_PKG_SIZE_INFO;
1999 ret = pkgmgr_client_connection_send_request(client, "getsize",
2000 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2001 if (ret != PKGMGR_R_OK) {
2002 ERR("request failed: %d", ret);
2006 g_variant_get(result, "(i&s)", &ret, &req_key);
2007 if (req_key == NULL) {
2008 g_variant_unref(result);
2009 return PKGMGR_R_ECOMM;
2011 if (ret != PKGMGR_R_OK) {
2012 g_variant_unref(result);
2016 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2018 if (cb_info == NULL) {
2019 g_variant_unref(result);
2020 return PKGMGR_R_ENOMEM;
2022 g_variant_unref(result);
2023 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2024 if (ret != PKGMGR_R_OK) {
2025 __free_cb_info(cb_info);
2028 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2033 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2034 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2037 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2038 user_data, _getuid());
2041 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2042 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2043 void *user_data, uid_t uid)
2044 { /* total package size info */
2045 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2046 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2050 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2051 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2053 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2054 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2055 user_data, _getuid());
2058 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2059 const char *resp_data, char **req_data, char **license_url)
2065 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2067 if (pc == NULL || resp_data == NULL || req_data == NULL ||
2068 license_url == NULL) {
2069 ERR("invalid parameter");
2070 return PKGMGR_R_EINVAL;
2073 if (client->pc_type != PC_REQUEST) {
2074 ERR("client->pc_type is not PC_REQUEST");
2075 return PKGMGR_R_EINVAL;
2078 ret = pkgmgr_client_connection_send_request(client,
2079 "generate_license_request",
2080 g_variant_new("(s)", resp_data), &result);
2081 if (ret != PKGMGR_R_OK) {
2082 ERR("request failed: %d", ret);
2086 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2087 if (ret != PKGMGR_R_OK) {
2088 ERR("generate_license_request failed: %d", ret);
2089 g_variant_unref(result);
2093 *req_data = strdup(data);
2094 *license_url = strdup(url);
2096 g_variant_unref(result);
2101 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2105 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2107 if (pc == NULL || resp_data == NULL) {
2108 ERR("invalid parameter");
2109 return PKGMGR_R_EINVAL;
2112 if (client->pc_type != PC_REQUEST) {
2113 ERR("client->pc_type is not PC_REQUEST");
2114 return PKGMGR_R_EINVAL;
2117 ret = pkgmgr_client_connection_send_request(client, "register_license",
2118 g_variant_new("(s)", resp_data), &result);
2119 if (ret != PKGMGR_R_OK) {
2120 ERR("request failed: %d", ret);
2124 g_variant_get(result, "(i)", &ret);
2125 g_variant_unref(result);
2126 if (ret != PKGMGR_R_OK)
2127 ERR("register license failed: %d", ret);
2132 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2133 const char *drm_file_path, const char *decrypted_file_path)
2137 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2139 if (pc == NULL || drm_file_path == NULL ||
2140 decrypted_file_path == NULL) {
2141 ERR("invalid parameter");
2142 return PKGMGR_R_EINVAL;
2145 if (client->pc_type != PC_REQUEST) {
2146 ERR("client->pc_type is not PC_REQUEST");
2147 return PKGMGR_R_EINVAL;
2150 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2151 g_variant_new("(ss)", drm_file_path,
2152 decrypted_file_path), &result);
2153 if (ret != PKGMGR_R_OK) {
2154 ERR("request failed: %d", ret);
2158 g_variant_get(result, "(i)", &ret);
2159 g_variant_unref(result);
2160 if (ret != PKGMGR_R_OK)
2161 ERR("decrypt_package failed: %d", ret);
2166 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2168 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2171 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2172 const char *appid, uid_t uid)
2176 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2178 if (pc == NULL || appid == NULL) {
2179 ERR("Invalid parameter");
2180 return PKGMGR_R_EINVAL;
2183 ret = pkgmgr_client_connection_send_request(client,
2184 "enable_app_splash_screen",
2185 g_variant_new("(us)", uid, appid), &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);
2193 if (ret != PKGMGR_R_OK)
2194 ERR("enable splash screen failed: %d", ret);
2199 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2202 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2206 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2207 const char *appid, uid_t uid)
2211 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2213 if (pc == NULL || appid == NULL) {
2214 ERR("Invalid parameter");
2215 return PKGMGR_R_EINVAL;
2218 ret = pkgmgr_client_connection_send_request(client,
2219 "disable_app_splash_screen",
2220 g_variant_new("(us)", uid, appid), &result);
2221 if (ret != PKGMGR_R_OK) {
2222 ERR("request failed: %d", ret);
2226 g_variant_get(result, "(i)", &ret);
2227 g_variant_unref(result);
2228 if (ret != PKGMGR_R_OK)
2229 ERR("disable splash screen failed: %d", ret);
2234 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2235 int mode, uid_t uid)
2238 int ret = PKGMGR_R_ECOMM;
2239 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2241 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2242 ERR("invalid parameter");
2243 return PKGMGR_R_EINVAL;
2246 ret = pkgmgr_client_connection_send_request(client,
2247 "set_restriction_mode",
2248 g_variant_new("(usi)", uid, pkgid, mode), &result);
2249 if (ret != PKGMGR_R_OK) {
2250 ERR("request failed: %d", ret);
2254 g_variant_get(result, "(i)", &ret);
2255 g_variant_unref(result);
2260 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2261 const char *pkgid, int mode, uid_t uid)
2263 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2266 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2267 const char *pkgid, int mode)
2269 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2273 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2274 int mode, uid_t uid)
2277 int ret = PKGMGR_R_ECOMM;
2278 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2280 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2281 ERR("invalid parameter");
2282 return PKGMGR_R_EINVAL;
2285 ret = pkgmgr_client_connection_send_request(client,
2286 "unset_restriction_mode",
2287 g_variant_new("(usi)", uid, pkgid, mode), &result);
2288 if (ret != PKGMGR_R_OK) {
2289 ERR("request failed: %d", ret);
2293 g_variant_get(result, "(i)", &ret);
2294 g_variant_unref(result);
2300 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2301 const char *pkgid, int mode, uid_t uid)
2303 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2306 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2307 const char *pkgid, int mode)
2309 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2313 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2314 int *mode, uid_t uid)
2317 int ret = PKGMGR_R_ECOMM;
2319 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2321 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2322 ERR("invalid parameter");
2323 return PKGMGR_R_EINVAL;
2326 ret = pkgmgr_client_connection_send_request(client,
2327 "get_restriction_mode",
2328 g_variant_new("(us)", uid, pkgid), &result);
2329 if (ret != PKGMGR_R_OK) {
2330 ERR("request failed: %d", ret);
2334 g_variant_get(result, "(ii)", &m, &ret);
2335 g_variant_unref(result);
2336 if (ret != PKGMGR_R_OK)
2344 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2345 const char *pkgid, int *mode, uid_t uid)
2347 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2350 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2351 const char *pkgid, int *mode)
2353 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2357 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2361 int ret = PKGMGR_R_ECOMM;
2362 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2365 ERR("invalid parameter");
2366 return PKGMGR_R_EINVAL;
2369 ret = pkgmgr_client_connection_send_request(client,
2370 "set_restriction_mode",
2371 g_variant_new("(usi)", uid, "", mode), &result);
2372 if (ret != PKGMGR_R_OK) {
2373 ERR("request failed: %d", ret);
2377 g_variant_get(result, "(i)", &ret);
2378 g_variant_unref(result);
2383 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2385 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2388 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2392 int ret = PKGMGR_R_ECOMM;
2393 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2396 ERR("invalid parameter");
2397 return PKGMGR_R_EINVAL;
2400 ret = pkgmgr_client_connection_send_request(client,
2401 "unset_restriction_mode",
2402 g_variant_new("(usi)", uid, "", mode), &result);
2403 if (ret != PKGMGR_R_OK) {
2404 ERR("request failed: %d", ret);
2408 g_variant_get(result, "(i)", &ret);
2409 g_variant_unref(result);
2414 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2416 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2419 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2420 int *mode, uid_t uid)
2423 int ret = PKGMGR_R_ECOMM;
2425 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2428 ERR("invalid parameter");
2429 return PKGMGR_R_EINVAL;
2432 ret = pkgmgr_client_connection_send_request(client,
2433 "get_restriction_mode",
2434 g_variant_new("(us)", uid, ""), &result);
2435 if (ret != PKGMGR_R_OK) {
2436 ERR("request failed: %d", ret);
2440 g_variant_get(result, "(ii)", &m, &ret);
2441 g_variant_unref(result);
2442 if (ret != PKGMGR_R_OK)
2450 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2452 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2455 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2458 pkg_plugin_set *plugin_set;
2459 package_manager_pkg_detail_info_t *info;
2462 if (pkg_path == NULL) {
2463 ERR("invalid parameter");
2467 pkg_type = __get_type_from_path(pkg_path);
2468 if (pkg_type == NULL) {
2469 ERR("cannot get pkg type");
2473 plugin_set = _package_manager_load_library(pkg_type);
2474 if (plugin_set == NULL) {
2475 ERR("failed to load library for %s", pkg_type);
2480 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2482 ERR("out of memory");
2487 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2489 ERR("get_pkg_detail_info_from_package failed");
2497 return (pkgmgr_info *)info;
2500 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2502 package_manager_pkg_detail_info_t *pkg_info =
2503 (package_manager_pkg_detail_info_t *)info;
2506 ERR("invalid parameter");
2507 return PKGMGR_R_EINVAL;
2510 g_list_free_full(pkg_info->privilege_list, free);
2511 free(pkg_info->icon_buf);
2517 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2518 char *label, uid_t uid)
2522 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2524 if (pc == NULL || appid == NULL || label == NULL) {
2525 ERR("Invalid parameter");
2526 return PKGMGR_R_EINVAL;
2529 ret = pkgmgr_client_connection_send_request(client,
2531 g_variant_new("(uss)", uid, appid, label), &result);
2532 if (ret != PKGMGR_R_OK) {
2533 ERR("Request failed: %d", ret);
2537 g_variant_get(result, "(i)", &ret);
2538 g_variant_unref(result);
2543 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2545 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2548 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2549 char *icon_path, uid_t uid)
2553 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2555 if (pc == NULL || appid == NULL || icon_path == NULL) {
2556 ERR("Invalid parameter");
2557 return PKGMGR_R_EINVAL;
2560 if (access(icon_path, F_OK) != 0) {
2561 ERR("failed to access: %s", icon_path);
2562 return PKGMGR_R_EINVAL;
2565 ret = pkgmgr_client_connection_send_request(client,
2567 g_variant_new("(uss)", uid, appid, icon_path), &result);
2568 if (ret != PKGMGR_R_OK) {
2569 ERR("Request failed: %d", ret);
2573 g_variant_get(result, "(i)", &ret);
2574 g_variant_unref(result);
2579 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2581 return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2584 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2586 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2589 ERR("invalid parameter");
2590 return PKGMGR_R_EINVAL;
2593 client->debug_mode = debug_mode;
2598 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2600 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2603 ERR("invalid parameter");
2604 return PKGMGR_R_EINVAL;
2607 client->skip_optimization = skip_optimization;
2612 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2613 const char *pkgid, uid_t uid)
2616 int ret = PKGMGR_R_ECOMM;
2617 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2620 ERR("invalid parameter");
2621 return PKGMGR_R_EINVAL;
2624 ret = pkgmgr_client_connection_send_request(client,
2625 "migrate_external_image",
2626 g_variant_new("(us)", uid, pkgid), &result);
2627 if (ret != PKGMGR_R_OK) {
2628 ERR("request failed: %d", ret);
2632 g_variant_get(result, "(i)", &ret);
2633 g_variant_unref(result);