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_listen_res_copy_status(pkgmgr_client *pc,
1886 pkgmgr_res_copy_handler event_cb, void *data)
1889 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1890 struct cb_info *cb_info;
1892 if (pc == NULL || event_cb == NULL) {
1893 ERR("invalid parameter");
1894 return PKGMGR_R_EINVAL;
1897 if (client->pc_type != PC_LISTENING) {
1898 ERR("client->pc_type is not PC_LISTENING");
1899 return PKGMGR_R_EINVAL;
1902 cb_info = __create_res_copy_event_cb_info(client, event_cb, data, NULL);
1903 if (cb_info == NULL)
1904 return PKGMGR_R_ENOMEM;
1905 cb_info->status_type = client->status_type;
1906 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1907 if (ret != PKGMGR_R_OK) {
1908 __free_cb_info(cb_info);
1911 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1913 return cb_info->req_id;
1916 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1918 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1921 struct cb_info *cb_info;
1924 ERR("invalid parameter");
1925 return PKGMGR_R_EINVAL;
1928 /* unset all callback */
1929 tmp = client->cb_info_list;
1930 while (tmp != NULL) {
1932 cb_info = (struct cb_info *)tmp->data;
1933 pkgmgr_client_connection_unset_callback(pc, cb_info);
1934 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1936 __free_cb_info(cb_info);
1943 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1944 const char *pkgid, const char *key, const char *val)
1946 /* client cannot broadcast signal */
1950 /* TODO: deprecate(or remove) */
1951 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1952 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1953 const char *pkgid, const char *custom_info,
1954 pkgmgr_handler event_cb, void *data)
1956 return pkgmgr_client_usr_request_service(service_type, service_mode,
1957 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1961 API int pkgmgr_client_usr_request_service(
1962 pkgmgr_request_service_type service_type, int service_mode,
1963 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1964 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1969 /* Check for NULL value of service type */
1970 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1971 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1973 switch (service_type) {
1974 case PM_REQUEST_MOVE:
1975 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1976 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1977 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1979 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1982 case PM_REQUEST_GET_SIZE:
1983 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1984 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1985 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1987 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1990 case PM_REQUEST_KILL_APP:
1991 case PM_REQUEST_CHECK_APP:
1992 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1993 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1995 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1997 ERR("__check_app_process fail \n");
2004 ERR("Wrong Request\n");
2014 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2018 struct pkgmgr_client_t *client;
2020 if (pkgid == NULL || uid == GLOBAL_USER) {
2021 ERR("invalid parameter");
2022 return PKGMGR_R_EINVAL;
2025 client = pkgmgr_client_new(PC_REQUEST);
2026 if (client == NULL) {
2027 ERR("out of memory");
2028 return PKGMGR_R_ENOMEM;
2031 ret = pkgmgr_client_connection_send_request(client, "clearcache",
2032 g_variant_new("(us)", uid, pkgid), &result);
2033 if (ret != PKGMGR_R_OK) {
2034 ERR("request failed: %d", ret);
2035 pkgmgr_client_free(client);
2039 g_variant_get(result, "(i)", &ret);
2040 g_variant_unref(result);
2041 pkgmgr_client_free(client);
2046 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2048 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
2051 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2053 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2056 API int pkgmgr_client_clear_all_cache_dir(void)
2058 return pkgmgr_client_usr_clear_cache_dir(
2059 PKG_CLEAR_ALL_CACHE, _getuid());
2062 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
2063 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2066 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2070 /* TODO: deprecate(or remove) */
2071 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
2072 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2073 void *data, uid_t uid)
2076 int ret = PKGMGR_R_ECOMM;
2077 char *req_key = NULL;
2078 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2079 struct cb_info *cb_info;
2081 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2082 ERR("invalid parameter");
2083 return PKGMGR_R_EINVAL;
2086 if (client->pc_type != PC_REQUEST) {
2087 ERR("client->pc_type is not PC_REQUEST");
2088 return PKGMGR_R_EINVAL;
2092 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2093 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2095 get_type = PM_GET_PKG_SIZE_INFO;
2097 ret = pkgmgr_client_connection_send_request(client, "getsize",
2098 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2099 if (ret != PKGMGR_R_OK) {
2100 ERR("request failed: %d", ret);
2104 g_variant_get(result, "(i&s)", &ret, &req_key);
2105 if (req_key == NULL) {
2106 g_variant_unref(result);
2107 return PKGMGR_R_ECOMM;
2109 if (ret != PKGMGR_R_OK) {
2110 g_variant_unref(result);
2114 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
2115 if (cb_info == NULL) {
2116 g_variant_unref(result);
2117 return PKGMGR_R_ENOMEM;
2119 g_variant_unref(result);
2120 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2121 if (ret != PKGMGR_R_OK) {
2122 __free_cb_info(cb_info);
2125 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2130 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2131 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2132 void *user_data, uid_t uid)
2135 int ret = PKGMGR_R_ECOMM;
2136 char *req_key = NULL;
2138 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2139 struct cb_info *cb_info;
2141 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2142 ERR("invalid parameter");
2143 return PKGMGR_R_EINVAL;
2146 if (client->pc_type != PC_REQUEST) {
2147 ERR("client->pc_type is not PC_REQUEST");
2148 return PKGMGR_R_EINVAL;
2151 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2152 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2154 get_type = PM_GET_PKG_SIZE_INFO;
2156 ret = pkgmgr_client_connection_send_request(client, "getsize",
2157 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2158 if (ret != PKGMGR_R_OK) {
2159 ERR("request failed: %d", ret);
2163 g_variant_get(result, "(i&s)", &ret, &req_key);
2164 if (req_key == NULL) {
2165 g_variant_unref(result);
2166 return PKGMGR_R_ECOMM;
2168 if (ret != PKGMGR_R_OK) {
2169 g_variant_unref(result);
2173 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2175 if (cb_info == NULL) {
2176 g_variant_unref(result);
2177 return PKGMGR_R_ENOMEM;
2179 g_variant_unref(result);
2180 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2181 if (ret != PKGMGR_R_OK) {
2182 __free_cb_info(cb_info);
2185 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2190 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2191 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2194 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2195 user_data, _getuid());
2198 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2199 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2200 void *user_data, uid_t uid)
2201 { /* total package size info */
2202 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2203 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2207 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2208 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2210 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2211 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2212 user_data, _getuid());
2215 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2216 const char *resp_data, char **req_data, char **license_url)
2222 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2224 if (pc == NULL || resp_data == NULL || req_data == NULL ||
2225 license_url == NULL) {
2226 ERR("invalid parameter");
2227 return PKGMGR_R_EINVAL;
2230 if (client->pc_type != PC_REQUEST) {
2231 ERR("client->pc_type is not PC_REQUEST");
2232 return PKGMGR_R_EINVAL;
2235 ret = pkgmgr_client_connection_send_request(client,
2236 "generate_license_request",
2237 g_variant_new("(s)", resp_data), &result);
2238 if (ret != PKGMGR_R_OK) {
2239 ERR("request failed: %d", ret);
2243 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2244 if (ret != PKGMGR_R_OK) {
2245 ERR("generate_license_request failed: %d", ret);
2246 g_variant_unref(result);
2250 *req_data = strdup(data);
2251 *license_url = strdup(url);
2253 g_variant_unref(result);
2258 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2262 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2264 if (pc == NULL || resp_data == NULL) {
2265 ERR("invalid parameter");
2266 return PKGMGR_R_EINVAL;
2269 if (client->pc_type != PC_REQUEST) {
2270 ERR("client->pc_type is not PC_REQUEST");
2271 return PKGMGR_R_EINVAL;
2274 ret = pkgmgr_client_connection_send_request(client, "register_license",
2275 g_variant_new("(s)", resp_data), &result);
2276 if (ret != PKGMGR_R_OK) {
2277 ERR("request failed: %d", ret);
2281 g_variant_get(result, "(i)", &ret);
2282 g_variant_unref(result);
2283 if (ret != PKGMGR_R_OK)
2284 ERR("register license failed: %d", ret);
2289 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2290 const char *drm_file_path, const char *decrypted_file_path)
2294 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2296 if (pc == NULL || drm_file_path == NULL ||
2297 decrypted_file_path == NULL) {
2298 ERR("invalid parameter");
2299 return PKGMGR_R_EINVAL;
2302 if (client->pc_type != PC_REQUEST) {
2303 ERR("client->pc_type is not PC_REQUEST");
2304 return PKGMGR_R_EINVAL;
2307 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2308 g_variant_new("(ss)", drm_file_path,
2309 decrypted_file_path), &result);
2310 if (ret != PKGMGR_R_OK) {
2311 ERR("request failed: %d", ret);
2315 g_variant_get(result, "(i)", &ret);
2316 g_variant_unref(result);
2317 if (ret != PKGMGR_R_OK)
2318 ERR("decrypt_package failed: %d", ret);
2323 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2325 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2328 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2329 const char *appid, uid_t uid)
2333 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2335 if (pc == NULL || appid == NULL) {
2336 ERR("Invalid parameter");
2337 return PKGMGR_R_EINVAL;
2340 ret = pkgmgr_client_connection_send_request(client,
2341 "enable_app_splash_screen",
2342 g_variant_new("(us)", uid, appid), &result);
2343 if (ret != PKGMGR_R_OK) {
2344 ERR("request failed: %d", ret);
2348 g_variant_get(result, "(i)", &ret);
2349 g_variant_unref(result);
2350 if (ret != PKGMGR_R_OK)
2351 ERR("enable splash screen failed: %d", ret);
2356 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2359 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2363 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2364 const char *appid, uid_t uid)
2368 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2370 if (pc == NULL || appid == NULL) {
2371 ERR("Invalid parameter");
2372 return PKGMGR_R_EINVAL;
2375 ret = pkgmgr_client_connection_send_request(client,
2376 "disable_app_splash_screen",
2377 g_variant_new("(us)", uid, appid), &result);
2378 if (ret != PKGMGR_R_OK) {
2379 ERR("request failed: %d", ret);
2383 g_variant_get(result, "(i)", &ret);
2384 g_variant_unref(result);
2385 if (ret != PKGMGR_R_OK)
2386 ERR("disable splash screen failed: %d", ret);
2391 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2392 int mode, uid_t uid)
2395 int ret = PKGMGR_R_ECOMM;
2396 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2398 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2399 ERR("invalid parameter");
2400 return PKGMGR_R_EINVAL;
2403 ret = pkgmgr_client_connection_send_request(client,
2404 "set_restriction_mode",
2405 g_variant_new("(usi)", uid, pkgid, mode), &result);
2406 if (ret != PKGMGR_R_OK) {
2407 ERR("request failed: %d", ret);
2411 g_variant_get(result, "(i)", &ret);
2412 g_variant_unref(result);
2417 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2418 const char *pkgid, int mode, uid_t uid)
2420 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2423 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2424 const char *pkgid, int mode)
2426 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2430 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2431 int mode, uid_t uid)
2434 int ret = PKGMGR_R_ECOMM;
2435 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2437 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2438 ERR("invalid parameter");
2439 return PKGMGR_R_EINVAL;
2442 ret = pkgmgr_client_connection_send_request(client,
2443 "unset_restriction_mode",
2444 g_variant_new("(usi)", uid, pkgid, mode), &result);
2445 if (ret != PKGMGR_R_OK) {
2446 ERR("request failed: %d", ret);
2450 g_variant_get(result, "(i)", &ret);
2451 g_variant_unref(result);
2457 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2458 const char *pkgid, int mode, uid_t uid)
2460 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2463 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2464 const char *pkgid, int mode)
2466 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2470 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2471 int *mode, uid_t uid)
2474 int ret = PKGMGR_R_ECOMM;
2476 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2478 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2479 ERR("invalid parameter");
2480 return PKGMGR_R_EINVAL;
2483 ret = pkgmgr_client_connection_send_request(client,
2484 "get_restriction_mode",
2485 g_variant_new("(us)", uid, pkgid), &result);
2486 if (ret != PKGMGR_R_OK) {
2487 ERR("request failed: %d", ret);
2491 g_variant_get(result, "(ii)", &m, &ret);
2492 g_variant_unref(result);
2493 if (ret != PKGMGR_R_OK)
2501 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2502 const char *pkgid, int *mode, uid_t uid)
2504 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2507 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2508 const char *pkgid, int *mode)
2510 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2514 API int pkgmgr_client_usr_set_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 "set_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_set_restriction_mode(pkgmgr_client *pc, int mode)
2542 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2545 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2549 int ret = PKGMGR_R_ECOMM;
2550 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2553 ERR("invalid parameter");
2554 return PKGMGR_R_EINVAL;
2557 ret = pkgmgr_client_connection_send_request(client,
2558 "unset_restriction_mode",
2559 g_variant_new("(usi)", uid, "", mode), &result);
2560 if (ret != PKGMGR_R_OK) {
2561 ERR("request failed: %d", ret);
2565 g_variant_get(result, "(i)", &ret);
2566 g_variant_unref(result);
2571 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2573 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2576 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2577 int *mode, uid_t uid)
2580 int ret = PKGMGR_R_ECOMM;
2582 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2585 ERR("invalid parameter");
2586 return PKGMGR_R_EINVAL;
2589 ret = pkgmgr_client_connection_send_request(client,
2590 "get_restriction_mode",
2591 g_variant_new("(us)", uid, ""), &result);
2592 if (ret != PKGMGR_R_OK) {
2593 ERR("request failed: %d", ret);
2597 g_variant_get(result, "(ii)", &m, &ret);
2598 g_variant_unref(result);
2599 if (ret != PKGMGR_R_OK)
2607 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2609 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2612 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2615 pkg_plugin_set *plugin_set;
2616 package_manager_pkg_detail_info_t *info;
2619 if (pkg_path == NULL) {
2620 ERR("invalid parameter");
2624 pkg_type = __get_type_from_path(pkg_path);
2625 if (pkg_type == NULL) {
2626 ERR("cannot get pkg type");
2630 plugin_set = _package_manager_load_library(pkg_type);
2631 if (plugin_set == NULL) {
2632 ERR("failed to load library for %s", pkg_type);
2637 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2639 ERR("out of memory");
2644 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2646 ERR("get_pkg_detail_info_from_package failed");
2654 return (pkgmgr_info *)info;
2657 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2659 package_manager_pkg_detail_info_t *pkg_info =
2660 (package_manager_pkg_detail_info_t *)info;
2663 ERR("invalid parameter");
2664 return PKGMGR_R_EINVAL;
2667 g_list_free_full(pkg_info->privilege_list, free);
2668 free(pkg_info->icon_buf);
2674 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2675 char *label, uid_t uid)
2679 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2681 if (pc == NULL || appid == NULL || label == NULL) {
2682 ERR("Invalid parameter");
2683 return PKGMGR_R_EINVAL;
2686 ret = pkgmgr_client_connection_send_request(client,
2688 g_variant_new("(uss)", uid, appid, label), &result);
2689 if (ret != PKGMGR_R_OK) {
2690 ERR("Request failed: %d", ret);
2694 g_variant_get(result, "(i)", &ret);
2695 g_variant_unref(result);
2700 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2702 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2705 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2706 char *icon_path, uid_t uid)
2710 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2712 if (pc == NULL || appid == NULL || icon_path == NULL) {
2713 ERR("Invalid parameter");
2714 return PKGMGR_R_EINVAL;
2717 if (access(icon_path, F_OK) != 0) {
2718 ERR("failed to access: %s", icon_path);
2719 return PKGMGR_R_EINVAL;
2722 ret = pkgmgr_client_connection_send_request(client,
2724 g_variant_new("(uss)", uid, appid, icon_path), &result);
2725 if (ret != PKGMGR_R_OK) {
2726 ERR("Request failed: %d", ret);
2730 g_variant_get(result, "(i)", &ret);
2731 g_variant_unref(result);
2736 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2738 return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2741 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2743 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2746 ERR("invalid parameter");
2747 return PKGMGR_R_EINVAL;
2750 client->debug_mode = debug_mode;
2755 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2757 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2760 ERR("invalid parameter");
2761 return PKGMGR_R_EINVAL;
2764 client->skip_optimization = skip_optimization;
2769 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2770 const char *pkgid, uid_t uid)
2773 int ret = PKGMGR_R_ECOMM;
2774 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2777 ERR("invalid parameter");
2778 return PKGMGR_R_EINVAL;
2781 ret = pkgmgr_client_connection_send_request(client,
2782 "migrate_external_image",
2783 g_variant_new("(us)", uid, pkgid), &result);
2784 if (ret != PKGMGR_R_OK) {
2785 ERR("request failed: %d", ret);
2789 g_variant_get(result, "(i)", &ret);
2790 g_variant_unref(result);
2795 API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
2796 const char *src_path, const char *dest_path)
2798 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2800 if (pc == NULL || src_path == NULL) {
2801 ERR("invalid parameter");
2802 return PKGMGR_R_EINVAL;
2805 if (client->res_copy_builder == NULL) {
2806 client->res_copy_builder =
2807 g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
2808 if (client->res_copy_builder == NULL) {
2809 ERR("out of memory");
2810 return PKGMGR_R_ENOMEM;
2814 g_variant_builder_add(client->res_copy_builder, "(ss)",
2815 src_path, dest_path ? dest_path : "");
2820 API int pkgmgr_client_res_copy(pkgmgr_client *pc,
2821 pkgmgr_res_copy_handler event_cb, void *user_data)
2825 char *req_key = NULL;
2826 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2827 struct cb_info *cb_info;
2829 if (pc == NULL || event_cb == NULL) {
2830 ERR("invalid parameter");
2831 return PKGMGR_R_EINVAL;
2834 ret = pkgmgr_client_connection_send_request(client,
2836 g_variant_new("(a(ss))",
2837 client->res_copy_builder), &result);
2838 if (ret != PKGMGR_R_OK) {
2839 ERR("request failed: %d", ret);
2843 g_variant_get(result, "(i&s)", &ret, &req_key);
2844 if (req_key == NULL) {
2845 g_variant_unref(result);
2846 return PKGMGR_R_ECOMM;
2848 if (ret != PKGMGR_R_OK) {
2849 g_variant_unref(result);
2853 cb_info = __create_res_copy_event_cb_info(client,
2854 event_cb, user_data, req_key);
2855 g_variant_unref(result);
2856 if (cb_info == NULL)
2857 return PKGMGR_R_ENOMEM;
2859 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2860 if (ret != PKGMGR_R_OK) {
2861 __free_cb_info(cb_info);
2864 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2866 return cb_info->req_id;
2869 API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
2870 const char *res_path)
2872 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2874 if (pc == NULL || res_path == NULL) {
2875 ERR("invalid parameter");
2876 return PKGMGR_R_EINVAL;
2879 if (client->res_remove_builder == NULL) {
2880 client->res_remove_builder =
2881 g_variant_builder_new(G_VARIANT_TYPE("as"));
2882 if (client->res_remove_builder == NULL) {
2883 ERR("out of memory");
2884 return PKGMGR_R_ENOMEM;
2888 g_variant_builder_add(client->res_remove_builder, "s", res_path);
2893 API int pkgmgr_client_res_remove(pkgmgr_client *pc,
2894 pkgmgr_res_copy_handler event_cb, void *user_data)
2898 char *req_key = NULL;
2899 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2900 struct cb_info *cb_info;
2902 if (pc == NULL || event_cb == NULL) {
2903 ERR("invalid parameter");
2904 return PKGMGR_R_EINVAL;
2907 ret = pkgmgr_client_connection_send_request(client,
2909 g_variant_new("(as)",
2910 client->res_remove_builder), &result);
2911 if (ret != PKGMGR_R_OK) {
2912 ERR("request failed: %d", ret);
2916 g_variant_get(result, "(i&s)", &ret, &req_key);
2917 if (req_key == NULL) {
2918 g_variant_unref(result);
2919 return PKGMGR_R_ECOMM;
2921 if (ret != PKGMGR_R_OK) {
2922 g_variant_unref(result);
2926 cb_info = __create_res_copy_event_cb_info(client,
2927 event_cb, user_data, req_key);
2928 g_variant_unref(result);
2929 if (cb_info == NULL)
2930 return PKGMGR_R_ENOMEM;
2932 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2933 if (ret != PKGMGR_R_OK) {
2934 __free_cb_info(cb_info);
2937 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2939 return cb_info->req_id;
2942 API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid,
2943 pkgmgr_res_copy_handler event_cb, void *user_data)
2945 return pkgmgr_client_res_usr_uninstall(pc, pkgid, event_cb,
2946 user_data, _getuid());
2949 API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
2950 pkgmgr_res_copy_handler event_cb, void *user_data, uid_t uid)
2953 int ret = PKGMGR_R_ECOMM;
2954 char *req_key = NULL;
2955 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2956 struct cb_info *cb_info;
2958 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2959 ERR("invalid parameter");
2960 return PKGMGR_R_EINVAL;
2963 ret = pkgmgr_client_connection_send_request(client,
2965 g_variant_new("(us)", uid, pkgid), &result);
2966 if (ret != PKGMGR_R_OK) {
2967 ERR("request failed: %d", ret);
2971 g_variant_get(result, "(i&s)", &ret, &req_key);
2972 if (req_key == NULL) {
2973 g_variant_unref(result);
2974 return PKGMGR_R_ECOMM;
2976 if (ret != PKGMGR_R_OK) {
2977 g_variant_unref(result);
2981 cb_info = __create_res_copy_event_cb_info(client,
2982 event_cb, user_data, req_key);
2983 g_variant_unref(result);
2984 if (cb_info == NULL)
2985 return PKGMGR_R_ENOMEM;
2987 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2988 if (ret != PKGMGR_R_OK) {
2989 __free_cb_info(cb_info);
2992 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2994 return cb_info->req_id;