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 "package-manager-types.h"
44 #include "pkgmgr_client_debug.h"
45 #include "pkgmgr_client_internal.h"
47 /* API export macro */
49 #define API __attribute__ ((visibility("default")))
52 #define BINSH_NAME "/bin/sh"
55 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
56 #define REGULAR_USER 5000
58 static GList *jobs_to_free;
59 static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER;
61 static inline uid_t _getuid(void)
65 if (uid < REGULAR_USER)
71 static int _get_internal_request_id()
73 static int internal_req_id = 1;
75 return internal_req_id++;
78 static char *_generate_request_id(void)
84 gettimeofday(&tv, NULL);
85 curtime = tv.tv_sec * 1000000 + tv.tv_usec;
87 snprintf(buf, sizeof(buf), "%d_%ld", getpid(), curtime);
92 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
93 pkgmgr_handler event_cb, void *data, const char *req_key)
95 struct cb_info *cb_info;
97 cb_info = calloc(1, sizeof(struct cb_info));
98 if (cb_info == NULL) {
102 cb_info->client = client;
103 cb_info->event_cb = event_cb;
104 cb_info->data = data;
105 cb_info->req_id = _get_internal_request_id();
106 if (req_key != NULL) {
107 cb_info->req_key = strdup(req_key);
108 if (cb_info->req_key == NULL) {
109 ERR("out of memory");
118 static struct cb_info *__create_app_event_cb_info(
119 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
120 void *data, const char *req_key)
122 struct cb_info *cb_info;
124 cb_info = calloc(1, sizeof(struct cb_info));
125 if (cb_info == NULL) {
126 ERR("out of memory");
129 cb_info->client = client;
130 cb_info->app_event_cb = app_event_cb;
131 cb_info->data = data;
132 cb_info->req_id = _get_internal_request_id();
133 if (req_key != NULL) {
134 cb_info->req_key = strdup(req_key);
135 if (cb_info->req_key == NULL) {
136 ERR("out of memory");
145 static struct cb_info *__create_res_event_cb_info(
146 struct pkgmgr_client_t *client,
147 pkgmgr_res_handler res_event_cb,
148 void *data, const char *req_key)
150 struct cb_info *cb_info;
152 cb_info = calloc(1, sizeof(struct cb_info));
153 if (cb_info == NULL) {
154 ERR("out of memory");
158 cb_info->client = client;
159 cb_info->res_event_cb = res_event_cb;
160 cb_info->data = data;
161 cb_info->req_id = _get_internal_request_id();
165 cb_info->req_key = strdup(req_key);
166 if (cb_info->req_key == NULL) {
167 ERR("out of memory");
175 static struct cb_info *__create_upgrade_event_cb_info(
176 struct pkgmgr_client_t *client,
177 pkgmgr_pkg_upgrade_handler upgrade_event_cb,
178 void *data, const char *req_key)
180 struct cb_info *cb_info;
182 cb_info = calloc(1, sizeof(struct cb_info));
183 if (cb_info == NULL) {
184 ERR("out of memory");
188 cb_info->client = client;
189 cb_info->upgrade_event_cb = upgrade_event_cb;
190 cb_info->data = data;
191 cb_info->req_id = _get_internal_request_id();
195 cb_info->req_key = strdup(req_key);
196 if (cb_info->req_key == NULL) {
197 ERR("out of memory");
205 static struct cb_info *__create_size_info_cb_info(
206 struct pkgmgr_client_t *client,
207 pkgmgr_pkg_size_info_receive_cb size_info_cb,
208 void *data, const char *req_key)
210 struct cb_info *cb_info;
212 cb_info = calloc(1, sizeof(struct cb_info));
213 if (cb_info == NULL) {
214 ERR("out of memory");
217 cb_info->client = client;
218 cb_info->size_info_cb = size_info_cb;
219 cb_info->data = data;
220 cb_info->req_id = _get_internal_request_id();
221 if (req_key != NULL) {
222 cb_info->req_key = strdup(req_key);
223 if (cb_info->req_key == NULL) {
224 ERR("out of memory");
233 static int __jobs_to_free_add(gpointer data)
235 pthread_mutex_lock(&__mutex);
236 if (g_list_find(jobs_to_free, data)) {
237 pthread_mutex_unlock(&__mutex);
241 jobs_to_free = g_list_append(jobs_to_free, data);
242 pthread_mutex_unlock(&__mutex);
246 static void __jobs_to_free_remove(gpointer data)
248 pthread_mutex_lock(&__mutex);
249 jobs_to_free = g_list_remove(jobs_to_free, data);
250 pthread_mutex_unlock(&__mutex);
253 static void __do_free_cb_info(gpointer data)
255 struct cb_info *cb_info = (struct cb_info *)data;
257 g_list_free(cb_info->sid_list);
258 free(cb_info->req_key);
262 static void __free_cb_info_cb(gpointer data)
264 g_idle_remove_by_data(data);
265 __do_free_cb_info(data);
268 __attribute__((destructor)) static void __free_cb_info_at_destructor(void)
270 pthread_mutex_lock(&__mutex);
271 g_list_free_full(jobs_to_free, __free_cb_info_cb);
272 pthread_mutex_unlock(&__mutex);
275 static gboolean __free_cb_info_at_idle(gpointer data)
277 __jobs_to_free_remove(data);
278 __do_free_cb_info(data);
280 return G_SOURCE_REMOVE;
283 static void __free_cb_info(struct cb_info *cb_info)
285 if (__jobs_to_free_add(cb_info) < 0)
288 g_idle_add(__free_cb_info_at_idle, cb_info);
291 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
292 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
296 int ret = PKGMGR_R_ECOMM;
297 long long size_info = 0;
298 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
300 if (pc == NULL || pkgid == NULL) {
301 ERR("invalid parameter");
302 return PKGMGR_R_EINVAL;
305 if (client->pc_type != PC_REQUEST) {
306 ERR("client->pc_type is not PC_REQUEST");
307 return PKGMGR_R_EINVAL;
310 ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
311 g_variant_new("(usi)", uid, pkgid, get_type), &result);
312 if (ret != PKGMGR_R_OK) {
313 ERR("request failed: %d", ret);
317 g_variant_get(result, "(ix)", &ret, &size_info);
318 if (ret != PKGMGR_R_OK) {
319 ERR("request result failed: %d", ret);
320 g_variant_unref(result);
325 ERR("invalid size_info=(%lld)", size_info);
328 ret = (int)size_info;
329 DBG("size_info(%lld), return size(%d)", size_info, ret);
332 g_variant_unref(result);
337 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
338 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
339 pkgmgr_handler event_cb, void *data)
343 ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
345 ERR("move request failed");
352 static int __check_app_process(pkgmgr_request_service_type service_type,
353 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
356 int ret = PKGMGR_R_ECOMM;
357 pkgmgrinfo_pkginfo_h handle;
359 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
361 retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
363 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
364 if (ret != PMINFO_R_OK) {
365 ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
366 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
367 return PKGMGR_R_ERROR;
370 if (service_type == PM_REQUEST_KILL_APP) {
371 ret = pkgmgr_client_connection_send_request(client, "kill",
372 g_variant_new("(us)", uid, pkgid), &result);
373 } else if (service_type == PM_REQUEST_CHECK_APP) {
374 ret = pkgmgr_client_connection_send_request(client, "check",
375 g_variant_new("(us)", uid, pkgid), &result);
377 ERR("unexpected service type: %d", service_type);
378 ret = PKGMGR_R_ERROR;
381 if (ret != PKGMGR_R_OK) {
382 ERR("request failed: %d", ret);
383 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
387 g_variant_get(result, "(ii)", &ret, &pid);
388 g_variant_unref(result);
389 if (ret != PKGMGR_R_OK) {
390 ERR("request failed, ret=%d", ret);
391 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
397 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
403 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
405 struct pkgmgr_client_t *client;
407 if (pc_type == PC_BROADCAST) {
408 ERR("broadcast type is not supported");
412 if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
413 ERR("invalid parameter");
417 client = calloc(1, sizeof(struct pkgmgr_client_t));
418 if (client == NULL) {
419 ERR("out of memory");
423 client->pc_type = pc_type;
424 client->status_type = PKGMGR_CLIENT_STATUS_ALL;
426 if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) {
431 return (pkgmgr_client *)client;
434 API int pkgmgr_client_free(pkgmgr_client *pc)
436 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
439 ERR("invalid argument");
440 return PKGMGR_R_EINVAL;
443 pkgmgr_client_remove_listen_status(client);
444 pkgmgr_client_connection_disconnect(client);
445 if (client->tep_path)
446 free(client->tep_path);
447 if (client->res_copy_builder)
448 g_variant_builder_unref(client->res_copy_builder);
449 if (client->res_remove_builder)
450 g_variant_builder_unref(client->res_remove_builder);
451 if (client->res_create_dir_builder)
452 g_variant_builder_unref(client->res_create_dir_builder);
458 struct manifest_and_type type_map[] = {
459 { "res/wgt/config.xml", "wgt" },
460 { "config.xml", "wgt" },
461 { "tizen-manifest.xml", "tpk" },
465 static char *__get_type_from_path(const char *pkg_path)
467 const char *type = NULL;
471 uf = unzOpen(pkg_path);
473 ERR("failed to open zip file %s", pkg_path);
477 for (i = 0; type_map[i].manifest != NULL; i++) {
478 if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
479 DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
480 type = type_map[i].type;
486 return type ? strdup(type) : NULL;
489 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
492 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
494 if (pc == NULL || tep_path == NULL) {
495 ERR("invalied parameter");
496 return PKGMGR_R_EINVAL;
499 if (client->tep_path)
500 free(client->tep_path);
502 client->tep_path = strdup(tep_path);
503 client->tep_move = tep_move;
508 API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
509 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
510 void *data, uid_t uid)
513 GVariantBuilder *pkgs_builder;
515 GVariantBuilder *args_builder;
518 char *req_key = NULL;
519 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
520 struct cb_info *cb_info;
522 char *request_id = NULL;
524 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
525 ERR("invalid parameter");
526 return PKGMGR_R_EINVAL;
529 if (client->pc_type != PC_REQUEST) {
530 ERR("client type is not PC_REQUEST");
531 return PKGMGR_R_EINVAL;
534 for (i = 0; i < n_pkgs; i++) {
535 if (access(pkg_paths[i], F_OK) != 0) {
536 ERR("failed to access: %s", pkg_paths[i]);
537 return PKGMGR_R_EINVAL;
541 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
542 for (i = 0; i < n_pkgs; i++)
543 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
544 pkgs = g_variant_new("as", pkgs_builder);
545 g_variant_builder_unref(pkgs_builder);
547 args_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
548 if (client->debug_mode)
549 g_variant_builder_add(args_builder, "s", "-G");
550 if (client->skip_optimization)
551 g_variant_builder_add(args_builder, "s", "-S");
552 args = g_variant_new("as", args_builder);
553 g_variant_builder_unref(args_builder);
555 request_id = _generate_request_id();
556 ret = pkgmgr_client_connection_send_request(client, "install_pkgs",
557 g_variant_new("(u@as@ass)", uid, pkgs, args,
561 if (ret != PKGMGR_R_OK) {
562 ERR("request failed: %d", ret);
566 g_variant_get(result, "(i&s)", &ret, &req_key);
567 if (req_key == NULL) {
568 g_variant_unref(result);
569 return PKGMGR_R_ECOMM;
571 if (ret != PKGMGR_R_OK) {
572 g_variant_unref(result);
576 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
577 if (cb_info == NULL) {
578 g_variant_unref(result);
579 return PKGMGR_R_ERROR;
581 g_variant_unref(result);
582 ret = pkgmgr_client_connection_set_callback(client, cb_info);
583 if (ret != PKGMGR_R_OK) {
584 __free_cb_info(cb_info);
587 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
589 return cb_info->req_id;
592 API int pkgmgr_client_install_packages(pkgmgr_client *pc,
593 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
596 return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
597 event_cb, data, _getuid());
600 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
601 const char *descriptor_path, const char *pkg_path,
602 const char *optional_data, pkgmgr_mode mode,
603 pkgmgr_handler event_cb, void *data, uid_t uid)
606 int ret = PKGMGR_R_ECOMM;
607 char *req_key = NULL;
608 GVariantBuilder *builder = NULL;
609 GVariant *args = NULL;
610 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
611 struct cb_info *cb_info;
612 char *request_id = NULL;
614 if (pc == NULL || pkg_path == NULL) {
615 ERR("invalid parameter");
616 return PKGMGR_R_EINVAL;
619 if (client->pc_type != PC_REQUEST) {
620 ERR("client type is not PC_REQUEST");
621 return PKGMGR_R_EINVAL;
624 if (access(pkg_path, F_OK) != 0) {
625 ERR("failed to access: %s", pkg_path);
626 return PKGMGR_R_EINVAL;
629 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
630 ERR("failed to access: %s", client->tep_path);
631 return PKGMGR_R_EINVAL;
634 /* build arguments */
635 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
636 if (client->tep_path) {
637 g_variant_builder_add(builder, "s", "-e");
638 g_variant_builder_add(builder, "s", client->tep_path);
639 g_variant_builder_add(builder, "s", "-M");
640 /* TODO: revise tep_move */
641 g_variant_builder_add(builder, "s",
642 client->tep_move ? "tep_move" : "tep_copy");
644 if (client->debug_mode)
645 g_variant_builder_add(builder, "s", "-G");
646 if (client->skip_optimization)
647 g_variant_builder_add(builder, "s", "-S");
649 args = g_variant_new("as", builder);
650 g_variant_builder_unref(builder);
652 request_id = _generate_request_id();
653 ret = pkgmgr_client_connection_send_request(client, "install",
654 g_variant_new("(uss@ass)", uid, pkg_type ? pkg_type : "",
655 pkg_path, args, request_id),
658 if (ret != PKGMGR_R_OK) {
659 ERR("request failed: %d", ret);
663 g_variant_get(result, "(i&s)", &ret, &req_key);
664 if (req_key == NULL) {
665 g_variant_unref(result);
666 return PKGMGR_R_ECOMM;
668 if (ret != PKGMGR_R_OK) {
669 g_variant_unref(result);
673 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
674 if (cb_info == NULL) {
675 g_variant_unref(result);
676 return PKGMGR_R_ENOMEM;
678 g_variant_unref(result);
679 ret = pkgmgr_client_connection_set_callback(client, cb_info);
680 if (ret != PKGMGR_R_OK) {
681 __free_cb_info(cb_info);
684 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
685 return cb_info->req_id;
688 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
689 const char *descriptor_path, const char *pkg_path,
690 const char *optional_data, pkgmgr_mode mode,
691 pkgmgr_handler event_cb, void *data)
693 return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
694 pkg_path, optional_data, mode, event_cb, data,
698 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
699 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
700 pkgmgr_handler event_cb, void *data)
702 return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
703 mode, event_cb, data, _getuid());
706 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
707 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
708 pkgmgr_handler event_cb, void *data, uid_t uid)
711 int ret = PKGMGR_R_ECOMM;
712 char *req_key = NULL;
713 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
714 struct cb_info *cb_info;
716 if (pc == NULL || pkgid == NULL) {
717 ERR("invalid parameter");
718 return PKGMGR_R_EINVAL;
721 if (client->pc_type != PC_REQUEST) {
722 ERR("client->pc_type is not PC_REQUEST");
723 return PKGMGR_R_EINVAL;
726 ret = pkgmgr_client_connection_send_request(client, "reinstall",
727 g_variant_new("(us)", uid, pkgid), &result);
728 if (ret != PKGMGR_R_OK) {
729 ERR("request failed: %d", ret);
733 g_variant_get(result, "(i&s)", &ret, &req_key);
734 if (req_key == NULL) {
735 g_variant_unref(result);
736 return PKGMGR_R_ECOMM;
738 if (ret != PKGMGR_R_OK) {
739 g_variant_unref(result);
743 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
744 if (cb_info == NULL) {
745 g_variant_unref(result);
746 return PKGMGR_R_ENOMEM;
748 g_variant_unref(result);
749 ret = pkgmgr_client_connection_set_callback(client, cb_info);
750 if (ret != PKGMGR_R_OK) {
751 __free_cb_info(cb_info);
754 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
756 return cb_info->req_id;
759 API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
760 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
761 void *data, uid_t uid)
764 GVariantBuilder *pkgs_builder;
766 int ret = PKGMGR_R_ECOMM;
767 char *req_key = NULL;
768 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
769 struct cb_info *cb_info;
771 char *request_id = NULL;
773 if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
774 ERR("invalid parameter");
775 return PKGMGR_R_EINVAL;
778 if (client->pc_type != PC_REQUEST) {
779 ERR("client->pc_type is not PC_REQUEST");
780 return PKGMGR_R_EINVAL;
783 for (i = 0; i < n_pkgs; i++) {
784 if (access(pkg_paths[i], F_OK) != 0) {
785 ERR("failed to access: %s", pkg_paths[i]);
786 return PKGMGR_R_EINVAL;
790 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
791 for (i = 0; i < n_pkgs; i++)
792 g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
793 pkgs = g_variant_new("as", pkgs_builder);
794 g_variant_builder_unref(pkgs_builder);
796 request_id = _generate_request_id();
797 ret = pkgmgr_client_connection_send_request(client,
798 "mount_install_pkgs",
799 g_variant_new("(u@ass)", uid, pkgs, request_id),
802 if (ret != PKGMGR_R_OK) {
803 ERR("request failed: %d", ret);
807 g_variant_get(result, "(i&s)", &ret, &req_key);
808 if (req_key == NULL) {
809 g_variant_unref(result);
810 return PKGMGR_R_ECOMM;
812 if (ret != PKGMGR_R_OK) {
813 g_variant_unref(result);
817 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
818 if (cb_info == NULL) {
819 g_variant_unref(result);
820 return PKGMGR_R_ENOMEM;
822 g_variant_unref(result);
823 ret = pkgmgr_client_connection_set_callback(client, cb_info);
824 if (ret != PKGMGR_R_OK) {
825 __free_cb_info(cb_info);
828 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
830 return cb_info->req_id;
833 API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
834 const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
837 return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
838 event_cb, data, _getuid());
841 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
842 const char *descriptor_path, const char *pkg_path,
843 const char *optional_data, pkgmgr_mode mode,
844 pkgmgr_handler event_cb, void *data, uid_t uid)
847 int ret = PKGMGR_R_ECOMM;
848 char *req_key = NULL;
849 GVariantBuilder *builder = NULL;
850 GVariant *args = NULL;
851 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
852 struct cb_info *cb_info;
853 char *request_id = NULL;
855 if (pc == NULL || pkg_path == NULL) {
856 ERR("invalid parameter");
857 return PKGMGR_R_EINVAL;
860 if (client->pc_type != PC_REQUEST) {
861 ERR("client->pc_type is not PC_REQUEST");
862 return PKGMGR_R_EINVAL;
865 if (access(pkg_path, F_OK) != 0) {
866 ERR("failed to access: %s", pkg_path);
867 return PKGMGR_R_EINVAL;
870 if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
871 ERR("failed to access: %s", client->tep_path);
872 return PKGMGR_R_EINVAL;
875 /* build arguments */
876 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
877 if (client->tep_path) {
878 g_variant_builder_add(builder, "s", "-e");
879 g_variant_builder_add(builder, "s", client->tep_path);
880 g_variant_builder_add(builder, "s", "-M");
881 /* TODO: revise tep_move */
882 g_variant_builder_add(builder, "s",
883 client->tep_move ? "tep_move" : "tep_copy");
886 args = g_variant_new("as", builder);
887 g_variant_builder_unref(builder);
889 request_id = _generate_request_id();
890 ret = pkgmgr_client_connection_send_request(client, "mount_install",
891 g_variant_new("(uss@ass)", uid,
892 pkg_type ? pkg_type : "", pkg_path,
896 if (ret != PKGMGR_R_OK) {
897 ERR("request failed: %d", ret);
901 g_variant_get(result, "(i&s)", &ret, &req_key);
902 if (req_key == NULL) {
903 g_variant_unref(result);
904 return PKGMGR_R_ECOMM;
906 if (ret != PKGMGR_R_OK) {
907 g_variant_unref(result);
911 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
912 if (cb_info == NULL) {
913 g_variant_unref(result);
914 return PKGMGR_R_ENOMEM;
916 g_variant_unref(result);
917 ret = pkgmgr_client_connection_set_callback(client, cb_info);
918 if (ret != PKGMGR_R_OK) {
919 __free_cb_info(cb_info);
922 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
924 return cb_info->req_id;
927 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
928 const char *descriptor_path, const char *pkg_path,
929 const char *optional_data, pkgmgr_mode mode,
930 pkgmgr_handler event_cb, void *data)
932 return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
933 pkg_path, optional_data, mode, event_cb, data,
937 API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
938 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
939 void *data, uid_t uid)
942 GVariantBuilder *pkgs_builder;
944 int ret = PKGMGR_R_ECOMM;
945 char *req_key = NULL;
946 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
947 struct cb_info *cb_info;
950 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
951 ERR("invalid parameter");
952 return PKGMGR_R_EINVAL;
955 if (client->pc_type != PC_REQUEST) {
956 ERR("client->pc_type is not PC_REQUEST");
957 return PKGMGR_R_EINVAL;
960 pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
961 for (i = 0; i < n_pkgs; i++)
962 g_variant_builder_add(pkgs_builder, "s", pkgids[i]);
963 pkgs = g_variant_new("as", pkgs_builder);
964 g_variant_builder_unref(pkgs_builder);
966 ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs",
967 g_variant_new("(u@as)", uid, pkgs), &result);
968 if (ret != PKGMGR_R_OK) {
969 ERR("request failed: %d", ret);
973 g_variant_get(result, "(i&s)", &ret, &req_key);
974 if (req_key == NULL) {
975 g_variant_unref(result);
976 return PKGMGR_R_ECOMM;
978 if (ret != PKGMGR_R_OK) {
979 g_variant_unref(result);
983 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
984 if (cb_info == NULL) {
985 g_variant_unref(result);
986 return PKGMGR_R_ENOMEM;
988 g_variant_unref(result);
989 ret = pkgmgr_client_connection_set_callback(client, cb_info);
990 if (ret != PKGMGR_R_OK) {
991 __free_cb_info(cb_info);
994 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
996 return cb_info->req_id;
999 API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
1000 const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
1003 return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
1004 event_cb, data, _getuid());
1007 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1008 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1011 return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
1015 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1016 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1017 void *data, uid_t uid)
1020 int ret = PKGMGR_R_ECOMM;
1021 char *req_key = NULL;
1022 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1023 struct cb_info *cb_info;
1025 if (pc == NULL || pkgid == NULL) {
1026 ERR("invalid parameter");
1027 return PKGMGR_R_EINVAL;
1030 if (client->pc_type != PC_REQUEST) {
1031 ERR("client->pc_type is not PC_REQUEST");
1032 return PKGMGR_R_EINVAL;
1035 ret = pkgmgr_client_connection_send_request(client, "uninstall",
1036 g_variant_new("(us)", uid, pkgid), &result);
1037 if (ret != PKGMGR_R_OK) {
1038 ERR("request failed: %d", ret);
1042 g_variant_get(result, "(i&s)", &ret, &req_key);
1043 if (req_key == NULL) {
1044 g_variant_unref(result);
1045 return PKGMGR_R_ECOMM;
1047 if (ret != PKGMGR_R_OK) {
1048 g_variant_unref(result);
1052 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1053 if (cb_info == NULL) {
1054 g_variant_unref(result);
1055 return PKGMGR_R_ENOMEM;
1057 g_variant_unref(result);
1058 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1059 if (ret != PKGMGR_R_OK) {
1060 __free_cb_info(cb_info);
1063 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1065 return cb_info->req_id;
1068 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1069 const char *pkgid, pkgmgr_move_type move_type,
1070 pkgmgr_handler event_cb, void *data)
1072 return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
1073 event_cb, data, _getuid());
1075 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1076 const char *pkgid, pkgmgr_move_type move_type,
1077 pkgmgr_handler event_cb, void *data, uid_t uid)
1080 int ret = PKGMGR_R_ECOMM;
1081 char *req_key = NULL;
1082 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1083 struct cb_info *cb_info;
1085 if (pc == NULL || pkgid == NULL) {
1086 ERR("invalid parameter");
1087 return PKGMGR_R_EINVAL;
1090 if ((move_type < PM_MOVE_TO_INTERNAL) ||
1091 (move_type > PM_MOVE_TO_EXTENDED))
1092 return PKGMGR_R_EINVAL;
1094 if (client->pc_type != PC_REQUEST) {
1095 ERR("client->pc_type is not PC_REQUEST");
1096 return PKGMGR_R_EINVAL;
1099 ret = pkgmgr_client_connection_send_request(client, "move",
1100 g_variant_new("(usi)", uid, pkgid, move_type), &result);
1101 if (ret != PKGMGR_R_OK) {
1102 ERR("request failed: %d", ret);
1106 g_variant_get(result, "(i&s)", &ret, &req_key);
1107 if (req_key == NULL) {
1108 g_variant_unref(result);
1109 return PKGMGR_R_ECOMM;
1111 if (ret != PKGMGR_R_OK) {
1112 g_variant_unref(result);
1116 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1117 if (cb_info == NULL) {
1118 g_variant_unref(result);
1119 return PKGMGR_R_ERROR;
1121 g_variant_unref(result);
1122 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1123 if (ret != PKGMGR_R_OK) {
1124 __free_cb_info(cb_info);
1127 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1129 return cb_info->req_id;
1132 API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
1133 pkg_update_info_t *update_info, uid_t uid)
1136 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1139 if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
1140 ERR("invalid parameter");
1141 return PKGMGR_R_EINVAL;
1144 if (client->pc_type != PC_REQUEST) {
1145 ERR("client->pc_type is not PC_REQUEST");
1146 return PKGMGR_R_EINVAL;
1149 ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
1150 g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
1151 update_info->type), &result);
1152 if (ret != PKGMGR_R_OK) {
1153 ERR("request failed: %d", ret);
1157 g_variant_get(result, "(i)", &ret);
1158 if (ret != PKGMGR_R_OK) {
1159 g_variant_unref(result);
1162 g_variant_unref(result);
1167 API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
1168 pkg_update_info_t *update_info)
1170 return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
1174 API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
1175 const char *pkgid, uid_t uid)
1178 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1181 if (pc == NULL || pkgid == NULL) {
1182 ERR("invalid parameter");
1183 return PKGMGR_R_EINVAL;
1186 if (client->pc_type != PC_REQUEST) {
1187 ERR("client->pc_type is not PC_REQUEST");
1188 return PKGMGR_R_EINVAL;
1191 ret = pkgmgr_client_connection_send_request(client,
1192 "unregister_pkg_update_info",
1193 g_variant_new("(us)", uid, pkgid), &result);
1194 if (ret != PKGMGR_R_OK) {
1195 ERR("request failed: %d", ret);
1199 g_variant_get(result, "(i)", &ret);
1200 if (ret != PKGMGR_R_OK) {
1201 g_variant_unref(result);
1204 g_variant_unref(result);
1209 API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
1212 return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
1215 API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
1219 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1223 ERR("invalid parameter");
1224 return PKGMGR_R_EINVAL;
1227 if (client->pc_type != PC_REQUEST) {
1228 ERR("client->pc_type is not PC_REQUEST");
1229 return PKGMGR_R_EINVAL;
1232 ret = pkgmgr_client_connection_send_request(client,
1233 "unregister_all_pkg_update_info",
1234 g_variant_new("(u)", uid), &result);
1235 if (ret != PKGMGR_R_OK) {
1236 ERR("request failed: %d", ret);
1240 g_variant_get(result, "(i)", &ret);
1241 if (ret != PKGMGR_R_OK) {
1242 g_variant_unref(result);
1245 g_variant_unref(result);
1250 API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
1252 return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
1255 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1256 const char *pkgid, uid_t uid)
1259 int ret = PKGMGR_R_ECOMM;
1260 GVariantBuilder *builder;
1261 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1263 if (pc == NULL || pkgid == NULL) {
1264 ERR("invalid parameter");
1265 return PKGMGR_R_EINVAL;
1268 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1269 g_variant_builder_add(builder, "s", pkgid);
1271 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1272 g_variant_new("(uas)", uid, builder), &result);
1273 g_variant_builder_unref(builder);
1274 if (ret != PKGMGR_R_OK) {
1275 ERR("request failed: %d", ret);
1279 g_variant_get(result, "(is)", &ret, NULL);
1280 g_variant_unref(result);
1285 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1288 return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
1291 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
1292 const char *pkg_type, const char **pkgids, int n_pkgs,
1293 pkgmgr_handler event_cb, void *data, uid_t uid)
1296 GVariantBuilder *builder;
1297 int ret = PKGMGR_R_ECOMM;
1298 char *req_key = NULL;
1299 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1300 struct cb_info *cb_info;
1303 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1304 ERR("invalid parameter");
1305 return PKGMGR_R_EINVAL;
1308 if (client->pc_type != PC_REQUEST) {
1309 ERR("client type is not PC_REQUEST");
1310 return PKGMGR_R_EINVAL;
1313 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1314 for (i = 0; i < n_pkgs; i++)
1315 g_variant_builder_add(builder, "s", pkgids[i]);
1317 ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
1318 g_variant_new("(uas)", uid, builder), &result);
1319 g_variant_builder_unref(builder);
1320 if (ret != PKGMGR_R_OK) {
1321 ERR("request failed: %d", ret);
1325 g_variant_get(result, "(i&s)", &ret, &req_key);
1326 if (req_key == NULL) {
1327 g_variant_unref(result);
1328 return PKGMGR_R_ECOMM;
1330 if (ret != PKGMGR_R_OK) {
1331 g_variant_unref(result);
1335 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1336 if (cb_info == NULL) {
1337 g_variant_unref(result);
1338 return PKGMGR_R_ERROR;
1340 g_variant_unref(result);
1341 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1342 if (ret != PKGMGR_R_OK) {
1343 __free_cb_info(cb_info);
1346 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1348 return cb_info->req_id;
1351 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
1352 const char *pkg_type, const char **pkgids, int n_pkgs,
1353 pkgmgr_handler event_cb, void *data)
1355 return pkgmgr_client_usr_activate_packages(pc, pkg_type,
1356 pkgids, n_pkgs, event_cb, data, _getuid());
1359 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1360 const char *pkgid, uid_t uid)
1363 GVariantBuilder *builder;
1364 int ret = PKGMGR_R_ECOMM;
1365 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1367 if (pc == NULL || pkgid == NULL) {
1368 ERR("invalid parameter");
1369 return PKGMGR_R_EINVAL;
1372 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1373 g_variant_builder_add(builder, "s", pkgid);
1375 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1376 g_variant_new("(uas)", uid, builder), &result);
1377 g_variant_builder_unref(builder);
1378 if (ret != PKGMGR_R_OK) {
1379 ERR("request failed: %d", ret);
1383 g_variant_get(result, "(is)", &ret, NULL);
1384 g_variant_unref(result);
1389 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1392 return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1395 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
1396 const char *pkg_type, const char **pkgids, int n_pkgs,
1397 pkgmgr_handler event_cb, void *data, uid_t uid)
1400 GVariantBuilder *builder;
1401 int ret = PKGMGR_R_ECOMM;
1402 char *req_key = NULL;
1403 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1404 struct cb_info *cb_info;
1407 if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
1408 ERR("invalid parameter");
1409 return PKGMGR_R_EINVAL;
1412 if (client->pc_type != PC_REQUEST) {
1413 ERR("client type is not PC_REQUEST");
1414 return PKGMGR_R_EINVAL;
1417 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1418 for (i = 0; i < n_pkgs; i++)
1419 g_variant_builder_add(builder, "s", pkgids[i]);
1421 ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
1422 g_variant_new("(uas)", uid, builder), &result);
1423 g_variant_builder_unref(builder);
1424 if (ret != PKGMGR_R_OK) {
1425 ERR("request failed: %d", ret);
1429 g_variant_get(result, "(i&s)", &ret, &req_key);
1430 if (req_key == NULL) {
1431 g_variant_unref(result);
1432 return PKGMGR_R_ECOMM;
1434 if (ret != PKGMGR_R_OK) {
1435 g_variant_unref(result);
1439 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1440 if (cb_info == NULL) {
1441 g_variant_unref(result);
1442 return PKGMGR_R_ERROR;
1444 g_variant_unref(result);
1445 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1446 if (ret != PKGMGR_R_OK) {
1447 __free_cb_info(cb_info);
1450 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1452 return cb_info->req_id;
1455 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1456 const char *pkg_type, const char **pkgids, int n_pkgs,
1457 pkgmgr_handler event_cb, void *data)
1459 return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1460 pkgids, n_pkgs, event_cb, data, _getuid());
1463 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1464 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1467 int ret = PKGMGR_R_ECOMM;
1468 char *req_key = NULL;
1469 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1470 struct cb_info *cb_info;
1472 if (pc == NULL || appid == NULL) {
1473 ERR("invalid parameter");
1474 return PKGMGR_R_EINVAL;
1477 ret = pkgmgr_client_connection_send_request(client, "enable_app",
1478 g_variant_new("(us)", uid, appid), &result);
1479 if (ret != PKGMGR_R_OK) {
1480 ERR("request failed: %d", ret);
1484 g_variant_get(result, "(i&s)", &ret, &req_key);
1485 if (req_key == NULL) {
1486 g_variant_unref(result);
1487 return PKGMGR_R_ECOMM;
1489 if (ret != PKGMGR_R_OK) {
1490 g_variant_unref(result);
1494 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1496 if (cb_info == NULL) {
1497 g_variant_unref(result);
1498 return PKGMGR_R_ENOMEM;
1500 g_variant_unref(result);
1501 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1502 if (ret != PKGMGR_R_OK) {
1503 __free_cb_info(cb_info);
1506 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1508 return cb_info->req_id;
1511 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1512 pkgmgr_app_handler app_event_cb, void *data)
1514 return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1518 API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
1519 int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1522 GVariantBuilder *builder;
1523 int ret = PKGMGR_R_ECOMM;
1524 char *req_key = NULL;
1525 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1526 struct cb_info *cb_info;
1529 if (pc == NULL || appids == NULL || n_apps < 1) {
1530 ERR("invalid parameter");
1531 return PKGMGR_R_EINVAL;
1534 if (client->pc_type != PC_REQUEST) {
1535 ERR("client type is not PC_REQUEST");
1536 return PKGMGR_R_EINVAL;
1539 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1540 for (i = 0; i < n_apps; i++)
1541 g_variant_builder_add(builder, "s", appids[i]);
1543 ret = pkgmgr_client_connection_send_request(client, "enable_apps",
1544 g_variant_new("(uas)", uid, builder), &result);
1545 g_variant_builder_unref(builder);
1546 if (ret != PKGMGR_R_OK) {
1547 ERR("request failed: %d", ret);
1551 g_variant_get(result, "(i&s)", &ret, &req_key);
1552 if (req_key == NULL) {
1553 g_variant_unref(result);
1554 return PKGMGR_R_ECOMM;
1556 if (ret != PKGMGR_R_OK) {
1557 g_variant_unref(result);
1561 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1562 if (cb_info == NULL) {
1563 g_variant_unref(result);
1564 return PKGMGR_R_ERROR;
1566 g_variant_unref(result);
1567 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1568 if (ret != PKGMGR_R_OK) {
1569 __free_cb_info(cb_info);
1572 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1574 return cb_info->req_id;
1577 API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
1578 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1580 return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
1581 app_event_cb, data, _getuid());
1584 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1585 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1588 int ret = PKGMGR_R_ECOMM;
1589 char *req_key = NULL;
1590 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1591 struct cb_info *cb_info;
1593 if (pc == NULL || appid == NULL) {
1594 ERR("invalid parameter");
1595 return PKGMGR_R_EINVAL;
1598 ret = pkgmgr_client_connection_send_request(client,
1599 "enable_global_app_for_uid",
1600 g_variant_new("(us)", uid, appid), &result);
1601 if (ret != PKGMGR_R_OK) {
1602 ERR("request failed: %d", ret);
1606 g_variant_get(result, "(i&s)", &ret, &req_key);
1607 if (req_key == NULL) {
1608 g_variant_unref(result);
1609 return PKGMGR_R_ECOMM;
1611 if (ret != PKGMGR_R_OK) {
1612 g_variant_unref(result);
1616 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1618 if (cb_info == NULL) {
1619 g_variant_unref(result);
1620 return PKGMGR_R_ENOMEM;
1622 g_variant_unref(result);
1623 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1624 if (ret != PKGMGR_R_OK) {
1625 __free_cb_info(cb_info);
1628 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1630 return cb_info->req_id;
1633 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1634 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1637 int ret = PKGMGR_R_ECOMM;
1638 char *req_key = NULL;
1639 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1640 struct cb_info *cb_info;
1642 if (pc == NULL || appid == NULL) {
1643 ERR("invalid parameter");
1644 return PKGMGR_R_EINVAL;
1647 ret = pkgmgr_client_connection_send_request(client, "disable_app",
1648 g_variant_new("(us)", uid, appid), &result);
1649 if (ret != PKGMGR_R_OK) {
1650 ERR("request failed: %d", ret);
1654 g_variant_get(result, "(i&s)", &ret, &req_key);
1655 if (req_key == NULL) {
1656 g_variant_unref(result);
1657 return PKGMGR_R_ECOMM;
1659 if (ret != PKGMGR_R_OK) {
1660 g_variant_unref(result);
1664 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1666 if (cb_info == NULL) {
1667 g_variant_unref(result);
1668 return PKGMGR_R_ENOMEM;
1670 g_variant_unref(result);
1671 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1672 if (ret != PKGMGR_R_OK) {
1673 __free_cb_info(cb_info);
1676 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1678 return cb_info->req_id;
1681 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1682 pkgmgr_app_handler app_event_cb, void *data)
1684 return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
1688 API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
1689 const char **appids, int n_apps,
1690 pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1693 GVariantBuilder *builder;
1694 int ret = PKGMGR_R_ECOMM;
1695 char *req_key = NULL;
1696 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1697 struct cb_info *cb_info;
1700 if (pc == NULL || appids == NULL || n_apps < 1) {
1701 ERR("invalid parameter");
1702 return PKGMGR_R_EINVAL;
1705 if (client->pc_type != PC_REQUEST) {
1706 ERR("client type is not PC_REQUEST");
1707 return PKGMGR_R_EINVAL;
1710 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1711 for (i = 0; i < n_apps; i++)
1712 g_variant_builder_add(builder, "s", appids[i]);
1714 ret = pkgmgr_client_connection_send_request(client, "disable_apps",
1715 g_variant_new("(uas)", uid, builder), &result);
1716 g_variant_builder_unref(builder);
1717 if (ret != PKGMGR_R_OK) {
1718 ERR("request failed: %d", ret);
1722 g_variant_get(result, "(i&s)", &ret, &req_key);
1723 if (req_key == NULL) {
1724 g_variant_unref(result);
1725 return PKGMGR_R_ECOMM;
1727 if (ret != PKGMGR_R_OK) {
1728 g_variant_unref(result);
1732 cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
1733 if (cb_info == NULL) {
1734 g_variant_unref(result);
1735 return PKGMGR_R_ERROR;
1737 g_variant_unref(result);
1738 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1739 if (ret != PKGMGR_R_OK) {
1740 __free_cb_info(cb_info);
1743 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1745 return cb_info->req_id;
1748 API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
1749 int n_apps, pkgmgr_app_handler app_event_cb, void *data)
1751 return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
1752 app_event_cb, data, _getuid());
1755 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1756 const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
1759 int ret = PKGMGR_R_ECOMM;
1760 char *req_key = NULL;
1761 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1762 struct cb_info *cb_info;
1764 if (pc == NULL || appid == NULL) {
1765 ERR("invalid parameter");
1766 return PKGMGR_R_EINVAL;
1769 ret = pkgmgr_client_connection_send_request(client,
1770 "disable_global_app_for_uid",
1771 g_variant_new("(us)", uid, appid), &result);
1772 if (ret != PKGMGR_R_OK) {
1773 ERR("request failed: %d", ret);
1777 g_variant_get(result, "(i&s)", &ret, &req_key);
1778 if (req_key == NULL) {
1779 g_variant_unref(result);
1780 return PKGMGR_R_ECOMM;
1782 if (ret != PKGMGR_R_OK) {
1783 g_variant_unref(result);
1787 cb_info = __create_app_event_cb_info(client, app_event_cb, data,
1789 if (cb_info == NULL) {
1790 g_variant_unref(result);
1791 return PKGMGR_R_ENOMEM;
1793 g_variant_unref(result);
1794 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1795 if (ret != PKGMGR_R_OK) {
1796 __free_cb_info(cb_info);
1799 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1801 return cb_info->req_id;
1804 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1805 const char *pkg_type, const char *pkgid, pkgmgr_mode mode,
1810 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1812 if (pc == NULL || pkgid == NULL || uid == GLOBAL_USER) {
1813 ERR("invalid parameter");
1814 return PKGMGR_R_EINVAL;
1817 if (client->pc_type != PC_REQUEST) {
1818 ERR("client->pc_type is not PC_REQUEST");
1819 return PKGMGR_R_EINVAL;
1822 ret = pkgmgr_client_connection_send_request(client, "cleardata",
1823 g_variant_new("(us)", uid, pkgid), &result);
1824 if (ret != PKGMGR_R_OK) {
1825 ERR("request failed: %d", ret);
1829 g_variant_get(result, "(i)", &ret);
1830 g_variant_unref(result);
1835 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1836 const char *pkgid, pkgmgr_mode mode)
1838 return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode,
1842 API int pkgmgr_client_usr_clear_user_data_with_path(pkgmgr_client *pc,
1843 const char *pkg_type, const char *pkgid, const char *file_path,
1844 pkgmgr_mode mode, uid_t uid)
1848 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1850 if (!pc || !pkgid || !file_path || uid == GLOBAL_USER) {
1851 ERR("invalid parameter");
1852 return PKGMGR_R_EINVAL;
1855 if (client->pc_type != PC_REQUEST) {
1856 ERR("client->pc_type is not PC_REQUEST");
1857 return PKGMGR_R_EINVAL;
1860 ret = pkgmgr_client_connection_send_request(client, "cleardata_with_path",
1861 g_variant_new("(uss)", uid, pkgid, file_path), &result);
1862 if (ret != PKGMGR_R_OK) {
1863 ERR("request failed: %d", ret);
1867 g_variant_get(result, "(i)", &ret);
1868 g_variant_unref(result);
1873 API int pkgmgr_client_clear_user_data_with_path(pkgmgr_client *pc, const char *pkg_type,
1874 const char *pkgid, const char *file_path, pkgmgr_mode mode)
1876 return pkgmgr_client_usr_clear_user_data_with_path(pc, pkg_type, pkgid,
1877 file_path, mode, _getuid());
1880 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1882 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1885 ERR("invalid parameter");
1886 return PKGMGR_R_EINVAL;
1889 client->status_type = status_type;
1894 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1898 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1899 struct cb_info *cb_info;
1901 if (pc == NULL || event_cb == NULL) {
1902 ERR("invalid parameter");
1903 return PKGMGR_R_EINVAL;
1906 if (client->pc_type != PC_LISTENING) {
1907 ERR("client->pc_type is not PC_LISTENING");
1908 return PKGMGR_R_EINVAL;
1911 cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1912 if (cb_info == NULL)
1913 return PKGMGR_R_ENOMEM;
1914 cb_info->status_type = client->status_type;
1915 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1916 if (ret != PKGMGR_R_OK) {
1917 __free_cb_info(cb_info);
1920 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1922 return cb_info->req_id;
1925 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1926 pkgmgr_app_handler app_event_cb, void *data)
1929 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1930 struct cb_info *cb_info;
1932 if (pc == NULL || app_event_cb == NULL) {
1933 ERR("invalid parameter");
1934 return PKGMGR_R_EINVAL;
1937 if (client->pc_type != PC_LISTENING) {
1938 ERR("client->pc_type is not PC_LISTENING");
1939 return PKGMGR_R_EINVAL;
1942 cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1943 if (cb_info == NULL)
1944 return PKGMGR_R_ENOMEM;
1945 cb_info->status_type = client->status_type;
1946 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1947 if (ret != PKGMGR_R_OK) {
1948 __free_cb_info(cb_info);
1951 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1953 return cb_info->req_id;
1956 API int pkgmgr_client_listen_res_status(pkgmgr_client *pc,
1957 pkgmgr_res_handler event_cb, void *data)
1960 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1961 struct cb_info *cb_info;
1963 if (pc == NULL || event_cb == NULL) {
1964 ERR("invalid parameter");
1965 return PKGMGR_R_EINVAL;
1968 if (client->pc_type != PC_LISTENING) {
1969 ERR("client->pc_type is not PC_LISTENING");
1970 return PKGMGR_R_EINVAL;
1973 cb_info = __create_res_event_cb_info(client, event_cb, data, NULL);
1974 if (cb_info == NULL)
1975 return PKGMGR_R_ENOMEM;
1976 cb_info->status_type = client->status_type;
1977 ret = pkgmgr_client_connection_set_callback(client, cb_info);
1978 if (ret != PKGMGR_R_OK) {
1979 __free_cb_info(cb_info);
1982 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1984 return cb_info->req_id;
1987 API int pkgmgr_client_listen_pkg_upgrade_status(pkgmgr_client *pc,
1988 pkgmgr_pkg_upgrade_handler event_cb, void *data)
1991 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1992 struct cb_info *cb_info;
1994 if (pc == NULL || event_cb == NULL) {
1995 ERR("invalid parameter");
1996 return PKGMGR_R_EINVAL;
1999 if (client->pc_type != PC_LISTENING) {
2000 ERR("client->pc_type is not PC_LISTENING");
2001 return PKGMGR_R_EINVAL;
2004 cb_info = __create_upgrade_event_cb_info(client, event_cb, data, NULL);
2005 if (cb_info == NULL)
2006 return PKGMGR_R_ENOMEM;
2007 cb_info->status_type = client->status_type;
2008 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2009 if (ret != PKGMGR_R_OK) {
2010 __free_cb_info(cb_info);
2013 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2015 return cb_info->req_id;
2018 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
2020 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2023 struct cb_info *cb_info;
2026 ERR("invalid parameter");
2027 return PKGMGR_R_EINVAL;
2030 /* unset all callback */
2031 tmp = client->cb_info_list;
2032 while (tmp != NULL) {
2034 cb_info = (struct cb_info *)tmp->data;
2035 pkgmgr_client_connection_unset_callback(pc, cb_info);
2036 client->cb_info_list = g_list_delete_link(client->cb_info_list,
2038 __free_cb_info(cb_info);
2045 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
2046 const char *pkgid, const char *key, const char *val)
2048 /* client cannot broadcast signal */
2052 /* TODO: deprecate(or remove) */
2053 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
2054 int service_mode, pkgmgr_client *pc, const char *pkg_type,
2055 const char *pkgid, const char *custom_info,
2056 pkgmgr_handler event_cb, void *data)
2058 return pkgmgr_client_usr_request_service(service_type, service_mode,
2059 pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
2063 API int pkgmgr_client_usr_request_service(
2064 pkgmgr_request_service_type service_type, int service_mode,
2065 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
2066 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
2071 /* Check for NULL value of service type */
2072 retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
2073 retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
2075 switch (service_type) {
2076 case PM_REQUEST_MOVE:
2077 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2078 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2079 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2081 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
2084 case PM_REQUEST_GET_SIZE:
2085 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2086 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2087 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
2089 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
2092 case PM_REQUEST_KILL_APP:
2093 case PM_REQUEST_CHECK_APP:
2094 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
2095 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
2097 ret = __check_app_process(service_type, pc, pkgid, uid, data);
2099 ERR("__check_app_process fail \n");
2106 ERR("Wrong Request\n");
2116 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2120 struct pkgmgr_client_t *client;
2122 if (pkgid == NULL || uid == GLOBAL_USER) {
2123 ERR("invalid parameter");
2124 return PKGMGR_R_EINVAL;
2127 client = pkgmgr_client_new(PC_REQUEST);
2128 if (client == NULL) {
2129 ERR("out of memory");
2130 return PKGMGR_R_ENOMEM;
2133 ret = pkgmgr_client_connection_send_request(client, "clearcache",
2134 g_variant_new("(us)", uid, pkgid), &result);
2135 if (ret != PKGMGR_R_OK) {
2136 ERR("request failed: %d", ret);
2137 pkgmgr_client_free(client);
2141 g_variant_get(result, "(i)", &ret);
2142 g_variant_unref(result);
2143 pkgmgr_client_free(client);
2148 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2150 return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
2153 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2155 return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2158 API int pkgmgr_client_clear_all_cache_dir(void)
2160 return pkgmgr_client_usr_clear_cache_dir(
2161 PKG_CLEAR_ALL_CACHE, _getuid());
2164 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
2165 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2168 return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2172 /* TODO: deprecate(or remove) */
2173 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
2174 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2175 void *data, uid_t uid)
2178 int ret = PKGMGR_R_ECOMM;
2179 char *req_key = NULL;
2180 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2181 struct cb_info *cb_info;
2183 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2184 ERR("invalid parameter");
2185 return PKGMGR_R_EINVAL;
2188 if (client->pc_type != PC_REQUEST) {
2189 ERR("client->pc_type is not PC_REQUEST");
2190 return PKGMGR_R_EINVAL;
2194 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2195 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2197 get_type = PM_GET_PKG_SIZE_INFO;
2199 ret = pkgmgr_client_connection_send_request(client, "getsize",
2200 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2201 if (ret != PKGMGR_R_OK) {
2202 ERR("request failed: %d", ret);
2206 g_variant_get(result, "(i&s)", &ret, &req_key);
2207 if (req_key == NULL) {
2208 g_variant_unref(result);
2209 return PKGMGR_R_ECOMM;
2211 if (ret != PKGMGR_R_OK) {
2212 g_variant_unref(result);
2216 cb_info = __create_event_cb_info(client, event_cb, data, req_key);
2217 if (cb_info == NULL) {
2218 g_variant_unref(result);
2219 return PKGMGR_R_ENOMEM;
2221 g_variant_unref(result);
2222 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2223 if (ret != PKGMGR_R_OK) {
2224 __free_cb_info(cb_info);
2227 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2232 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2233 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2234 void *user_data, uid_t uid)
2237 int ret = PKGMGR_R_ECOMM;
2238 char *req_key = NULL;
2240 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2241 struct cb_info *cb_info;
2243 if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2244 ERR("invalid parameter");
2245 return PKGMGR_R_EINVAL;
2248 if (client->pc_type != PC_REQUEST) {
2249 ERR("client->pc_type is not PC_REQUEST");
2250 return PKGMGR_R_EINVAL;
2253 if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2254 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2256 get_type = PM_GET_PKG_SIZE_INFO;
2258 ret = pkgmgr_client_connection_send_request(client, "getsize",
2259 g_variant_new("(usi)", uid, pkgid, get_type), &result);
2260 if (ret != PKGMGR_R_OK) {
2261 ERR("request failed: %d", ret);
2265 g_variant_get(result, "(i&s)", &ret, &req_key);
2266 if (req_key == NULL) {
2267 g_variant_unref(result);
2268 return PKGMGR_R_ECOMM;
2270 if (ret != PKGMGR_R_OK) {
2271 g_variant_unref(result);
2275 cb_info = __create_size_info_cb_info(client, event_cb, user_data,
2277 if (cb_info == NULL) {
2278 g_variant_unref(result);
2279 return PKGMGR_R_ENOMEM;
2281 g_variant_unref(result);
2282 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2283 if (ret != PKGMGR_R_OK) {
2284 __free_cb_info(cb_info);
2287 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2292 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
2293 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2296 return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
2297 user_data, _getuid());
2300 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
2301 pkgmgr_total_pkg_size_info_receive_cb event_cb,
2302 void *user_data, uid_t uid)
2303 { /* total package size info */
2304 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2305 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2309 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
2310 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2312 return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
2313 (pkgmgr_pkg_size_info_receive_cb)event_cb,
2314 user_data, _getuid());
2317 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2318 const char *resp_data, char **req_data, char **license_url)
2324 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2326 if (pc == NULL || resp_data == NULL || req_data == NULL ||
2327 license_url == NULL) {
2328 ERR("invalid parameter");
2329 return PKGMGR_R_EINVAL;
2332 if (client->pc_type != PC_REQUEST) {
2333 ERR("client->pc_type is not PC_REQUEST");
2334 return PKGMGR_R_EINVAL;
2337 ret = pkgmgr_client_connection_send_request(client,
2338 "generate_license_request",
2339 g_variant_new("(s)", resp_data), &result);
2340 if (ret != PKGMGR_R_OK) {
2341 ERR("request failed: %d", ret);
2345 g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2346 if (ret != PKGMGR_R_OK) {
2347 ERR("generate_license_request failed: %d", ret);
2348 g_variant_unref(result);
2352 *req_data = strdup(data);
2353 *license_url = strdup(url);
2355 g_variant_unref(result);
2360 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2364 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2366 if (pc == NULL || resp_data == NULL) {
2367 ERR("invalid parameter");
2368 return PKGMGR_R_EINVAL;
2371 if (client->pc_type != PC_REQUEST) {
2372 ERR("client->pc_type is not PC_REQUEST");
2373 return PKGMGR_R_EINVAL;
2376 ret = pkgmgr_client_connection_send_request(client, "register_license",
2377 g_variant_new("(s)", resp_data), &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("register license failed: %d", ret);
2391 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2392 const char *drm_file_path, const char *decrypted_file_path)
2396 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2398 if (pc == NULL || drm_file_path == NULL ||
2399 decrypted_file_path == NULL) {
2400 ERR("invalid parameter");
2401 return PKGMGR_R_EINVAL;
2404 if (client->pc_type != PC_REQUEST) {
2405 ERR("client->pc_type is not PC_REQUEST");
2406 return PKGMGR_R_EINVAL;
2409 ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
2410 g_variant_new("(ss)", drm_file_path,
2411 decrypted_file_path), &result);
2412 if (ret != PKGMGR_R_OK) {
2413 ERR("request failed: %d", ret);
2417 g_variant_get(result, "(i)", &ret);
2418 g_variant_unref(result);
2419 if (ret != PKGMGR_R_OK)
2420 ERR("decrypt_package failed: %d", ret);
2425 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2427 return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2430 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2431 const char *appid, uid_t uid)
2435 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2437 if (pc == NULL || appid == NULL) {
2438 ERR("Invalid parameter");
2439 return PKGMGR_R_EINVAL;
2442 ret = pkgmgr_client_connection_send_request(client,
2443 "enable_app_splash_screen",
2444 g_variant_new("(us)", uid, appid), &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);
2452 if (ret != PKGMGR_R_OK)
2453 ERR("enable splash screen failed: %d", ret);
2458 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2461 return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2465 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2466 const char *appid, uid_t uid)
2470 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2472 if (pc == NULL || appid == NULL) {
2473 ERR("Invalid parameter");
2474 return PKGMGR_R_EINVAL;
2477 ret = pkgmgr_client_connection_send_request(client,
2478 "disable_app_splash_screen",
2479 g_variant_new("(us)", uid, appid), &result);
2480 if (ret != PKGMGR_R_OK) {
2481 ERR("request failed: %d", ret);
2485 g_variant_get(result, "(i)", &ret);
2486 g_variant_unref(result);
2487 if (ret != PKGMGR_R_OK)
2488 ERR("disable splash screen failed: %d", ret);
2493 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2494 int mode, uid_t uid)
2497 int ret = PKGMGR_R_ECOMM;
2498 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2500 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2501 ERR("invalid parameter");
2502 return PKGMGR_R_EINVAL;
2505 ret = pkgmgr_client_connection_send_request(client,
2506 "set_restriction_mode",
2507 g_variant_new("(usi)", uid, pkgid, mode), &result);
2508 if (ret != PKGMGR_R_OK) {
2509 ERR("request failed: %d", ret);
2513 g_variant_get(result, "(i)", &ret);
2514 g_variant_unref(result);
2519 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
2520 const char *pkgid, int mode, uid_t uid)
2522 return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2525 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
2526 const char *pkgid, int mode)
2528 return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
2532 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2533 int mode, uid_t uid)
2536 int ret = PKGMGR_R_ECOMM;
2537 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2539 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2540 ERR("invalid parameter");
2541 return PKGMGR_R_EINVAL;
2544 ret = pkgmgr_client_connection_send_request(client,
2545 "unset_restriction_mode",
2546 g_variant_new("(usi)", uid, pkgid, mode), &result);
2547 if (ret != PKGMGR_R_OK) {
2548 ERR("request failed: %d", ret);
2552 g_variant_get(result, "(i)", &ret);
2553 g_variant_unref(result);
2559 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
2560 const char *pkgid, int mode, uid_t uid)
2562 return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2565 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
2566 const char *pkgid, int mode)
2568 return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
2572 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
2573 int *mode, uid_t uid)
2576 int ret = PKGMGR_R_ECOMM;
2578 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2580 if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2581 ERR("invalid parameter");
2582 return PKGMGR_R_EINVAL;
2585 ret = pkgmgr_client_connection_send_request(client,
2586 "get_restriction_mode",
2587 g_variant_new("(us)", uid, pkgid), &result);
2588 if (ret != PKGMGR_R_OK) {
2589 ERR("request failed: %d", ret);
2593 g_variant_get(result, "(ii)", &m, &ret);
2594 g_variant_unref(result);
2595 if (ret != PKGMGR_R_OK)
2603 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
2604 const char *pkgid, int *mode, uid_t uid)
2606 return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2609 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
2610 const char *pkgid, int *mode)
2612 return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
2616 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2620 int ret = PKGMGR_R_ECOMM;
2621 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2624 ERR("invalid parameter");
2625 return PKGMGR_R_EINVAL;
2628 ret = pkgmgr_client_connection_send_request(client,
2629 "set_restriction_mode",
2630 g_variant_new("(usi)", uid, "", mode), &result);
2631 if (ret != PKGMGR_R_OK) {
2632 ERR("request failed: %d", ret);
2636 g_variant_get(result, "(i)", &ret);
2637 g_variant_unref(result);
2642 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2644 return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2647 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2651 int ret = PKGMGR_R_ECOMM;
2652 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2655 ERR("invalid parameter");
2656 return PKGMGR_R_EINVAL;
2659 ret = pkgmgr_client_connection_send_request(client,
2660 "unset_restriction_mode",
2661 g_variant_new("(usi)", uid, "", mode), &result);
2662 if (ret != PKGMGR_R_OK) {
2663 ERR("request failed: %d", ret);
2667 g_variant_get(result, "(i)", &ret);
2668 g_variant_unref(result);
2673 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2675 return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2678 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2679 int *mode, uid_t uid)
2682 int ret = PKGMGR_R_ECOMM;
2684 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2687 ERR("invalid parameter");
2688 return PKGMGR_R_EINVAL;
2691 ret = pkgmgr_client_connection_send_request(client,
2692 "get_restriction_mode",
2693 g_variant_new("(us)", uid, ""), &result);
2694 if (ret != PKGMGR_R_OK) {
2695 ERR("request failed: %d", ret);
2699 g_variant_get(result, "(ii)", &m, &ret);
2700 g_variant_unref(result);
2701 if (ret != PKGMGR_R_OK)
2709 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2711 return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2714 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2717 pkg_plugin_set *plugin_set;
2718 package_manager_pkg_detail_info_t *info;
2721 if (pkg_path == NULL) {
2722 ERR("invalid parameter");
2726 pkg_type = __get_type_from_path(pkg_path);
2727 if (pkg_type == NULL) {
2728 ERR("cannot get pkg type");
2732 plugin_set = _package_manager_load_library(pkg_type);
2733 if (plugin_set == NULL) {
2734 ERR("failed to load library for %s", pkg_type);
2739 info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2741 ERR("out of memory");
2746 ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2748 ERR("get_pkg_detail_info_from_package failed");
2756 return (pkgmgr_info *)info;
2759 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2761 package_manager_pkg_detail_info_t *pkg_info =
2762 (package_manager_pkg_detail_info_t *)info;
2765 ERR("invalid parameter");
2766 return PKGMGR_R_EINVAL;
2769 g_list_free_full(pkg_info->privilege_list, free);
2770 free(pkg_info->icon_buf);
2776 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2777 char *label, uid_t uid)
2781 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2783 if (pc == NULL || appid == NULL || label == NULL) {
2784 ERR("Invalid parameter");
2785 return PKGMGR_R_EINVAL;
2788 ret = pkgmgr_client_connection_send_request(client,
2790 g_variant_new("(uss)", uid, appid, label), &result);
2791 if (ret != PKGMGR_R_OK) {
2792 ERR("Request failed: %d", ret);
2796 g_variant_get(result, "(i)", &ret);
2797 g_variant_unref(result);
2802 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2804 return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2807 API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
2808 char *icon_path, uid_t uid)
2812 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2814 if (pc == NULL || appid == NULL || icon_path == NULL) {
2815 ERR("Invalid parameter");
2816 return PKGMGR_R_EINVAL;
2819 if (access(icon_path, F_OK) != 0) {
2820 ERR("failed to access: %s", icon_path);
2821 return PKGMGR_R_EINVAL;
2824 ret = pkgmgr_client_connection_send_request(client,
2826 g_variant_new("(uss)", uid, appid, icon_path), &result);
2827 if (ret != PKGMGR_R_OK) {
2828 ERR("Request failed: %d", ret);
2832 g_variant_get(result, "(i)", &ret);
2833 g_variant_unref(result);
2838 API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
2840 return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
2843 API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
2845 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2848 ERR("invalid parameter");
2849 return PKGMGR_R_EINVAL;
2852 client->debug_mode = debug_mode;
2857 API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
2859 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2862 ERR("invalid parameter");
2863 return PKGMGR_R_EINVAL;
2866 client->skip_optimization = skip_optimization;
2871 API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
2872 const char *pkgid, uid_t uid)
2875 int ret = PKGMGR_R_ECOMM;
2876 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2879 ERR("invalid parameter");
2880 return PKGMGR_R_EINVAL;
2883 ret = pkgmgr_client_connection_send_request(client,
2884 "migrate_external_image",
2885 g_variant_new("(us)", uid, pkgid), &result);
2886 if (ret != PKGMGR_R_OK) {
2887 ERR("request failed: %d", ret);
2891 g_variant_get(result, "(i)", &ret);
2892 g_variant_unref(result);
2897 API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
2898 const char *src_path, const char *dest_path)
2900 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2902 if (pc == NULL || src_path == NULL) {
2903 ERR("invalid parameter");
2904 return PKGMGR_R_EINVAL;
2907 if (client->res_copy_builder == NULL) {
2908 client->res_copy_builder =
2909 g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
2910 if (client->res_copy_builder == NULL) {
2911 ERR("out of memory");
2912 return PKGMGR_R_ENOMEM;
2916 g_variant_builder_add(client->res_copy_builder, "(ss)",
2917 src_path, dest_path ? dest_path : "");
2922 API int pkgmgr_client_res_copy(pkgmgr_client *pc,
2923 pkgmgr_res_handler event_cb, void *user_data)
2927 char *req_key = NULL;
2928 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2929 struct cb_info *cb_info;
2931 if (pc == NULL || event_cb == NULL) {
2932 ERR("invalid parameter");
2933 return PKGMGR_R_EINVAL;
2936 ret = pkgmgr_client_connection_send_request(client,
2938 g_variant_new("(a(ss))",
2939 client->res_copy_builder), &result);
2940 if (ret != PKGMGR_R_OK) {
2941 ERR("request failed: %d", ret);
2945 g_variant_get(result, "(i&s)", &ret, &req_key);
2946 if (req_key == NULL) {
2947 g_variant_unref(result);
2948 return PKGMGR_R_ECOMM;
2950 if (ret != PKGMGR_R_OK) {
2951 g_variant_unref(result);
2955 cb_info = __create_res_event_cb_info(client,
2956 event_cb, user_data, req_key);
2957 g_variant_unref(result);
2958 if (cb_info == NULL)
2959 return PKGMGR_R_ENOMEM;
2961 ret = pkgmgr_client_connection_set_callback(client, cb_info);
2962 if (ret != PKGMGR_R_OK) {
2963 __free_cb_info(cb_info);
2966 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
2968 return cb_info->req_id;
2971 API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc,
2972 const char *dir_path)
2974 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2976 if (pc == NULL || dir_path == NULL) {
2977 ERR("invalid parameter");
2978 return PKGMGR_R_EINVAL;
2981 if (client->res_create_dir_builder == NULL) {
2982 client->res_create_dir_builder =
2983 g_variant_builder_new(G_VARIANT_TYPE("as"));
2984 if (client->res_create_dir_builder == NULL) {
2985 ERR("out of memory");
2986 return PKGMGR_R_ENOMEM;
2990 g_variant_builder_add(client->res_create_dir_builder, "s", dir_path);
2995 API int pkgmgr_client_res_create_dir(pkgmgr_client *pc,
2996 pkgmgr_res_handler event_cb, void *user_data)
3000 char *req_key = NULL;
3001 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
3002 struct cb_info *cb_info;
3004 if (pc == NULL || event_cb == NULL) {
3005 ERR("invalid parameter");
3006 return PKGMGR_R_EINVAL;
3009 ret = pkgmgr_client_connection_send_request(client,
3011 g_variant_new("(as)",
3012 client->res_create_dir_builder), &result);
3013 if (ret != PKGMGR_R_OK) {
3014 ERR("request failed: %d", ret);
3018 g_variant_get(result, "(i&s)", &ret, &req_key);
3019 if (req_key == NULL) {
3020 g_variant_unref(result);
3021 return PKGMGR_R_ECOMM;
3023 if (ret != PKGMGR_R_OK) {
3024 g_variant_unref(result);
3028 cb_info = __create_res_event_cb_info(client,
3029 event_cb, user_data, req_key);
3030 g_variant_unref(result);
3031 if (cb_info == NULL)
3032 return PKGMGR_R_ENOMEM;
3034 ret = pkgmgr_client_connection_set_callback(client, cb_info);
3035 if (ret != PKGMGR_R_OK) {
3036 __free_cb_info(cb_info);
3039 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
3041 return cb_info->req_id;
3044 API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
3045 const char *res_path)
3047 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
3049 if (pc == NULL || res_path == NULL) {
3050 ERR("invalid parameter");
3051 return PKGMGR_R_EINVAL;
3054 if (client->res_remove_builder == NULL) {
3055 client->res_remove_builder =
3056 g_variant_builder_new(G_VARIANT_TYPE("as"));
3057 if (client->res_remove_builder == NULL) {
3058 ERR("out of memory");
3059 return PKGMGR_R_ENOMEM;
3063 g_variant_builder_add(client->res_remove_builder, "s", res_path);
3068 API int pkgmgr_client_res_remove(pkgmgr_client *pc,
3069 pkgmgr_res_handler event_cb, void *user_data)
3073 char *req_key = NULL;
3074 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
3075 struct cb_info *cb_info;
3077 if (pc == NULL || event_cb == NULL) {
3078 ERR("invalid parameter");
3079 return PKGMGR_R_EINVAL;
3082 ret = pkgmgr_client_connection_send_request(client,
3084 g_variant_new("(as)",
3085 client->res_remove_builder), &result);
3086 if (ret != PKGMGR_R_OK) {
3087 ERR("request failed: %d", ret);
3091 g_variant_get(result, "(i&s)", &ret, &req_key);
3092 if (req_key == NULL) {
3093 g_variant_unref(result);
3094 return PKGMGR_R_ECOMM;
3096 if (ret != PKGMGR_R_OK) {
3097 g_variant_unref(result);
3101 cb_info = __create_res_event_cb_info(client,
3102 event_cb, user_data, req_key);
3103 g_variant_unref(result);
3104 if (cb_info == NULL)
3105 return PKGMGR_R_ENOMEM;
3107 ret = pkgmgr_client_connection_set_callback(client, cb_info);
3108 if (ret != PKGMGR_R_OK) {
3109 __free_cb_info(cb_info);
3112 client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
3114 return cb_info->req_id;
3117 API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid)
3119 return pkgmgr_client_res_usr_uninstall(pc, pkgid, _getuid());
3122 API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
3126 int ret = PKGMGR_R_ECOMM;
3127 struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
3129 if (pc == NULL || pkgid == NULL) {
3130 ERR("invalid parameter");
3131 return PKGMGR_R_EINVAL;
3134 ret = pkgmgr_client_connection_send_request(client,
3136 g_variant_new("(us)", uid, pkgid), &result);
3137 if (ret != PKGMGR_R_OK) {
3138 ERR("request failed: %d", ret);
3142 g_variant_get(result, "(i)", &ret);
3143 g_variant_unref(result);
3148 API pkgmgr_res_event_info *pkgmgr_res_event_info_new()
3150 pkgmgr_res_event_info_t *info;
3152 info = calloc(1, sizeof(pkgmgr_res_event_info_t));
3154 ERR("out of memory");
3158 return (pkgmgr_res_event_info *)info;
3161 static void __free_path_states(gpointer data)
3163 res_event_path_state_t *path_state = (res_event_path_state_t *)data;
3165 if (path_state == NULL)
3167 if (path_state->path)
3168 free(path_state->path);
3172 API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info)
3174 pkgmgr_res_event_info_t *event_info =
3175 (pkgmgr_res_event_info_t *)info;
3177 if (event_info == NULL) {
3178 ERR("invalid argument");
3179 return PKGMGR_R_EINVAL;
3182 if (event_info->path_states)
3183 g_list_free_full(event_info->path_states, __free_path_states);
3189 API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code)
3191 pkgmgr_res_event_info_t *info = handle;
3193 ERR("invalid parameter");
3194 return PKGMGR_R_EINVAL;
3197 info->error_code = error_code;
3201 API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code)
3203 pkgmgr_res_event_info_t *info = handle;
3204 if (info == NULL || error_code == NULL) {
3205 ERR("invalid parameter");
3206 return PKGMGR_R_EINVAL;
3209 *error_code = info->error_code;
3213 API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle,
3214 const char *path, pkgmgr_res_event_path_state state)
3216 pkgmgr_res_event_info_t *info = handle;
3217 res_event_path_state_t *path_state;
3219 if (info == NULL || path == NULL) {
3220 ERR("invalid parameter");
3221 return PKGMGR_R_EINVAL;
3224 path_state = calloc(1, sizeof(res_event_path_state_t));
3225 if (path_state == NULL) {
3226 ERR("out of memory");
3227 return PKGMGR_R_ENOMEM;
3230 path_state->path = strdup(path);
3231 if (path_state->path == NULL) {
3232 ERR("out of memory");
3234 return PKGMGR_R_ENOMEM;
3236 path_state->state = state;
3238 info->path_states = g_list_prepend(info->path_states , path_state);
3242 API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle,
3243 pkgmgr_res_event_path_cb callback, void *user_data)
3245 pkgmgr_res_event_info_t *info = handle;
3247 res_event_path_state_t *path_state;
3250 ERR("invalid parameter");
3251 return PKGMGR_R_EINVAL;
3254 for (list = info->path_states; list != NULL; list = list->next) {
3255 path_state = (res_event_path_state_t *)list->data;
3256 if (callback(path_state->path, path_state->state,