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.
37 #include <pkgmgr-info.h>
38 #include <iniparser.h>
39 /* For multi-user support */
40 #include <tzplatform_config.h>
42 #include "package-manager.h"
43 #include "pkgmgr_client_debug.h"
44 #include "pkgmgr_client_internal.h"
46 /* API export macro */
48 #define API __attribute__ ((visibility("default")))
51 #define BINSH_NAME "/bin/sh"
54 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
55 #define REGULAR_USER 5000
57 static GList *jobs_to_free;
58 static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER;
60 static inline uid_t _getuid(void)
64 if (uid < REGULAR_USER)
70 static int _get_internal_request_id()
72 static int internal_req_id = 1;
74 return internal_req_id++;
77 static char *_generate_request_id(void)
83 gettimeofday(&tv, NULL);
84 curtime = tv.tv_sec * 1000000 + tv.tv_usec;
86 snprintf(buf, sizeof(buf), "%d_%ld", getpid(), curtime);
91 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
92 pkgmgr_handler event_cb, void *data, const char *req_key)
94 struct cb_info *cb_info;
96 cb_info = calloc(1, sizeof(struct cb_info));
97 if (cb_info == NULL) {
101 cb_info->client = client;
102 cb_info->event_cb = event_cb;
103 cb_info->data = data;
104 cb_info->req_id = _get_internal_request_id();
105 if (req_key != NULL) {
106 cb_info->req_key = strdup(req_key);
107 if (cb_info->req_key == NULL) {
108 ERR("out of memory");
117 static struct cb_info *__create_app_event_cb_info(
118 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
119 void *data, const char *req_key)
121 struct cb_info *cb_info;
123 cb_info = calloc(1, sizeof(struct cb_info));
124 if (cb_info == NULL) {
125 ERR("out of memory");
128 cb_info->client = client;
129 cb_info->app_event_cb = app_event_cb;
130 cb_info->data = data;
131 cb_info->req_id = _get_internal_request_id();
132 if (req_key != NULL) {
133 cb_info->req_key = strdup(req_key);
134 if (cb_info->req_key == NULL) {
135 ERR("out of memory");
144 static struct cb_info *__create_res_copy_event_cb_info(
145 struct pkgmgr_client_t *client,
146 pkgmgr_res_copy_handler res_copy_event_cb,
147 void *data, const char *req_key)
149 struct cb_info *cb_info;
151 cb_info = calloc(1, sizeof(struct cb_info));
152 if (cb_info == NULL) {
153 ERR("out of memory");
157 cb_info->client = client;
158 cb_info->res_copy_event_cb = res_copy_event_cb;
159 cb_info->data = data;
160 cb_info->req_id = _get_internal_request_id();
164 cb_info->req_key = strdup(req_key);
165 if (cb_info->req_key == NULL) {
166 ERR("out of memory");
174 static struct cb_info *__create_size_info_cb_info(
175 struct pkgmgr_client_t *client,
176 pkgmgr_pkg_size_info_receive_cb size_info_cb,
177 void *data, const char *req_key)
179 struct cb_info *cb_info;
181 cb_info = calloc(1, sizeof(struct cb_info));
182 if (cb_info == NULL) {
183 ERR("out of memory");
186 cb_info->client = client;
187 cb_info->size_info_cb = size_info_cb;
188 cb_info->data = data;
189 cb_info->req_id = _get_internal_request_id();
190 if (req_key != NULL) {
191 cb_info->req_key = strdup(req_key);
192 if (cb_info->req_key == NULL) {
193 ERR("out of memory");
202 static int __jobs_to_free_add(gpointer data)
204 pthread_mutex_lock(&__mutex);
205 if (g_list_find(jobs_to_free, data)) {
206 pthread_mutex_unlock(&__mutex);
210 jobs_to_free = g_list_append(jobs_to_free, data);
211 pthread_mutex_unlock(&__mutex);
215 static void __jobs_to_free_remove(gpointer data)
217 pthread_mutex_lock(&__mutex);
218 jobs_to_free = g_list_remove(jobs_to_free, data);
219 pthread_mutex_unlock(&__mutex);
222 static void __do_free_cb_info(gpointer data)
224 struct cb_info *cb_info = (struct cb_info *)data;
226 g_list_free(cb_info->sid_list);
227 free(cb_info->req_key);
231 static void __free_cb_info_cb(gpointer data)
233 g_idle_remove_by_data(data);
234 __do_free_cb_info(data);
237 __attribute__((destructor)) static void __free_cb_info_at_destructor(void)
239 pthread_mutex_lock(&__mutex);
240 g_list_free_full(jobs_to_free, __free_cb_info_cb);
241 pthread_mutex_unlock(&__mutex);
244 static gboolean __free_cb_info_at_idle(gpointer data)
246 __jobs_to_free_remove(data);
247 __do_free_cb_info(data);
249 return G_SOURCE_REMOVE;
252 static void __free_cb_info(struct cb_info *cb_info)
254 if (__jobs_to_free_add(cb_info) < 0)
257 g_idle_add(__free_cb_info_at_idle, cb_info);
260 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
261 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
265 int ret = PKGMGR_R_ECOMM;
266 long long size_info = 0;
267 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
269 if (pc == NULL || pkgid == NULL) {
270 ERR("invalid parameter");
271 return PKGMGR_R_EINVAL;
274 if (client->pc_type != PC_REQUEST) {
275 ERR("client->pc_type is not PC_REQUEST");
276 return PKGMGR_R_EINVAL;
279 ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
280 g_variant_new("(usi)", uid, pkgid, get_type), &result);
281 if (ret != PKGMGR_R_OK) {
282 ERR("request failed: %d", ret);
286 g_variant_get(result, "(ix)", &ret, &size_info);
287 if (ret != PKGMGR_R_OK) {
288 ERR("request result failed: %d", ret);
289 g_variant_unref(result);
294 ERR("invalid size_info=(%lld)", size_info);
297 ret = (int)size_info;
298 DBG("size_info(%lld), return size(%d)", size_info, ret);
301 g_variant_unref(result);
306 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
307 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
308 pkgmgr_handler event_cb, void *data)
312 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
314 ERR("move request failed");
321 static int __check_app_process(pkgmgr_request_service_type service_type,
322 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
325 int ret = PKGMGR_R_ECOMM;
326 pkgmgrinfo_pkginfo_h handle;
328 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
330 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
332 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
333 if (ret != PMINFO_R_OK) {
334 ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
335 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
336 return PKGMGR_R_ERROR;
339 if (service_type == PM_REQUEST_KILL_APP) {
340 ret = pkgmgr_client_connection_send_request(client, "kill",
341 g_variant_new("(us)", uid, pkgid), &result);
342 } else if (service_type == PM_REQUEST_CHECK_APP) {
343 ret = pkgmgr_client_connection_send_request(client, "check",
344 g_variant_new("(us)", uid, pkgid), &result);
346 ERR("unexpected service type: %d", service_type);
347 ret = PKGMGR_R_ERROR;
350 if (ret != PKGMGR_R_OK) {
351 ERR("request failed: %d", ret);
352 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
356 g_variant_get(result, "(ii)", &ret, &pid);
357 g_variant_unref(result);
358 if (ret != PKGMGR_R_OK) {
359 ERR("request failed, ret=%d", ret);
360 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
366 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
372 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
374 struct pkgmgr_client_t *client;
376 if (pc_type == PC_BROADCAST) {
377 ERR("broadcast type is not supported");
381 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
382 ERR("invalid parameter");
386 client = calloc(1, sizeof(struct pkgmgr_client_t));
387 if (client == NULL) {
388 ERR("out of memory");
392 client->pc_type = pc_type;
393 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
395 if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) {
400 return (pkgmgr_client *)client;
403 API int pkgmgr_client_free(pkgmgr_client *pc)
405 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
408 ERR("invalid argument");
409 return PKGMGR_R_EINVAL;
412 pkgmgr_client_remove_listen_status(client);
413 pkgmgr_client_connection_disconnect(client);
414 if (client->tep_path)
415 free(client->tep_path);
416 if (client->res_copy_builder)
417 g_variant_builder_unref(client->res_copy_builder);
418 if (client->res_remove_builder)
419 g_variant_builder_unref(client->res_remove_builder);
425 struct manifest_and_type type_map[] = {
426 { "res/wgt/config.xml", "wgt" },
427 { "config.xml", "wgt" },
428 { "tizen-manifest.xml", "tpk" },
432 static char *__get_type_from_path(const char *pkg_path)
434 const char *type = NULL;
438 uf = unzOpen(pkg_path);
440 ERR("failed to open zip file %s", pkg_path);
444 for (i = 0; type_map[i].manifest != NULL; i++) {
445 if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
446 DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
447 type = type_map[i].type;
453 return type ? strdup(type) : NULL;
456 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
459 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
461 if (pc == NULL || tep_path == NULL) {
462 ERR("invalied parameter");
463 return PKGMGR_R_EINVAL;
466 if (client->tep_path)
467 free(client->tep_path);
469 client->tep_path = strdup(tep_path);
470 client->tep_move = tep_move;
475 API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
476 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
477 void *data, uid_t uid)
480 GVariantBuilder *pkgs_builder;
482 GVariantBuilder *args_builder;
485 char *req_key = NULL;
486 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
487 struct cb_info *cb_info;
489 char *request_id = NULL;
491 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
492 ERR("invalid parameter");
493 return PKGMGR_R_EINVAL;
496 if (client->pc_type != PC_REQUEST) {
497 ERR("client type is not PC_REQUEST");
498 return PKGMGR_R_EINVAL;
501 for (i = 0; i < n_pkgs; i++) {
502 if (access(pkg_paths[i], F_OK) != 0) {
503 ERR("failed to access: %s", pkg_paths[i]);
504 return PKGMGR_R_EINVAL;
508 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
509 for (i = 0; i < n_pkgs; i++)
510 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
511 pkgs = g_variant_new("as", pkgs_builder);
512 g_variant_builder_unref(pkgs_builder);
514 args_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
515 if (client->debug_mode)
516 g_variant_builder_add(args_builder, "s", "-G");
517 if (client->skip_optimization)
518 g_variant_builder_add(args_builder, "s", "-S");
519 args = g_variant_new("as", args_builder);
520 g_variant_builder_unref(args_builder);
522 request_id = _generate_request_id();
523 ret = pkgmgr_client_connection_send_request(client, "install_pkgs",
524 g_variant_new("(u@as@ass)", uid, pkgs, args,
528 if (ret != PKGMGR_R_OK) {
529 ERR("request failed: %d", ret);
533 g_variant_get(result, "(i&s)", &ret, &req_key);
534 if (req_key == NULL) {
535 g_variant_unref(result);
536 return PKGMGR_R_ECOMM;
538 if (ret != PKGMGR_R_OK) {
539 g_variant_unref(result);
543 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
544 if (cb_info == NULL) {
545 g_variant_unref(result);
546 return PKGMGR_R_ERROR;
548 g_variant_unref(result);
549 ret = pkgmgr_client_connection_set_callback(client, cb_info);
550 if (ret != PKGMGR_R_OK) {
551 __free_cb_info(cb_info);
554 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
556 return cb_info->req_id;
559 API int pkgmgr_client_install_packages(pkgmgr_client *pc,
560 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
563 return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
564 event_cb, data, _getuid());
567 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
568 const char *descriptor_path, const char *pkg_path,
569 const char *optional_data, pkgmgr_mode mode,
570 pkgmgr_handler event_cb, void *data, uid_t uid)
573 int ret = PKGMGR_R_ECOMM;
574 char *req_key = NULL;
575 GVariantBuilder *builder = NULL;
576 GVariant *args = NULL;
577 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
578 struct cb_info *cb_info;
579 char *request_id = NULL;
581 if (pc == NULL || pkg_path == NULL) {
582 ERR("invalid parameter");
583 return PKGMGR_R_EINVAL;
586 if (client->pc_type != PC_REQUEST) {
587 ERR("client type is not PC_REQUEST");
588 return PKGMGR_R_EINVAL;
591 if (access(pkg_path, F_OK) != 0) {
592 ERR("failed to access: %s", pkg_path);
593 return PKGMGR_R_EINVAL;
596 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
597 ERR("failed to access: %s", client->tep_path);
598 return PKGMGR_R_EINVAL;
601 /* build arguments */
602 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
603 if (client->tep_path) {
604 g_variant_builder_add(builder, "s", "-e");
605 g_variant_builder_add(builder, "s", client->tep_path);
606 g_variant_builder_add(builder, "s", "-M");
607 /* TODO: revise tep_move */
608 g_variant_builder_add(builder, "s",
609 client->tep_move ? "tep_move" : "tep_copy");
611 if (client->debug_mode)
612 g_variant_builder_add(builder, "s", "-G");
613 if (client->skip_optimization)
614 g_variant_builder_add(builder, "s", "-S");
616 args = g_variant_new("as", builder);
617 g_variant_builder_unref(builder);
619 request_id = _generate_request_id();
620 ret = pkgmgr_client_connection_send_request(client, "install",
621 g_variant_new("(uss@ass)", uid, pkg_type ? pkg_type : "",
622 pkg_path, args, request_id),
625 if (ret != PKGMGR_R_OK) {
626 ERR("request failed: %d", ret);
630 g_variant_get(result, "(i&s)", &ret, &req_key);
631 if (req_key == NULL) {
632 g_variant_unref(result);
633 return PKGMGR_R_ECOMM;
635 if (ret != PKGMGR_R_OK) {
636 g_variant_unref(result);
640 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
641 if (cb_info == NULL) {
642 g_variant_unref(result);
643 return PKGMGR_R_ENOMEM;
645 g_variant_unref(result);
646 ret = pkgmgr_client_connection_set_callback(client, cb_info);
647 if (ret != PKGMGR_R_OK) {
648 __free_cb_info(cb_info);
651 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
652 return cb_info->req_id;
655 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
656 const char *descriptor_path, const char *pkg_path,
657 const char *optional_data, pkgmgr_mode mode,
658 pkgmgr_handler event_cb, void *data)
660 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
661 pkg_path, optional_data, mode, event_cb, data,
665 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
666 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
667 pkgmgr_handler event_cb, void *data)
669 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
670 mode, event_cb, data, _getuid());
673 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
674 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
675 pkgmgr_handler event_cb, void *data, uid_t uid)
678 int ret = PKGMGR_R_ECOMM;
679 char *req_key = NULL;
680 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
681 struct cb_info *cb_info;
683 if (pc == NULL || pkgid == NULL) {
684 ERR("invalid parameter");
685 return PKGMGR_R_EINVAL;
688 if (client->pc_type != PC_REQUEST) {
689 ERR("client->pc_type is not PC_REQUEST");
690 return PKGMGR_R_EINVAL;
693 ret = pkgmgr_client_connection_send_request(client, "reinstall",
694 g_variant_new("(us)", uid, pkgid), &result);
695 if (ret != PKGMGR_R_OK) {
696 ERR("request failed: %d", ret);
700 g_variant_get(result, "(i&s)", &ret, &req_key);
701 if (req_key == NULL) {
702 g_variant_unref(result);
703 return PKGMGR_R_ECOMM;
705 if (ret != PKGMGR_R_OK) {
706 g_variant_unref(result);
710 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
711 if (cb_info == NULL) {
712 g_variant_unref(result);
713 return PKGMGR_R_ENOMEM;
715 g_variant_unref(result);
716 ret = pkgmgr_client_connection_set_callback(client, cb_info);
717 if (ret != PKGMGR_R_OK) {
718 __free_cb_info(cb_info);
721 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
723 return cb_info->req_id;
726 API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
727 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
728 void *data, uid_t uid)
731 GVariantBuilder *pkgs_builder;
733 int ret = PKGMGR_R_ECOMM;
734 char *req_key = NULL;
735 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
736 struct cb_info *cb_info;
738 char *request_id = NULL;
740 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
741 ERR("invalid parameter");
742 return PKGMGR_R_EINVAL;
745 if (client->pc_type != PC_REQUEST) {
746 ERR("client->pc_type is not PC_REQUEST");
747 return PKGMGR_R_EINVAL;
750 for (i = 0; i < n_pkgs; i++) {
751 if (access(pkg_paths[i], F_OK) != 0) {
752 ERR("failed to access: %s", pkg_paths[i]);
753 return PKGMGR_R_EINVAL;
757 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
758 for (i = 0; i < n_pkgs; i++)
759 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
760 pkgs = g_variant_new("as", pkgs_builder);
761 g_variant_builder_unref(pkgs_builder);
763 request_id = _generate_request_id();
764 ret = pkgmgr_client_connection_send_request(client,
765 "mount_install_pkgs",
766 g_variant_new("(u@ass)", uid, pkgs, request_id),
769 if (ret != PKGMGR_R_OK) {
770 ERR("request failed: %d", ret);
774 g_variant_get(result, "(i&s)", &ret, &req_key);
775 if (req_key == NULL) {
776 g_variant_unref(result);
777 return PKGMGR_R_ECOMM;
779 if (ret != PKGMGR_R_OK) {
780 g_variant_unref(result);
784 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
785 if (cb_info == NULL) {
786 g_variant_unref(result);
787 return PKGMGR_R_ENOMEM;
789 g_variant_unref(result);
790 ret = pkgmgr_client_connection_set_callback(client, cb_info);
791 if (ret != PKGMGR_R_OK) {
792 __free_cb_info(cb_info);
795 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
797 return cb_info->req_id;
800 API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
801 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
804 return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
805 event_cb, data, _getuid());
808 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
809 const char *descriptor_path, const char *pkg_path,
810 const char *optional_data, pkgmgr_mode mode,
811 pkgmgr_handler event_cb, void *data, uid_t uid)
814 int ret = PKGMGR_R_ECOMM;
815 char *req_key = NULL;
816 GVariantBuilder *builder = NULL;
817 GVariant *args = NULL;
818 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
819 struct cb_info *cb_info;
820 char *request_id = NULL;
822 if (pc == NULL || pkg_path == NULL) {
823 ERR("invalid parameter");
824 return PKGMGR_R_EINVAL;
827 if (client->pc_type != PC_REQUEST) {
828 ERR("client->pc_type is not PC_REQUEST");
829 return PKGMGR_R_EINVAL;
832 if (access(pkg_path, F_OK) != 0) {
833 ERR("failed to access: %s", pkg_path);
834 return PKGMGR_R_EINVAL;
837 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
838 ERR("failed to access: %s", client->tep_path);
839 return PKGMGR_R_EINVAL;
842 /* build arguments */
843 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
844 if (client->tep_path) {
845 g_variant_builder_add(builder, "s", "-e");
846 g_variant_builder_add(builder, "s", client->tep_path);
847 g_variant_builder_add(builder, "s", "-M");
848 /* TODO: revise tep_move */
849 g_variant_builder_add(builder, "s",
850 client->tep_move ? "tep_move" : "tep_copy");
853 args = g_variant_new("as", builder);
854 g_variant_builder_unref(builder);
856 request_id = _generate_request_id();
857 ret = pkgmgr_client_connection_send_request(client, "mount_install",
858 g_variant_new("(uss@ass)", uid,
859 pkg_type ? pkg_type : "", pkg_path,
863 if (ret != PKGMGR_R_OK) {
864 ERR("request failed: %d", ret);
868 g_variant_get(result, "(i&s)", &ret, &req_key);
869 if (req_key == NULL) {
870 g_variant_unref(result);
871 return PKGMGR_R_ECOMM;
873 if (ret != PKGMGR_R_OK) {
874 g_variant_unref(result);
878 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
879 if (cb_info == NULL) {
880 g_variant_unref(result);
881 return PKGMGR_R_ENOMEM;
883 g_variant_unref(result);
884 ret = pkgmgr_client_connection_set_callback(client, cb_info);
885 if (ret != PKGMGR_R_OK) {
886 __free_cb_info(cb_info);
889 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
891 return cb_info->req_id;
894 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
895 const char *descriptor_path, const char *pkg_path,
896 const char *optional_data, pkgmgr_mode mode,
897 pkgmgr_handler event_cb, void *data)
899 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
900 pkg_path, optional_data, mode, event_cb, data,
904 API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
905 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
906 void *data, uid_t uid)
909 GVariantBuilder *pkgs_builder;
911 int ret = PKGMGR_R_ECOMM;
912 char *req_key = NULL;
913 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
914 struct cb_info *cb_info;
917 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
918 ERR("invalid parameter");
919 return PKGMGR_R_EINVAL;
922 if (client->pc_type != PC_REQUEST) {
923 ERR("client->pc_type is not PC_REQUEST");
924 return PKGMGR_R_EINVAL;
927 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
928 for (i = 0; i < n_pkgs; i++)
929 g_variant_builder_add(pkgs_builder, "s", pkgids[i]);
930 pkgs = g_variant_new("as", pkgs_builder);
931 g_variant_builder_unref(pkgs_builder);
933 ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs",
934 g_variant_new("(u@as)", uid, pkgs), &result);
935 if (ret != PKGMGR_R_OK) {
936 ERR("request failed: %d", ret);
940 g_variant_get(result, "(i&s)", &ret, &req_key);
941 if (req_key == NULL) {
942 g_variant_unref(result);
943 return PKGMGR_R_ECOMM;
945 if (ret != PKGMGR_R_OK) {
946 g_variant_unref(result);
950 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
951 if (cb_info == NULL) {
952 g_variant_unref(result);
953 return PKGMGR_R_ENOMEM;
955 g_variant_unref(result);
956 ret = pkgmgr_client_connection_set_callback(client, cb_info);
957 if (ret != PKGMGR_R_OK) {
958 __free_cb_info(cb_info);
961 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
963 return cb_info->req_id;
966 API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
967 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
970 return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
971 event_cb, data, _getuid());
974 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
975 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
978 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
982 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
983 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
984 void *data, uid_t uid)
987 int ret = PKGMGR_R_ECOMM;
988 char *req_key = NULL;
989 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
990 struct cb_info *cb_info;
992 if (pc == NULL || pkgid == NULL) {
993 ERR("invalid parameter");
994 return PKGMGR_R_EINVAL;
997 if (client->pc_type != PC_REQUEST) {
998 ERR("client->pc_type is not PC_REQUEST");
999 return PKGMGR_R_EINVAL;
1002 ret = pkgmgr_client_connection_send_request(client, "uninstall",
1003 g_variant_new("(us)", uid, pkgid), &result);
1004 if (ret != PKGMGR_R_OK) {
1005 ERR("request failed: %d", ret);
1009 g_variant_get(result, "(i&s)", &ret, &req_key);
1010 if (req_key == NULL) {
1011 g_variant_unref(result);
1012 return PKGMGR_R_ECOMM;
1014 if (ret != PKGMGR_R_OK) {
1015 g_variant_unref(result);
1019 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1020 if (cb_info == NULL) {
1021 g_variant_unref(result);
1022 return PKGMGR_R_ENOMEM;
1024 g_variant_unref(result);
1025 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1026 if (ret != PKGMGR_R_OK) {
1027 __free_cb_info(cb_info);
1030 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1032 return cb_info->req_id;
1035 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1036 const char *pkgid, pkgmgr_move_type move_type,
1037 pkgmgr_handler event_cb, void *data)
1039 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
1040 event_cb, data, _getuid());
1042 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1043 const char *pkgid, pkgmgr_move_type move_type,
1044 pkgmgr_handler event_cb, void *data, uid_t uid)
1047 int ret = PKGMGR_R_ECOMM;
1048 char *req_key = NULL;
1049 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1050 struct cb_info *cb_info;
1052 if (pc == NULL || pkgid == NULL) {
1053 ERR("invalid parameter");
1054 return PKGMGR_R_EINVAL;
1057 if ((move_type < PM_MOVE_TO_INTERNAL) ||
1058 (move_type > PM_MOVE_TO_EXTENDED))
1059 return PKGMGR_R_EINVAL;
1061 if (client->pc_type != PC_REQUEST) {
1062 ERR("client->pc_type is not PC_REQUEST");
1063 return PKGMGR_R_EINVAL;
1066 ret = pkgmgr_client_connection_send_request(client, "move",
1067 g_variant_new("(usi)", uid, pkgid, move_type), &result);
1068 if (ret != PKGMGR_R_OK) {
1069 ERR("request failed: %d", ret);
1073 g_variant_get(result, "(i&s)", &ret, &req_key);
1074 if (req_key == NULL) {
1075 g_variant_unref(result);
1076 return PKGMGR_R_ECOMM;
1078 if (ret != PKGMGR_R_OK) {
1079 g_variant_unref(result);
1083 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1084 if (cb_info == NULL) {
1085 g_variant_unref(result);
1086 return PKGMGR_R_ERROR;
1088 g_variant_unref(result);
1089 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1090 if (ret != PKGMGR_R_OK) {
1091 __free_cb_info(cb_info);
1094 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1096 return cb_info->req_id;
1099 API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
1100 pkg_update_info_t *update_info, uid_t uid)
1103 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1106 if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
1107 ERR("invalid parameter");
1108 return PKGMGR_R_EINVAL;
1111 if (client->pc_type != PC_REQUEST) {
1112 ERR("client->pc_type is not PC_REQUEST");
1113 return PKGMGR_R_EINVAL;
1116 ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
1117 g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
1118 update_info->type), &result);
1119 if (ret != PKGMGR_R_OK) {
1120 ERR("request failed: %d", ret);
1124 g_variant_get(result, "(i)", &ret);
1125 if (ret != PKGMGR_R_OK) {
1126 g_variant_unref(result);
1129 g_variant_unref(result);
1134 API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
1135 pkg_update_info_t *update_info)
1137 return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
1141 API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
1142 const char *pkgid, uid_t uid)
1145 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1148 if (pc == NULL || pkgid == NULL) {
1149 ERR("invalid parameter");
1150 return PKGMGR_R_EINVAL;
1153 if (client->pc_type != PC_REQUEST) {
1154 ERR("client->pc_type is not PC_REQUEST");
1155 return PKGMGR_R_EINVAL;
1158 ret = pkgmgr_client_connection_send_request(client,
1159 "unregister_pkg_update_info",
1160 g_variant_new("(us)", uid, pkgid), &result);
1161 if (ret != PKGMGR_R_OK) {
1162 ERR("request failed: %d", ret);
1166 g_variant_get(result, "(i)", &ret);
1167 if (ret != PKGMGR_R_OK) {
1168 g_variant_unref(result);
1171 g_variant_unref(result);
1176 API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
1179 return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
1182 API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
1186 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1190 ERR("invalid parameter");
1191 return PKGMGR_R_EINVAL;
1194 if (client->pc_type != PC_REQUEST) {
1195 ERR("client->pc_type is not PC_REQUEST");
1196 return PKGMGR_R_EINVAL;
1199 ret = pkgmgr_client_connection_send_request(client,
1200 "unregister_all_pkg_update_info",
1201 g_variant_new("(u)", uid), &result);
1202 if (ret != PKGMGR_R_OK) {
1203 ERR("request failed: %d", ret);
1207 g_variant_get(result, "(i)", &ret);
1208 if (ret != PKGMGR_R_OK) {
1209 g_variant_unref(result);
1212 g_variant_unref(result);
1217 API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
1219 return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
1222 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1223 const char *pkgid, uid_t uid)
1226 int ret = PKGMGR_R_ECOMM;
1227 GVariantBuilder *builder;
1228 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1230 if (pc == NULL || pkgid == NULL) {
1231 ERR("invalid parameter");
1232 return PKGMGR_R_EINVAL;
1235 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1236 g_variant_builder_add(builder, "s", pkgid);
1238 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1239 g_variant_new("(uas)", uid, builder), &result);
1240 g_variant_builder_unref(builder);
1241 if (ret != PKGMGR_R_OK) {
1242 ERR("request failed: %d", ret);
1246 g_variant_get(result, "(is)", &ret, NULL);
1247 g_variant_unref(result);
1252 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1255 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
1258 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
1259 const char *pkg_type, const char **pkgids, int n_pkgs,
1260 pkgmgr_handler event_cb, void *data, uid_t uid)
1263 GVariantBuilder *builder;
1264 int ret = PKGMGR_R_ECOMM;
1265 char *req_key = NULL;
1266 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1267 struct cb_info *cb_info;
1270 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1271 ERR("invalid parameter");
1272 return PKGMGR_R_EINVAL;
1275 if (client->pc_type != PC_REQUEST) {
1276 ERR("client type is not PC_REQUEST");
1277 return PKGMGR_R_EINVAL;
1280 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1281 for (i = 0; i < n_pkgs; i++)
1282 g_variant_builder_add(builder, "s", pkgids[i]);
1284 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1285 g_variant_new("(uas)", uid, builder), &result);
1286 g_variant_builder_unref(builder);
1287 if (ret != PKGMGR_R_OK) {
1288 ERR("request failed: %d", ret);
1292 g_variant_get(result, "(i&s)", &ret, &req_key);
1293 if (req_key == NULL) {
1294 g_variant_unref(result);
1295 return PKGMGR_R_ECOMM;
1297 if (ret != PKGMGR_R_OK) {
1298 g_variant_unref(result);
1302 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1303 if (cb_info == NULL) {
1304 g_variant_unref(result);
1305 return PKGMGR_R_ERROR;
1307 g_variant_unref(result);
1308 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1309 if (ret != PKGMGR_R_OK) {
1310 __free_cb_info(cb_info);
1313 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1315 return cb_info->req_id;
1318 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
1319 const char *pkg_type, const char **pkgids, int n_pkgs,
1320 pkgmgr_handler event_cb, void *data)
1322 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
1323 pkgids, n_pkgs, event_cb, data, _getuid());
1326 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1327 const char *pkgid, uid_t uid)
1330 GVariantBuilder *builder;
1331 int ret = PKGMGR_R_ECOMM;
1332 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1334 if (pc == NULL || pkgid == NULL) {
1335 ERR("invalid parameter");
1336 return PKGMGR_R_EINVAL;
1339 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1340 g_variant_builder_add(builder, "s", pkgid);
1342 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1343 g_variant_new("(uas)", uid, builder), &result);
1344 g_variant_builder_unref(builder);
1345 if (ret != PKGMGR_R_OK) {
1346 ERR("request failed: %d", ret);
1350 g_variant_get(result, "(is)", &ret, NULL);
1351 g_variant_unref(result);
1356 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1359 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1362 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1363 const char *pkg_type, const char **pkgids, int n_pkgs,
1364 pkgmgr_handler event_cb, void *data, uid_t uid)
1367 GVariantBuilder *builder;
1368 int ret = PKGMGR_R_ECOMM;
1369 char *req_key = NULL;
1370 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1371 struct cb_info *cb_info;
1374 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1375 ERR("invalid parameter");
1376 return PKGMGR_R_EINVAL;
1379 if (client->pc_type != PC_REQUEST) {
1380 ERR("client type is not PC_REQUEST");
1381 return PKGMGR_R_EINVAL;
1384 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1385 for (i = 0; i < n_pkgs; i++)
1386 g_variant_builder_add(builder, "s", pkgids[i]);
1388 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1389 g_variant_new("(uas)", uid, builder), &result);
1390 g_variant_builder_unref(builder);
1391 if (ret != PKGMGR_R_OK) {
1392 ERR("request failed: %d", ret);
1396 g_variant_get(result, "(i&s)", &ret, &req_key);
1397 if (req_key == NULL) {
1398 g_variant_unref(result);
1399 return PKGMGR_R_ECOMM;
1401 if (ret != PKGMGR_R_OK) {
1402 g_variant_unref(result);
1406 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1407 if (cb_info == NULL) {
1408 g_variant_unref(result);
1409 return PKGMGR_R_ERROR;
1411 g_variant_unref(result);
1412 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1413 if (ret != PKGMGR_R_OK) {
1414 __free_cb_info(cb_info);
1417 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1419 return cb_info->req_id;
1422 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1423 const char *pkg_type, const char **pkgids, int n_pkgs,
1424 pkgmgr_handler event_cb, void *data)
1426 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1427 pkgids, n_pkgs, event_cb, data, _getuid());
1430 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1431 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1434 int ret = PKGMGR_R_ECOMM;
1435 char *req_key = NULL;
1436 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1437 struct cb_info *cb_info;
1439 if (pc == NULL || appid == NULL) {
1440 ERR("invalid parameter");
1441 return PKGMGR_R_EINVAL;
1444 ret = pkgmgr_client_connection_send_request(client, "enable_app",
1445 g_variant_new("(us)", uid, appid), &result);
1446 if (ret != PKGMGR_R_OK) {
1447 ERR("request failed: %d", ret);
1451 g_variant_get(result, "(i&s)", &ret, &req_key);
1452 if (req_key == NULL) {
1453 g_variant_unref(result);
1454 return PKGMGR_R_ECOMM;
1456 if (ret != PKGMGR_R_OK) {
1457 g_variant_unref(result);
1461 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1463 if (cb_info == NULL) {
1464 g_variant_unref(result);
1465 return PKGMGR_R_ENOMEM;
1467 g_variant_unref(result);
1468 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1469 if (ret != PKGMGR_R_OK) {
1470 __free_cb_info(cb_info);
1473 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1475 return cb_info->req_id;
1478 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1479 pkgmgr_app_handler app_event_cb, void *data)
1481 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1485 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1486 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1489 GVariantBuilder *builder;
1490 int ret = PKGMGR_R_ECOMM;
1491 char *req_key = NULL;
1492 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1493 struct cb_info *cb_info;
1496 if (pc == NULL || appids == NULL || n_apps < 1) {
1497 ERR("invalid parameter");
1498 return PKGMGR_R_EINVAL;
1501 if (client->pc_type != PC_REQUEST) {
1502 ERR("client type is not PC_REQUEST");
1503 return PKGMGR_R_EINVAL;
1506 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1507 for (i = 0; i < n_apps; i++)
1508 g_variant_builder_add(builder, "s", appids[i]);
1510 ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1511 g_variant_new("(uas)", uid, builder), &result);
1512 g_variant_builder_unref(builder);
1513 if (ret != PKGMGR_R_OK) {
1514 ERR("request failed: %d", ret);
1518 g_variant_get(result, "(i&s)", &ret, &req_key);
1519 if (req_key == NULL) {
1520 g_variant_unref(result);
1521 return PKGMGR_R_ECOMM;
1523 if (ret != PKGMGR_R_OK) {
1524 g_variant_unref(result);
1528 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1529 if (cb_info == NULL) {
1530 g_variant_unref(result);
1531 return PKGMGR_R_ERROR;
1533 g_variant_unref(result);
1534 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1535 if (ret != PKGMGR_R_OK) {
1536 __free_cb_info(cb_info);
1539 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1541 return cb_info->req_id;
1544 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1545 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1547 return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1548 app_event_cb, data, _getuid());
1551 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1552 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1555 int ret = PKGMGR_R_ECOMM;
1556 char *req_key = NULL;
1557 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1558 struct cb_info *cb_info;
1560 if (pc == NULL || appid == NULL) {
1561 ERR("invalid parameter");
1562 return PKGMGR_R_EINVAL;
1565 ret = pkgmgr_client_connection_send_request(client,
1566 "enable_global_app_for_uid",
1567 g_variant_new("(us)", uid, appid), &result);
1568 if (ret != PKGMGR_R_OK) {
1569 ERR("request failed: %d", ret);
1573 g_variant_get(result, "(i&s)", &ret, &req_key);
1574 if (req_key == NULL) {
1575 g_variant_unref(result);
1576 return PKGMGR_R_ECOMM;
1578 if (ret != PKGMGR_R_OK) {
1579 g_variant_unref(result);
1583 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1585 if (cb_info == NULL) {
1586 g_variant_unref(result);
1587 return PKGMGR_R_ENOMEM;
1589 g_variant_unref(result);
1590 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1591 if (ret != PKGMGR_R_OK) {
1592 __free_cb_info(cb_info);
1595 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1597 return cb_info->req_id;
1600 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1601 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1604 int ret = PKGMGR_R_ECOMM;
1605 char *req_key = NULL;
1606 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1607 struct cb_info *cb_info;
1609 if (pc == NULL || appid == NULL) {
1610 ERR("invalid parameter");
1611 return PKGMGR_R_EINVAL;
1614 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1615 g_variant_new("(us)", uid, appid), &result);
1616 if (ret != PKGMGR_R_OK) {
1617 ERR("request failed: %d", ret);
1621 g_variant_get(result, "(i&s)", &ret, &req_key);
1622 if (req_key == NULL) {
1623 g_variant_unref(result);
1624 return PKGMGR_R_ECOMM;
1626 if (ret != PKGMGR_R_OK) {
1627 g_variant_unref(result);
1631 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1633 if (cb_info == NULL) {
1634 g_variant_unref(result);
1635 return PKGMGR_R_ENOMEM;
1637 g_variant_unref(result);
1638 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1639 if (ret != PKGMGR_R_OK) {
1640 __free_cb_info(cb_info);
1643 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1645 return cb_info->req_id;
1648 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1649 pkgmgr_app_handler app_event_cb, void *data)
1651 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1655 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1656 const char **appids, int n_apps,
1657 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1660 GVariantBuilder *builder;
1661 int ret = PKGMGR_R_ECOMM;
1662 char *req_key = NULL;
1663 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1664 struct cb_info *cb_info;
1667 if (pc == NULL || appids == NULL || n_apps < 1) {
1668 ERR("invalid parameter");
1669 return PKGMGR_R_EINVAL;
1672 if (client->pc_type != PC_REQUEST) {
1673 ERR("client type is not PC_REQUEST");
1674 return PKGMGR_R_EINVAL;
1677 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1678 for (i = 0; i < n_apps; i++)
1679 g_variant_builder_add(builder, "s", appids[i]);
1681 ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1682 g_variant_new("(uas)", uid, builder), &result);
1683 g_variant_builder_unref(builder);
1684 if (ret != PKGMGR_R_OK) {
1685 ERR("request failed: %d", ret);
1689 g_variant_get(result, "(i&s)", &ret, &req_key);
1690 if (req_key == NULL) {
1691 g_variant_unref(result);
1692 return PKGMGR_R_ECOMM;
1694 if (ret != PKGMGR_R_OK) {
1695 g_variant_unref(result);
1699 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1700 if (cb_info == NULL) {
1701 g_variant_unref(result);
1702 return PKGMGR_R_ERROR;
1704 g_variant_unref(result);
1705 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1706 if (ret != PKGMGR_R_OK) {
1707 __free_cb_info(cb_info);
1710 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1712 return cb_info->req_id;
1715 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1716 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1718 return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1719 app_event_cb, data, _getuid());
1722 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1723 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1726 int ret = PKGMGR_R_ECOMM;
1727 char *req_key = NULL;
1728 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1729 struct cb_info *cb_info;
1731 if (pc == NULL || appid == NULL) {
1732 ERR("invalid parameter");
1733 return PKGMGR_R_EINVAL;
1736 ret = pkgmgr_client_connection_send_request(client,
1737 "disable_global_app_for_uid",
1738 g_variant_new("(us)", uid, appid), &result);
1739 if (ret != PKGMGR_R_OK) {
1740 ERR("request failed: %d", ret);
1744 g_variant_get(result, "(i&s)", &ret, &req_key);
1745 if (req_key == NULL) {
1746 g_variant_unref(result);
1747 return PKGMGR_R_ECOMM;
1749 if (ret != PKGMGR_R_OK) {
1750 g_variant_unref(result);
1754 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1756 if (cb_info == NULL) {
1757 g_variant_unref(result);
1758 return PKGMGR_R_ENOMEM;
1760 g_variant_unref(result);
1761 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1762 if (ret != PKGMGR_R_OK) {
1763 __free_cb_info(cb_info);
1766 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1768 return cb_info->req_id;
1771 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1772 const char *pkg_type, const char *pkgid, pkgmgr_mode mode,
1777 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1779 if (pc == NULL || pkgid == NULL || uid == GLOBAL_USER) {
1780 ERR("invalid parameter");
1781 return PKGMGR_R_EINVAL;
1784 if (client->pc_type != PC_REQUEST) {
1785 ERR("client->pc_type is not PC_REQUEST");
1786 return PKGMGR_R_EINVAL;
1789 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1790 g_variant_new("(us)", uid, pkgid), &result);
1791 if (ret != PKGMGR_R_OK) {
1792 ERR("request failed: %d", ret);
1796 g_variant_get(result, "(i)", &ret);
1797 g_variant_unref(result);
1802 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1803 const char *pkgid, pkgmgr_mode mode)
1805 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode,
1809 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1811 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1814 ERR("invalid parameter");
1815 return PKGMGR_R_EINVAL;
1818 client->status_type = status_type;
1823 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1827 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1828 struct cb_info *cb_info;
1830 if (pc == NULL || event_cb == NULL) {
1831 ERR("invalid parameter");
1832 return PKGMGR_R_EINVAL;
1835 if (client->pc_type != PC_LISTENING) {
1836 ERR("client->pc_type is not PC_LISTENING");
1837 return PKGMGR_R_EINVAL;
1840 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1841 if (cb_info == NULL)
1842 return PKGMGR_R_ENOMEM;
1843 cb_info->status_type = client->status_type;
1844 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1845 if (ret != PKGMGR_R_OK) {
1846 __free_cb_info(cb_info);
1849 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1851 return cb_info->req_id;
1854 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1855 pkgmgr_app_handler app_event_cb, void *data)
1858 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1859 struct cb_info *cb_info;
1861 if (pc == NULL || app_event_cb == NULL) {
1862 ERR("invalid parameter");
1863 return PKGMGR_R_EINVAL;
1866 if (client->pc_type != PC_LISTENING) {
1867 ERR("client->pc_type is not PC_LISTENING");
1868 return PKGMGR_R_EINVAL;
1871 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1872 if (cb_info == NULL)
1873 return PKGMGR_R_ENOMEM;
1874 cb_info->status_type = client->status_type;
1875 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1876 if (ret != PKGMGR_R_OK) {
1877 __free_cb_info(cb_info);
1880 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1882 return cb_info->req_id;
1885 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1887 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1890 struct cb_info *cb_info;
1893 ERR("invalid parameter");
1894 return PKGMGR_R_EINVAL;
1897 /* unset all callback */
1898 tmp = client->cb_info_list;
1899 while (tmp != NULL) {
1901 cb_info = (struct cb_info *)tmp->data;
1902 pkgmgr_client_connection_unset_callback(pc, cb_info);
1903 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1905 __free_cb_info(cb_info);
1912 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1913 const char *pkgid, const char *key, const char *val)
1915 /* client cannot broadcast signal */
1919 /* TODO: deprecate(or remove) */
1920 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1921 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1922 const char *pkgid, const char *custom_info,
1923 pkgmgr_handler event_cb, void *data)
1925 return pkgmgr_client_usr_request_service(service_type, service_mode,
1926 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1930 API int pkgmgr_client_usr_request_service(
1931 pkgmgr_request_service_type service_type, int service_mode,
1932 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1933 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1938 /* Check for NULL value of service type */
1939 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1940 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1942 switch (service_type) {
1943 case PM_REQUEST_MOVE:
1944 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1945 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1946 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1948 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1951 case PM_REQUEST_GET_SIZE:
1952 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1953 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1954 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1956 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1959 case PM_REQUEST_KILL_APP:
1960 case PM_REQUEST_CHECK_APP:
1961 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1962 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1964 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1966 ERR("__check_app_process fail \n");
1973 ERR("Wrong Request\n");
1983 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1987 struct pkgmgr_client_t *client;
1989 if (pkgid == NULL || uid == GLOBAL_USER) {
1990 ERR("invalid parameter");
1991 return PKGMGR_R_EINVAL;
1994 client = pkgmgr_client_new(PC_REQUEST);
1995 if (client == NULL) {
1996 ERR("out of memory");
1997 return PKGMGR_R_ENOMEM;
2000 ret = pkgmgr_client_connection_send_request(client, "clearcache",
2001 g_variant_new("(us)", uid, pkgid), &result);
2002 if (ret != PKGMGR_R_OK) {
2003 ERR("request failed: %d", ret);
2004 pkgmgr_client_free(client);
2008 g_variant_get(result, "(i)", &ret);
2009 g_variant_unref(result);
2010 pkgmgr_client_free(client);
2015 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2017 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
2020 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2022 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2025 API int pkgmgr_client_clear_all_cache_dir(void)
2027 return pkgmgr_client_usr_clear_cache_dir(
2028 PKG_CLEAR_ALL_CACHE, _getuid());
2031 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
2032 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2035 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2039 /* TODO: deprecate(or remove) */
2040 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
2041 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2042 void *data, uid_t uid)
2045 int ret = PKGMGR_R_ECOMM;
2046 char *req_key = NULL;
2047 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2048 struct cb_info *cb_info;
2050 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2051 ERR("invalid parameter");
2052 return PKGMGR_R_EINVAL;
2055 if (client->pc_type != PC_REQUEST) {
2056 ERR("client->pc_type is not PC_REQUEST");
2057 return PKGMGR_R_EINVAL;
2061 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2062 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2064 get_type = PM_GET_PKG_SIZE_INFO;
2066 ret = pkgmgr_client_connection_send_request(client, "getsize",
2067 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2068 if (ret != PKGMGR_R_OK) {
2069 ERR("request failed: %d", ret);
2073 g_variant_get(result, "(i&s)", &ret, &req_key);
2074 if (req_key == NULL) {
2075 g_variant_unref(result);
2076 return PKGMGR_R_ECOMM;
2078 if (ret != PKGMGR_R_OK) {
2079 g_variant_unref(result);
2083 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
2084 if (cb_info == NULL) {
2085 g_variant_unref(result);
2086 return PKGMGR_R_ENOMEM;
2088 g_variant_unref(result);
2089 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2090 if (ret != PKGMGR_R_OK) {
2091 __free_cb_info(cb_info);
2094 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2099 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2100 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2101 void *user_data, uid_t uid)
2104 int ret = PKGMGR_R_ECOMM;
2105 char *req_key = NULL;
2107 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2108 struct cb_info *cb_info;
2110 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2111 ERR("invalid parameter");
2112 return PKGMGR_R_EINVAL;
2115 if (client->pc_type != PC_REQUEST) {
2116 ERR("client->pc_type is not PC_REQUEST");
2117 return PKGMGR_R_EINVAL;
2120 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2121 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2123 get_type = PM_GET_PKG_SIZE_INFO;
2125 ret = pkgmgr_client_connection_send_request(client, "getsize",
2126 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2127 if (ret != PKGMGR_R_OK) {
2128 ERR("request failed: %d", ret);
2132 g_variant_get(result, "(i&s)", &ret, &req_key);
2133 if (req_key == NULL) {
2134 g_variant_unref(result);
2135 return PKGMGR_R_ECOMM;
2137 if (ret != PKGMGR_R_OK) {
2138 g_variant_unref(result);
2142 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2144 if (cb_info == NULL) {
2145 g_variant_unref(result);
2146 return PKGMGR_R_ENOMEM;
2148 g_variant_unref(result);
2149 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2150 if (ret != PKGMGR_R_OK) {
2151 __free_cb_info(cb_info);
2154 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2159 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2160 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2163 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2164 user_data, _getuid());
2167 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2168 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2169 void *user_data, uid_t uid)
2170 { /* total package size info */
2171 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2172 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2176 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2177 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2179 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2180 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2181 user_data, _getuid());
2184 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2185 const char *resp_data, char **req_data, char **license_url)
2191 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2193 if (pc == NULL || resp_data == NULL || req_data == NULL ||
2194 license_url == NULL) {
2195 ERR("invalid parameter");
2196 return PKGMGR_R_EINVAL;
2199 if (client->pc_type != PC_REQUEST) {
2200 ERR("client->pc_type is not PC_REQUEST");
2201 return PKGMGR_R_EINVAL;
2204 ret = pkgmgr_client_connection_send_request(client,
2205 "generate_license_request",
2206 g_variant_new("(s)", resp_data), &result);
2207 if (ret != PKGMGR_R_OK) {
2208 ERR("request failed: %d", ret);
2212 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2213 if (ret != PKGMGR_R_OK) {
2214 ERR("generate_license_request failed: %d", ret);
2215 g_variant_unref(result);
2219 *req_data = strdup(data);
2220 *license_url = strdup(url);
2222 g_variant_unref(result);
2227 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2231 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2233 if (pc == NULL || resp_data == NULL) {
2234 ERR("invalid parameter");
2235 return PKGMGR_R_EINVAL;
2238 if (client->pc_type != PC_REQUEST) {
2239 ERR("client->pc_type is not PC_REQUEST");
2240 return PKGMGR_R_EINVAL;
2243 ret = pkgmgr_client_connection_send_request(client, "register_license",
2244 g_variant_new("(s)", resp_data), &result);
2245 if (ret != PKGMGR_R_OK) {
2246 ERR("request failed: %d", ret);
2250 g_variant_get(result, "(i)", &ret);
2251 g_variant_unref(result);
2252 if (ret != PKGMGR_R_OK)
2253 ERR("register license failed: %d", ret);
2258 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2259 const char *drm_file_path, const char *decrypted_file_path)
2263 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2265 if (pc == NULL || drm_file_path == NULL ||
2266 decrypted_file_path == NULL) {
2267 ERR("invalid parameter");
2268 return PKGMGR_R_EINVAL;
2271 if (client->pc_type != PC_REQUEST) {
2272 ERR("client->pc_type is not PC_REQUEST");
2273 return PKGMGR_R_EINVAL;
2276 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2277 g_variant_new("(ss)", drm_file_path,
2278 decrypted_file_path), &result);
2279 if (ret != PKGMGR_R_OK) {
2280 ERR("request failed: %d", ret);
2284 g_variant_get(result, "(i)", &ret);
2285 g_variant_unref(result);
2286 if (ret != PKGMGR_R_OK)
2287 ERR("decrypt_package failed: %d", ret);
2292 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2294 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2297 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2298 const char *appid, uid_t uid)
2302 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2304 if (pc == NULL || appid == NULL) {
2305 ERR("Invalid parameter");
2306 return PKGMGR_R_EINVAL;
2309 ret = pkgmgr_client_connection_send_request(client,
2310 "enable_app_splash_screen",
2311 g_variant_new("(us)", uid, appid), &result);
2312 if (ret != PKGMGR_R_OK) {
2313 ERR("request failed: %d", ret);
2317 g_variant_get(result, "(i)", &ret);
2318 g_variant_unref(result);
2319 if (ret != PKGMGR_R_OK)
2320 ERR("enable splash screen failed: %d", ret);
2325 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2328 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2332 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2333 const char *appid, uid_t uid)
2337 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2339 if (pc == NULL || appid == NULL) {
2340 ERR("Invalid parameter");
2341 return PKGMGR_R_EINVAL;
2344 ret = pkgmgr_client_connection_send_request(client,
2345 "disable_app_splash_screen",
2346 g_variant_new("(us)", uid, appid), &result);
2347 if (ret != PKGMGR_R_OK) {
2348 ERR("request failed: %d", ret);
2352 g_variant_get(result, "(i)", &ret);
2353 g_variant_unref(result);
2354 if (ret != PKGMGR_R_OK)
2355 ERR("disable splash screen failed: %d", ret);
2360 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2361 int mode, uid_t uid)
2364 int ret = PKGMGR_R_ECOMM;
2365 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2367 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2368 ERR("invalid parameter");
2369 return PKGMGR_R_EINVAL;
2372 ret = pkgmgr_client_connection_send_request(client,
2373 "set_restriction_mode",
2374 g_variant_new("(usi)", uid, pkgid, mode), &result);
2375 if (ret != PKGMGR_R_OK) {
2376 ERR("request failed: %d", ret);
2380 g_variant_get(result, "(i)", &ret);
2381 g_variant_unref(result);
2386 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2387 const char *pkgid, int mode, uid_t uid)
2389 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2392 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2393 const char *pkgid, int mode)
2395 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2399 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2400 int mode, uid_t uid)
2403 int ret = PKGMGR_R_ECOMM;
2404 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2406 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2407 ERR("invalid parameter");
2408 return PKGMGR_R_EINVAL;
2411 ret = pkgmgr_client_connection_send_request(client,
2412 "unset_restriction_mode",
2413 g_variant_new("(usi)", uid, pkgid, mode), &result);
2414 if (ret != PKGMGR_R_OK) {
2415 ERR("request failed: %d", ret);
2419 g_variant_get(result, "(i)", &ret);
2420 g_variant_unref(result);
2426 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2427 const char *pkgid, int mode, uid_t uid)
2429 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2432 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2433 const char *pkgid, int mode)
2435 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2439 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2440 int *mode, uid_t uid)
2443 int ret = PKGMGR_R_ECOMM;
2445 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2447 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2448 ERR("invalid parameter");
2449 return PKGMGR_R_EINVAL;
2452 ret = pkgmgr_client_connection_send_request(client,
2453 "get_restriction_mode",
2454 g_variant_new("(us)", uid, pkgid), &result);
2455 if (ret != PKGMGR_R_OK) {
2456 ERR("request failed: %d", ret);
2460 g_variant_get(result, "(ii)", &m, &ret);
2461 g_variant_unref(result);
2462 if (ret != PKGMGR_R_OK)
2470 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2471 const char *pkgid, int *mode, uid_t uid)
2473 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2476 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2477 const char *pkgid, int *mode)
2479 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2483 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2487 int ret = PKGMGR_R_ECOMM;
2488 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2491 ERR("invalid parameter");
2492 return PKGMGR_R_EINVAL;
2495 ret = pkgmgr_client_connection_send_request(client,
2496 "set_restriction_mode",
2497 g_variant_new("(usi)", uid, "", mode), &result);
2498 if (ret != PKGMGR_R_OK) {
2499 ERR("request failed: %d", ret);
2503 g_variant_get(result, "(i)", &ret);
2504 g_variant_unref(result);
2509 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2511 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2514 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2518 int ret = PKGMGR_R_ECOMM;
2519 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2522 ERR("invalid parameter");
2523 return PKGMGR_R_EINVAL;
2526 ret = pkgmgr_client_connection_send_request(client,
2527 "unset_restriction_mode",
2528 g_variant_new("(usi)", uid, "", mode), &result);
2529 if (ret != PKGMGR_R_OK) {
2530 ERR("request failed: %d", ret);
2534 g_variant_get(result, "(i)", &ret);
2535 g_variant_unref(result);
2540 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2542 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2545 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2546 int *mode, uid_t uid)
2549 int ret = PKGMGR_R_ECOMM;
2551 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2554 ERR("invalid parameter");
2555 return PKGMGR_R_EINVAL;
2558 ret = pkgmgr_client_connection_send_request(client,
2559 "get_restriction_mode",
2560 g_variant_new("(us)", uid, ""), &result);
2561 if (ret != PKGMGR_R_OK) {
2562 ERR("request failed: %d", ret);
2566 g_variant_get(result, "(ii)", &m, &ret);
2567 g_variant_unref(result);
2568 if (ret != PKGMGR_R_OK)
2576 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2578 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2581 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2584 pkg_plugin_set *plugin_set;
2585 package_manager_pkg_detail_info_t *info;
2588 if (pkg_path == NULL) {
2589 ERR("invalid parameter");
2593 pkg_type = __get_type_from_path(pkg_path);
2594 if (pkg_type == NULL) {
2595 ERR("cannot get pkg type");
2599 plugin_set = _package_manager_load_library(pkg_type);
2600 if (plugin_set == NULL) {
2601 ERR("failed to load library for %s", pkg_type);
2606 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2608 ERR("out of memory");
2613 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2615 ERR("get_pkg_detail_info_from_package failed");
2623 return (pkgmgr_info *)info;
2626 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2628 package_manager_pkg_detail_info_t *pkg_info =
2629 (package_manager_pkg_detail_info_t *)info;
2632 ERR("invalid parameter");
2633 return PKGMGR_R_EINVAL;
2636 g_list_free_full(pkg_info->privilege_list, free);
2637 free(pkg_info->icon_buf);
2643 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2644 char *label, uid_t uid)
2648 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2650 if (pc == NULL || appid == NULL || label == NULL) {
2651 ERR("Invalid parameter");
2652 return PKGMGR_R_EINVAL;
2655 ret = pkgmgr_client_connection_send_request(client,
2657 g_variant_new("(uss)", uid, appid, label), &result);
2658 if (ret != PKGMGR_R_OK) {
2659 ERR("Request failed: %d", ret);
2663 g_variant_get(result, "(i)", &ret);
2664 g_variant_unref(result);
2669 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2671 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2674 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2675 char *icon_path, uid_t uid)
2679 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2681 if (pc == NULL || appid == NULL || icon_path == NULL) {
2682 ERR("Invalid parameter");
2683 return PKGMGR_R_EINVAL;
2686 if (access(icon_path, F_OK) != 0) {
2687 ERR("failed to access: %s", icon_path);
2688 return PKGMGR_R_EINVAL;
2691 ret = pkgmgr_client_connection_send_request(client,
2693 g_variant_new("(uss)", uid, appid, icon_path), &result);
2694 if (ret != PKGMGR_R_OK) {
2695 ERR("Request failed: %d", ret);
2699 g_variant_get(result, "(i)", &ret);
2700 g_variant_unref(result);
2705 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2707 return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2710 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2712 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2715 ERR("invalid parameter");
2716 return PKGMGR_R_EINVAL;
2719 client->debug_mode = debug_mode;
2724 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2726 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2729 ERR("invalid parameter");
2730 return PKGMGR_R_EINVAL;
2733 client->skip_optimization = skip_optimization;
2738 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2739 const char *pkgid, uid_t uid)
2742 int ret = PKGMGR_R_ECOMM;
2743 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2746 ERR("invalid parameter");
2747 return PKGMGR_R_EINVAL;
2750 ret = pkgmgr_client_connection_send_request(client,
2751 "migrate_external_image",
2752 g_variant_new("(us)", uid, pkgid), &result);
2753 if (ret != PKGMGR_R_OK) {
2754 ERR("request failed: %d", ret);
2758 g_variant_get(result, "(i)", &ret);
2759 g_variant_unref(result);
2764 API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
2765 const char *src_path, const char *dest_path)
2767 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2769 if (pc == NULL || src_path == NULL) {
2770 ERR("invalid parameter");
2771 return PKGMGR_R_EINVAL;
2774 if (client->res_copy_builder == NULL) {
2775 client->res_copy_builder =
2776 g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
2777 if (client->res_copy_builder == NULL) {
2778 ERR("out of memory");
2779 return PKGMGR_R_ENOMEM;
2783 g_variant_builder_add(client->res_copy_builder, "(ss)",
2784 src_path, dest_path ? dest_path : "");
2789 API int pkgmgr_client_res_copy(pkgmgr_client *pc,
2790 pkgmgr_res_copy_handler event_cb, void *user_data)
2794 char *req_key = NULL;
2795 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2796 struct cb_info *cb_info;
2798 if (pc == NULL || event_cb == NULL) {
2799 ERR("invalid parameter");
2800 return PKGMGR_R_EINVAL;
2803 ret = pkgmgr_client_connection_send_request(client,
2805 g_variant_new("(a(ss))",
2806 client->res_copy_builder), &result);
2807 if (ret != PKGMGR_R_OK) {
2808 ERR("request failed: %d", ret);
2812 g_variant_get(result, "(i&s)", &ret, &req_key);
2813 if (req_key == NULL) {
2814 g_variant_unref(result);
2815 return PKGMGR_R_ECOMM;
2817 if (ret != PKGMGR_R_OK) {
2818 g_variant_unref(result);
2822 cb_info = __create_res_copy_event_cb_info(client,
2823 event_cb, user_data, req_key);
2824 g_variant_unref(result);
2825 if (cb_info == NULL)
2826 return PKGMGR_R_ENOMEM;
2828 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2829 if (ret != PKGMGR_R_OK) {
2830 __free_cb_info(cb_info);
2833 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2835 return cb_info->req_id;
2838 API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
2839 const char *res_path)
2841 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2843 if (pc == NULL || res_path == NULL) {
2844 ERR("invalid parameter");
2845 return PKGMGR_R_EINVAL;
2848 if (client->res_remove_builder == NULL) {
2849 client->res_remove_builder =
2850 g_variant_builder_new(G_VARIANT_TYPE("as"));
2851 if (client->res_remove_builder == NULL) {
2852 ERR("out of memory");
2853 return PKGMGR_R_ENOMEM;
2857 g_variant_builder_add(client->res_remove_builder, "s", res_path);
2862 API int pkgmgr_client_res_remove(pkgmgr_client *pc,
2863 pkgmgr_res_copy_handler event_cb, void *user_data)
2867 char *req_key = NULL;
2868 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2869 struct cb_info *cb_info;
2871 if (pc == NULL || event_cb == NULL) {
2872 ERR("invalid parameter");
2873 return PKGMGR_R_EINVAL;
2876 ret = pkgmgr_client_connection_send_request(client,
2878 g_variant_new("(as)",
2879 client->res_remove_builder), &result);
2880 if (ret != PKGMGR_R_OK) {
2881 ERR("request failed: %d", ret);
2885 g_variant_get(result, "(i&s)", &ret, &req_key);
2886 if (req_key == NULL) {
2887 g_variant_unref(result);
2888 return PKGMGR_R_ECOMM;
2890 if (ret != PKGMGR_R_OK) {
2891 g_variant_unref(result);
2895 cb_info = __create_res_copy_event_cb_info(client,
2896 event_cb, user_data, req_key);
2897 g_variant_unref(result);
2898 if (cb_info == NULL)
2899 return PKGMGR_R_ENOMEM;
2901 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2902 if (ret != PKGMGR_R_OK) {
2903 __free_cb_info(cb_info);
2906 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2908 return cb_info->req_id;
2911 API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid,
2912 pkgmgr_res_copy_handler event_cb, void *user_data)
2914 return pkgmgr_client_res_usr_uninstall(pc, pkgid, event_cb,
2915 user_data, _getuid());
2918 API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
2919 pkgmgr_res_copy_handler event_cb, void *user_data, uid_t uid)
2922 int ret = PKGMGR_R_ECOMM;
2923 char *req_key = NULL;
2924 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2925 struct cb_info *cb_info;
2927 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2928 ERR("invalid parameter");
2929 return PKGMGR_R_EINVAL;
2932 ret = pkgmgr_client_connection_send_request(client,
2934 g_variant_new("(us)", uid, pkgid), &result);
2935 if (ret != PKGMGR_R_OK) {
2936 ERR("request failed: %d", ret);
2940 g_variant_get(result, "(i&s)", &ret, &req_key);
2941 if (req_key == NULL) {
2942 g_variant_unref(result);
2943 return PKGMGR_R_ECOMM;
2945 if (ret != PKGMGR_R_OK) {
2946 g_variant_unref(result);
2950 cb_info = __create_res_copy_event_cb_info(client,
2951 event_cb, user_data, req_key);
2952 g_variant_unref(result);
2953 if (cb_info == NULL)
2954 return PKGMGR_R_ENOMEM;
2956 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2957 if (ret != PKGMGR_R_OK) {
2958 __free_cb_info(cb_info);
2961 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2963 return cb_info->req_id;