Fix making gvariant with pkgtype
[platform/core/appfw/slp-pkgmgr.git] / client / src / pkgmgr.c
1 /*
2  * slp-pkgmgr
3  *
4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
5  *
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>
8  *
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
12  *
13  * http://www.apache.org/licenses/LICENSE-2.0
14  *
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.
20  *
21  */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <dlfcn.h>
28 #include <dirent.h>
29 #include <fcntl.h>
30 #include <sys/wait.h>
31 #include <sys/time.h>
32
33 #include <glib.h>
34
35 #include <pkgmgr-info.h>
36 #include <iniparser.h>
37 /* For multi-user support */
38 #include <tzplatform_config.h>
39
40 #include "package-manager.h"
41 #include "pkgmgr_client_debug.h"
42 #include "pkgmgr_client_internal.h"
43
44 /* API export macro */
45 #ifndef API
46 #define API __attribute__ ((visibility("default")))
47 #endif
48
49 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
50
51 #define BINSH_NAME      "/bin/sh"
52 #define BINSH_SIZE      7
53
54 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
55 #define REGULAR_USER 5000
56
57 static inline uid_t _getuid(void)
58 {
59         uid_t uid = getuid();
60
61         if (uid < REGULAR_USER)
62                 return GLOBAL_USER;
63         else
64                 return uid;
65 }
66
67 static int _get_request_id()
68 {
69         static int internal_req_id = 1;
70
71         return internal_req_id++;
72 }
73
74 static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
75                 pkgmgr_handler event_cb, void *data, const char *req_key)
76 {
77         struct cb_info *cb_info;
78
79         cb_info = calloc(1, sizeof(struct cb_info));
80         if (cb_info == NULL) {
81                 ERR("out of memory");
82                 return NULL;
83         }
84         cb_info->client = client;
85         cb_info->event_cb = event_cb;
86         cb_info->data = data;
87         cb_info->req_id = _get_request_id();
88         if (req_key != NULL) {
89                 cb_info->req_key = strdup(req_key);
90                 if (cb_info->req_key == NULL) {
91                         ERR("out of memory");
92                         free(cb_info);
93                         return NULL;
94                 }
95         }
96
97         return cb_info;
98 }
99
100 static struct cb_info *__create_app_event_cb_info(
101                 struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
102                 void *data, const char *req_key)
103 {
104         struct cb_info *cb_info;
105
106         cb_info = calloc(1, sizeof(struct cb_info));
107         if (cb_info == NULL) {
108                 ERR("out of memory");
109                 return NULL;
110         }
111         cb_info->client = client;
112         cb_info->app_event_cb = app_event_cb;
113         cb_info->data = data;
114         cb_info->req_id = _get_request_id();
115         if (req_key != NULL) {
116                 cb_info->req_key = strdup(req_key);
117                 if (cb_info->req_key == NULL) {
118                         ERR("out of memory");
119                         free(cb_info);
120                         return NULL;
121                 }
122         }
123
124         return cb_info;
125 }
126
127 static struct cb_info *__create_size_info_cb_info(
128                 struct pkgmgr_client_t *client,
129                 pkgmgr_pkg_size_info_receive_cb size_info_cb,
130                 void *data, const char *req_key)
131 {
132         struct cb_info *cb_info;
133
134         cb_info = calloc(1, sizeof(struct cb_info));
135         if (cb_info == NULL) {
136                 ERR("out of memory");
137                 return NULL;
138         }
139         cb_info->client = client;
140         cb_info->size_info_cb = size_info_cb;
141         cb_info->data = data;
142         cb_info->req_id = _get_request_id();
143         if (req_key != NULL) {
144                 cb_info->req_key = strdup(req_key);
145                 if (cb_info->req_key == NULL) {
146                         ERR("out of memory");
147                         free(cb_info);
148                         return NULL;
149                 }
150         }
151
152         return cb_info;
153 }
154
155 static void __free_cb_info(struct cb_info *cb_info)
156 {
157         free(cb_info->req_key);
158         free(cb_info);
159 }
160
161 static int __sync_process(const char *req_key)
162 {
163         int ret;
164         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
165         int result = -1;
166         int check_cnt = 0;
167         FILE *fp;
168         char buf[PKG_STRING_LEN_MAX] = {0, };
169
170         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
171         while (1) {
172                 check_cnt++;
173
174                 if (access(info_file, F_OK) == 0) {
175                         fp = fopen(info_file, "r");
176                         if (fp == NULL) {
177                                 DBG("file is not generated yet.... wait\n");
178                                 usleep(100 * 1000);     /* 100ms sleep*/
179                                 continue;
180                         }
181
182                         if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
183                                 ERR("failed to read info file");
184                                 fclose(fp);
185                                 break;
186                         }
187                         fclose(fp);
188
189                         DBG("info_file file is generated, result = %s. \n", buf);
190                         result = atoi(buf);
191                         break;
192                 }
193
194                 DBG("file is not generated yet.... wait\n");
195                 usleep(100 * 1000);     /* 100ms sleep*/
196
197                 if (check_cnt > 6000) { /* 60s * 10 time over*/
198                         ERR("wait time over!!\n");
199                         break;
200                 }
201         }
202
203         ret = remove(info_file);
204         if (ret < 0)
205                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
206
207         return result;
208 }
209
210 static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
211                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
212                 void *data)
213 {
214         GVariant *result;
215         int ret = PKGMGR_R_ECOMM;
216         char *req_key = NULL;
217         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
218
219         if (pc == NULL || pkgid == NULL) {
220                 ERR("invalid parameter");
221                 return PKGMGR_R_EINVAL;
222         }
223
224         if (client->pc_type != PC_REQUEST) {
225                 ERR("client->pc_type is not PC_REQUEST");
226                 return PKGMGR_R_EINVAL;
227         }
228
229         ret = pkgmgr_client_connection_send_request(client, "getsize",
230                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
231         if (ret != PKGMGR_R_OK) {
232                 ERR("request failed: %d", ret);
233                 return ret;
234         }
235
236         g_variant_get(result, "(i&s)", &ret, &req_key);
237         if (req_key == NULL) {
238                 g_variant_unref(result);
239                 return PKGMGR_R_ECOMM;
240         }
241         if (ret != PKGMGR_R_OK) {
242                 g_variant_unref(result);
243                 return ret;
244         }
245
246         ret = __sync_process(req_key);
247         if (ret < 0)
248                 ERR("get size failed, ret=%d\n", ret);
249
250         g_variant_unref(result);
251
252         return ret;
253 }
254
255 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
256                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
257                 pkgmgr_handler event_cb, void *data)
258 {
259         int ret;
260
261         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
262         if (ret < 0) {
263                 ERR("move request failed");
264                 return ret;
265         }
266
267         return ret;
268 }
269
270 static int __check_app_process(pkgmgr_request_service_type service_type,
271                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
272 {
273         GVariant *result;
274         int ret = PKGMGR_R_ECOMM;
275         pkgmgrinfo_pkginfo_h handle;
276         int pid = -1;
277         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
278
279         retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
280
281         if (uid != GLOBAL_USER)
282                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
283         else
284                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
285         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
286
287         if (service_type == PM_REQUEST_KILL_APP)
288                 ret = pkgmgr_client_connection_send_request(client, "kill",
289                                 g_variant_new("(us)", uid, pkgid), &result);
290         else if (service_type == PM_REQUEST_CHECK_APP)
291                 ret = pkgmgr_client_connection_send_request(client, "check",
292                                 g_variant_new("(us)", uid, pkgid), &result);
293         if (ret != PKGMGR_R_OK) {
294                 ERR("request failed: %d", ret);
295                 return ret;
296         }
297
298         g_variant_get(result, "(ii)", &ret, &pid);
299         g_variant_unref(result);
300         if (ret != PKGMGR_R_OK) {
301                 ERR("request failed, ret=%d", ret);
302                 return ret;
303         }
304
305         *(int *)data = pid;
306
307         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
308
309         return ret;
310
311 }
312
313 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
314 {
315         GVariant *result;
316         int ret = PKGMGR_R_ECOMM;
317 //      char *req_key = NULL;
318         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
319
320         if (pc == NULL) {
321                 ERR("invalid parameter");
322                 return PKGMGR_R_EINVAL;
323         }
324
325         if (client->pc_type != PC_REQUEST) {
326                 ERR("client->pc_type is not PC_REQUEST");
327                 return PKGMGR_R_EINVAL;
328         }
329
330         ret = pkgmgr_client_connection_send_request(client, "getsize",
331                         g_variant_new("(usi)", uid, "size_info",
332                                 PM_GET_SIZE_INFO), &result);
333         if (ret != PKGMGR_R_OK) {
334                 ERR("request failed: %d", ret);
335                 return ret;
336         }
337
338 /*
339         g_variant_get(result, "(i&s)", &ret, &req_key);
340         if (req_key == NULL) {
341                 g_variant_unref(result);
342                 return PKGMGR_R_ECOMM;
343         }
344 */
345
346         g_variant_unref(result);
347
348         return ret;
349 }
350
351 API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
352 {
353         struct pkgmgr_client_t *client;
354
355         if (pc_type == PC_BROADCAST) {
356                 ERR("broadcast type is not supported");
357                 return NULL;
358         }
359
360         if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
361                 ERR("invalid parameter");
362                 return NULL;
363         }
364
365         client = calloc(1, sizeof(struct pkgmgr_client_t));
366         if (client == NULL) {
367                 ERR("out of memory");
368                 return NULL;
369         }
370
371         client->pc_type = pc_type;
372         client->status_type = PKGMGR_CLIENT_STATUS_ALL;
373
374         if (pkgmgr_client_connection_connect(client))
375                 return NULL;
376
377         return (pkgmgr_client *)client;
378 }
379
380 API int pkgmgr_client_free(pkgmgr_client *pc)
381 {
382         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
383
384         if (pc == NULL) {
385                 ERR("invalid argument");
386                 return PKGMGR_R_EINVAL;
387         }
388
389         pkgmgr_client_remove_listen_status(client);
390         pkgmgr_client_connection_disconnect(client);
391         if (client->tep_path)
392                 free(client->tep_path);
393         free(client);
394
395         return PKGMGR_R_OK;
396 }
397
398 static char *__get_type_from_path(const char *pkg_path)
399 {
400         int ret;
401         char mimetype[255] = { '\0', };
402         char extlist[256] = { '\0', };
403         char *pkg_type;
404
405         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
406         if (ret) {
407                 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
408                 return NULL;
409         }
410
411         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
412         if (ret) {
413                 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
414                 return NULL;
415         }
416
417         if (strlen(extlist) == 0)
418                 return NULL;
419
420         if (strchr(extlist, ','))
421                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
422
423         pkg_type = strchr(extlist, '.') + 1;
424         return strdup(pkg_type);
425 }
426
427 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
428                 bool tep_move)
429 {
430         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
431
432         if (pc == NULL || tep_path == NULL) {
433                 ERR("invalied parameter");
434                 return PKGMGR_R_EINVAL;
435         }
436
437         if (client->tep_path)
438                 free(client->tep_path);
439
440         client->tep_path = strdup(tep_path);
441         client->tep_move = tep_move;
442
443         return PKGMGR_R_OK;
444 }
445
446 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
447                 const char *descriptor_path, const char *pkg_path,
448                 const char *optional_data, pkgmgr_mode mode,
449                 pkgmgr_handler event_cb, void *data, uid_t uid)
450 {
451         GVariant *result;
452         int ret = PKGMGR_R_ECOMM;
453         char *req_key = NULL;
454         GVariantBuilder *builder = NULL;
455         GVariant *args = NULL;
456         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
457         char *pkgtype = NULL;
458         struct cb_info *cb_info;
459
460         if (pc == NULL || pkg_path == NULL) {
461                 ERR("invalid parameter");
462                 return PKGMGR_R_EINVAL;
463         }
464
465         if (client->pc_type != PC_REQUEST) {
466                 ERR("client type is not PC_REQUEST");
467                 return PKGMGR_R_EINVAL;
468         }
469
470         if (access(pkg_path, F_OK) != 0) {
471                 ERR("failed to access: %s", pkg_path);
472                 return PKGMGR_R_EINVAL;
473         }
474
475         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
476                 ERR("failed to access: %s", client->tep_path);
477                 return PKGMGR_R_EINVAL;
478         }
479
480         if (pkg_type)
481                 pkgtype = strdup(pkg_type);
482
483         /* build arguments */
484         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
485         if (client->tep_path) {
486                 g_variant_builder_add(builder, "s", "-e");
487                 g_variant_builder_add(builder, "s", client->tep_path);
488                 g_variant_builder_add(builder, "s", "-M");
489                 /* TODO: revise tep_move */
490                 g_variant_builder_add(builder, "s",
491                                 client->tep_move ? "tep_move" : "tep_copy");
492         }
493
494         args = g_variant_new("as", builder);
495         g_variant_builder_unref(builder);
496
497         ret = pkgmgr_client_connection_send_request(client, "install",
498                         g_variant_new("(uss@as)", uid, pkgtype ? pkgtype : "",
499                                 pkg_path, args),
500                         &result);
501         if (ret != PKGMGR_R_OK) {
502                 ERR("request failed: %d", ret);
503                 return ret;
504         }
505
506         g_variant_get(result, "(i&s)", &ret, &req_key);
507         if (req_key == NULL) {
508                 g_variant_unref(result);
509                 return PKGMGR_R_ECOMM;
510         }
511         if (ret != PKGMGR_R_OK) {
512                 g_variant_unref(result);
513                 return ret;
514         }
515
516         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
517         if (cb_info == NULL) {
518                 g_variant_unref(result);
519                 return PKGMGR_R_ENOMEM;
520         }
521         g_variant_unref(result);
522         ret = pkgmgr_client_connection_set_callback(client, cb_info);
523         if (ret != PKGMGR_R_OK) {
524                 __free_cb_info(cb_info);
525                 return ret;
526         }
527         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
528
529         return cb_info->req_id;
530 }
531
532 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
533                 const char *descriptor_path, const char *pkg_path,
534                 const char *optional_data, pkgmgr_mode mode,
535                 pkgmgr_handler event_cb, void *data)
536 {
537         return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
538                         pkg_path, optional_data, mode, event_cb, data,
539                         _getuid());
540 }
541
542 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
543                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
544                 pkgmgr_handler event_cb, void *data)
545 {
546         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
547                         mode, event_cb, data, _getuid());
548 }
549
550 API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
551                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
552                 pkgmgr_handler event_cb, void *data, uid_t uid)
553 {
554         GVariant *result;
555         int ret = PKGMGR_R_ECOMM;
556         char *req_key = NULL;
557         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
558         struct cb_info *cb_info;
559
560         if (pc == NULL || pkgid == NULL) {
561                 ERR("invalid parameter");
562                 return PKGMGR_R_EINVAL;
563         }
564
565         if (client->pc_type != PC_REQUEST) {
566                 ERR("client->pc_type is not PC_REQUEST");
567                 return PKGMGR_R_EINVAL;
568         }
569
570         ret = pkgmgr_client_connection_send_request(client, "reinstall",
571                         g_variant_new("(us)", uid, pkgid), &result);
572         if (ret != PKGMGR_R_OK) {
573                 ERR("request failed: %d", ret);
574                 return ret;
575         }
576
577         g_variant_get(result, "(i&s)", &ret, &req_key);
578         if (req_key == NULL) {
579                 g_variant_unref(result);
580                 return PKGMGR_R_ECOMM;
581         }
582         if (ret != PKGMGR_R_OK) {
583                 g_variant_unref(result);
584                 return ret;
585         }
586
587         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
588         if (cb_info == NULL) {
589                 g_variant_unref(result);
590                 return PKGMGR_R_ENOMEM;
591         }
592         g_variant_unref(result);
593         ret = pkgmgr_client_connection_set_callback(client, cb_info);
594         if (ret != PKGMGR_R_OK) {
595                 __free_cb_info(cb_info);
596                 return ret;
597         }
598         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
599
600         return cb_info->req_id;
601 }
602
603 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
604                 const char *descriptor_path, const char *pkg_path,
605                 const char *optional_data, pkgmgr_mode mode,
606                 pkgmgr_handler event_cb, void *data, uid_t uid)
607 {
608         GVariant *result;
609         int ret = PKGMGR_R_ECOMM;
610         char *req_key = NULL;
611         GVariantBuilder *builder = NULL;
612         GVariant *args = NULL;
613         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
614         char *pkgtype = NULL;
615         struct cb_info *cb_info;
616
617         if (pc == NULL || pkg_path == NULL) {
618                 ERR("invalid parameter");
619                 return PKGMGR_R_EINVAL;
620         }
621
622         if (client->pc_type != PC_REQUEST) {
623                 ERR("client->pc_type is not PC_REQUEST");
624                 return PKGMGR_R_EINVAL;
625         }
626
627         if (access(pkg_path, F_OK) != 0) {
628                 ERR("failed to access: %s", pkg_path);
629                 return PKGMGR_R_EINVAL;
630         }
631
632         if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
633                 ERR("failed to access: %s", client->tep_path);
634                 return PKGMGR_R_EINVAL;
635         }
636
637         if (pkg_type)
638                 pkgtype = strdup(pkg_type);
639
640         /* build arguments */
641         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
642         if (client->tep_path) {
643                 g_variant_builder_add(builder, "s", "-e");
644                 g_variant_builder_add(builder, "s", client->tep_path);
645                 g_variant_builder_add(builder, "s", "-M");
646                 /* TODO: revise tep_move */
647                 g_variant_builder_add(builder, "s",
648                                 client->tep_move ? "tep_move" : "tep_copy");
649         }
650
651         args = g_variant_new("as", builder);
652         g_variant_builder_unref(builder);
653
654         ret = pkgmgr_client_connection_send_request(client, "mount_install",
655                         g_variant_new("(uss@as)", uid, pkgtype ? pkgtype : "",
656                                 pkg_path, args),
657                         &result);
658         if (ret != PKGMGR_R_OK) {
659                 ERR("request failed: %d", ret);
660                 return ret;
661         }
662
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;
667         }
668         if (ret != PKGMGR_R_OK) {
669                 g_variant_unref(result);
670                 return ret;
671         }
672
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;
677         }
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);
682                 return ret;
683         }
684         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
685
686         return cb_info->req_id;
687 }
688
689 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
690                 const char *descriptor_path, const char *pkg_path,
691                 const char *optional_data, pkgmgr_mode mode,
692                 pkgmgr_handler event_cb, void *data)
693 {
694         return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
695                         pkg_path, optional_data, mode, event_cb, data,
696                         _getuid());
697 }
698
699 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
700                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
701                 void *data)
702 {
703         return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
704                         data, _getuid());
705 }
706
707 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
708                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
709                 void *data, uid_t uid)
710 {
711         GVariant *result;
712         int ret = PKGMGR_R_ECOMM;
713         char *req_key = NULL;
714         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
715         struct cb_info *cb_info;
716
717         if (pc == NULL || pkgid == NULL) {
718                 ERR("invalid parameter");
719                 return PKGMGR_R_EINVAL;
720         }
721
722         if (client->pc_type != PC_REQUEST) {
723                 ERR("client->pc_type is not PC_REQUEST");
724                 return PKGMGR_R_EINVAL;
725         }
726
727         ret = pkgmgr_client_connection_send_request(client, "uninstall",
728                         g_variant_new("(us)", uid, pkgid), &result);
729         if (ret != PKGMGR_R_OK) {
730                 ERR("request failed: %d", ret);
731                 return ret;
732         }
733
734         g_variant_get(result, "(i&s)", &ret, &req_key);
735         if (req_key == NULL) {
736                 g_variant_unref(result);
737                 return PKGMGR_R_ECOMM;
738         }
739         if (ret != PKGMGR_R_OK) {
740                 g_variant_unref(result);
741                 return ret;
742         }
743
744         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
745         if (cb_info == NULL) {
746                 g_variant_unref(result);
747                 return PKGMGR_R_ENOMEM;
748         }
749         g_variant_unref(result);
750         ret = pkgmgr_client_connection_set_callback(client, cb_info);
751         if (ret != PKGMGR_R_OK) {
752                 __free_cb_info(cb_info);
753                 return ret;
754         }
755         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
756
757         return cb_info->req_id;
758 }
759
760 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
761                 const char *pkgid, pkgmgr_move_type move_type,
762                 pkgmgr_handler event_cb, void *data)
763 {
764         return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
765                         event_cb, data, _getuid());
766 }
767 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
768                 const char *pkgid, pkgmgr_move_type move_type,
769                 pkgmgr_handler event_cb, void *data, uid_t uid)
770 {
771         GVariant *result;
772         int ret = PKGMGR_R_ECOMM;
773         char *req_key = NULL;
774         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
775         struct cb_info *cb_info;
776
777         if (pc == NULL || pkgid == NULL) {
778                 ERR("invalid parameter");
779                 return PKGMGR_R_EINVAL;
780         }
781
782         if ((move_type < PM_MOVE_TO_INTERNAL) ||
783                         (move_type > PM_MOVE_TO_SDCARD))
784                 return PKGMGR_R_EINVAL;
785
786         if (client->pc_type != PC_REQUEST) {
787                 ERR("client->pc_type is not PC_REQUEST");
788                 return PKGMGR_R_EINVAL;
789         }
790
791         ret = pkgmgr_client_connection_send_request(client, "move",
792                         g_variant_new("(usi)", uid, pkgid, move_type), &result);
793         if (ret != PKGMGR_R_OK) {
794                 ERR("request failed: %d", ret);
795                 return ret;
796         }
797
798         g_variant_get(result, "(i&s)", &ret, &req_key);
799         if (req_key == NULL) {
800                 g_variant_unref(result);
801                 return PKGMGR_R_ECOMM;
802         }
803         if (ret != PKGMGR_R_OK) {
804                 g_variant_unref(result);
805                 return ret;
806         }
807
808         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
809         if (cb_info == NULL) {
810                 g_variant_unref(result);
811                 return PKGMGR_R_ERROR;
812         }
813         g_variant_unref(result);
814         ret = pkgmgr_client_connection_set_callback(client, cb_info);
815         if (ret != PKGMGR_R_OK) {
816                 __free_cb_info(cb_info);
817                 return ret;
818         }
819         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
820
821         return cb_info->req_id;
822 }
823
824 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
825                 const char *pkgid, uid_t uid)
826 {
827         GVariant *result;
828         int ret = PKGMGR_R_ECOMM;
829         GVariantBuilder *builder;
830         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
831
832         if (pc == NULL || pkgid == NULL) {
833                 ERR("invalid parameter");
834                 return PKGMGR_R_EINVAL;
835         }
836
837         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
838         g_variant_builder_add(builder, "s", pkgid);
839
840         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
841                         g_variant_new("(uas)", uid, builder), &result);
842         g_variant_builder_unref(builder);
843         if (ret != PKGMGR_R_OK) {
844                 ERR("request failed: %d", ret);
845                 return ret;
846         }
847
848         g_variant_get(result, "(is)", &ret, NULL);
849         g_variant_unref(result);
850
851         return ret;
852 }
853
854 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
855                 const char *pkgid)
856 {
857         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
858 }
859
860 API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
861                 const char *pkg_type, const char **pkgids, int n_pkgs,
862                 pkgmgr_handler event_cb, void *data, uid_t uid)
863 {
864         GVariant *result;
865         GVariantBuilder *builder;
866         int ret = PKGMGR_R_ECOMM;
867         char *req_key = NULL;
868         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
869         struct cb_info *cb_info;
870         int i;
871
872         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
873                 ERR("invalid parameter");
874                 return PKGMGR_R_EINVAL;
875         }
876
877         if (client->pc_type != PC_REQUEST) {
878                 ERR("client type is not PC_REQUEST");
879                 return PKGMGR_R_EINVAL;
880         }
881
882         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
883         for (i = 0; i < n_pkgs; i++)
884                 g_variant_builder_add(builder, "s", pkgids[i]);
885
886         ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
887                         g_variant_new("(uas)", uid, builder), &result);
888         g_variant_builder_unref(builder);
889         if (ret != PKGMGR_R_OK) {
890                 ERR("request failed: %d", ret);
891                 return ret;
892         }
893
894         g_variant_get(result, "(i&s)", &ret, &req_key);
895         if (req_key == NULL) {
896                 g_variant_unref(result);
897                 return PKGMGR_R_ECOMM;
898         }
899         if (ret != PKGMGR_R_OK) {
900                 g_variant_unref(result);
901                 return ret;
902         }
903
904         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
905         if (cb_info == NULL) {
906                 g_variant_unref(result);
907                 return PKGMGR_R_ERROR;
908         }
909         g_variant_unref(result);
910         ret = pkgmgr_client_connection_set_callback(client, cb_info);
911         if (ret != PKGMGR_R_OK) {
912                 __free_cb_info(cb_info);
913                 return ret;
914         }
915         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
916
917         return cb_info->req_id;
918 }
919
920 API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
921                 const char *pkg_type, const char **pkgids, int n_pkgs,
922                 pkgmgr_handler event_cb, void *data)
923 {
924         return pkgmgr_client_usr_activate_packages(pc, pkg_type,
925                         pkgids, n_pkgs, event_cb, data, _getuid());
926 }
927
928 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
929                                  const char *pkgid, uid_t uid)
930 {
931         GVariant *result;
932         GVariantBuilder *builder;
933         int ret = PKGMGR_R_ECOMM;
934         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
935
936         if (pc == NULL || pkgid == NULL) {
937                 ERR("invalid parameter");
938                 return PKGMGR_R_EINVAL;
939         }
940
941         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
942         g_variant_builder_add(builder, "s", pkgid);
943
944         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
945                         g_variant_new("(uas)", uid, builder), &result);
946         g_variant_builder_unref(builder);
947         if (ret != PKGMGR_R_OK) {
948                 ERR("request failed: %d", ret);
949                 return ret;
950         }
951
952         g_variant_get(result, "(is)", &ret, NULL);
953         g_variant_unref(result);
954
955         return ret;
956 }
957
958 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
959                                  const char *pkgid)
960 {
961         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
962 }
963
964 API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
965                 const char *pkg_type, const char **pkgids, int n_pkgs,
966                 pkgmgr_handler event_cb, void *data, uid_t uid)
967 {
968         GVariant *result;
969         GVariantBuilder *builder;
970         int ret = PKGMGR_R_ECOMM;
971         char *req_key = NULL;
972         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
973         struct cb_info *cb_info;
974         int i;
975
976         if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
977                 ERR("invalid parameter");
978                 return PKGMGR_R_EINVAL;
979         }
980
981         if (client->pc_type != PC_REQUEST) {
982                 ERR("client type is not PC_REQUEST");
983                 return PKGMGR_R_EINVAL;
984         }
985
986         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
987         for (i = 0; i < n_pkgs; i++)
988                 g_variant_builder_add(builder, "s", pkgids[i]);
989
990         ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
991                 g_variant_new("(uas)", uid, builder), &result);
992         g_variant_builder_unref(builder);
993         if (ret != PKGMGR_R_OK) {
994                 ERR("request failed: %d", ret);
995                 return ret;
996         }
997
998         g_variant_get(result, "(i&s)", &ret, &req_key);
999         if (req_key == NULL) {
1000                 g_variant_unref(result);
1001                 return PKGMGR_R_ECOMM;
1002         }
1003         if (ret != PKGMGR_R_OK) {
1004                 g_variant_unref(result);
1005                 return ret;
1006         }
1007
1008         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1009         if (cb_info == NULL) {
1010                 g_variant_unref(result);
1011                 return PKGMGR_R_ERROR;
1012         }
1013         g_variant_unref(result);
1014         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1015         if (ret != PKGMGR_R_OK) {
1016                 __free_cb_info(cb_info);
1017                 return ret;
1018         }
1019         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1020
1021         return cb_info->req_id;
1022 }
1023
1024 API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
1025                 const char *pkg_type, const char **pkgids, int n_pkgs,
1026                 pkgmgr_handler event_cb, void *data)
1027 {
1028         return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
1029                         pkgids, n_pkgs, event_cb, data, _getuid());
1030 }
1031
1032 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1033                 pkgmgr_app_handler app_event_cb, uid_t uid)
1034 {
1035         GVariant *result;
1036         int ret = PKGMGR_R_ECOMM;
1037         char *req_key = NULL;
1038         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1039         struct cb_info *cb_info;
1040
1041         if (pc == NULL || appid == NULL) {
1042                 ERR("invalid parameter");
1043                 return PKGMGR_R_EINVAL;
1044         }
1045
1046         ret = pkgmgr_client_connection_send_request(client, "enable_app",
1047                         g_variant_new("(us)", uid, appid), &result);
1048         if (ret != PKGMGR_R_OK) {
1049                 ERR("request failed: %d", ret);
1050                 return ret;
1051         }
1052
1053         g_variant_get(result, "(i&s)", &ret, &req_key);
1054         if (req_key == NULL) {
1055                 g_variant_unref(result);
1056                 return PKGMGR_R_ECOMM;
1057         }
1058         if (ret != PKGMGR_R_OK) {
1059                 g_variant_unref(result);
1060                 return ret;
1061         }
1062
1063         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1064                         req_key);
1065         if (cb_info == NULL) {
1066                 g_variant_unref(result);
1067                 return PKGMGR_R_ENOMEM;
1068         }
1069         g_variant_unref(result);
1070         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1071         if (ret != PKGMGR_R_OK) {
1072                 __free_cb_info(cb_info);
1073                 return ret;
1074         }
1075         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1076
1077         return PKGMGR_R_OK;
1078 }
1079
1080 API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
1081                 pkgmgr_app_handler app_event_cb)
1082 {
1083         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
1084                         _getuid());
1085 }
1086
1087 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1088                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1089 {
1090         GVariant *result;
1091         int ret = PKGMGR_R_ECOMM;
1092         char *req_key = NULL;
1093         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1094         struct cb_info *cb_info;
1095
1096         if (pc == NULL || appid == NULL) {
1097                 ERR("invalid parameter");
1098                 return PKGMGR_R_EINVAL;
1099         }
1100
1101         ret = pkgmgr_client_connection_send_request(client,
1102                         "enable_global_app_for_uid",
1103                         g_variant_new("(us)", uid, appid), &result);
1104         if (ret != PKGMGR_R_OK) {
1105                 ERR("request failed: %d", ret);
1106                 return ret;
1107         }
1108
1109         g_variant_get(result, "(i&s)", &ret, &req_key);
1110         if (req_key == NULL) {
1111                 g_variant_unref(result);
1112                 return PKGMGR_R_ECOMM;
1113         }
1114         if (ret != PKGMGR_R_OK) {
1115                 g_variant_unref(result);
1116                 return ret;
1117         }
1118
1119         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1120                         req_key);
1121         if (cb_info == NULL) {
1122                 g_variant_unref(result);
1123                 return PKGMGR_R_ENOMEM;
1124         }
1125         g_variant_unref(result);
1126         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1127         if (ret != PKGMGR_R_OK) {
1128                 __free_cb_info(cb_info);
1129                 return ret;
1130         }
1131         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1132
1133         return PKGMGR_R_OK;
1134 }
1135
1136 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1137                 pkgmgr_app_handler app_event_cb, uid_t uid)
1138 {
1139         GVariant *result;
1140         int ret = PKGMGR_R_ECOMM;
1141         char *req_key = NULL;
1142         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1143         struct cb_info *cb_info;
1144
1145         if (pc == NULL || appid == NULL) {
1146                 ERR("invalid parameter");
1147                 return PKGMGR_R_EINVAL;
1148         }
1149
1150         ret = pkgmgr_client_connection_send_request(client, "disable_app",
1151                         g_variant_new("(us)", uid, appid), &result);
1152         if (ret != PKGMGR_R_OK) {
1153                 ERR("request failed: %d", ret);
1154                 return ret;
1155         }
1156
1157         g_variant_get(result, "(i&s)", &ret, &req_key);
1158         if (req_key == NULL) {
1159                 g_variant_unref(result);
1160                 return PKGMGR_R_ECOMM;
1161         }
1162         if (ret != PKGMGR_R_OK) {
1163                 g_variant_unref(result);
1164                 return ret;
1165         }
1166
1167         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1168                         req_key);
1169         if (cb_info == NULL) {
1170                 g_variant_unref(result);
1171                 return PKGMGR_R_ENOMEM;
1172         }
1173         g_variant_unref(result);
1174         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1175         if (ret != PKGMGR_R_OK) {
1176                 __free_cb_info(cb_info);
1177                 return ret;
1178         }
1179         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1180
1181         return PKGMGR_R_OK;
1182 }
1183
1184 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
1185                 pkgmgr_app_handler app_event_cb)
1186 {
1187         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb,
1188                         _getuid());
1189 }
1190
1191 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1192                 const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1193 {
1194         GVariant *result;
1195         int ret = PKGMGR_R_ECOMM;
1196         char *req_key = NULL;
1197         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1198         struct cb_info *cb_info;
1199
1200         if (pc == NULL || appid == NULL) {
1201                 ERR("invalid parameter");
1202                 return PKGMGR_R_EINVAL;
1203         }
1204
1205         ret = pkgmgr_client_connection_send_request(client,
1206                         "disable_global_app_for_uid",
1207                         g_variant_new("(us)", uid, appid), &result);
1208         if (ret != PKGMGR_R_OK) {
1209                 ERR("request failed: %d", ret);
1210                 return ret;
1211         }
1212
1213         g_variant_get(result, "(i&s)", &ret, &req_key);
1214         if (req_key == NULL) {
1215                 g_variant_unref(result);
1216                 return PKGMGR_R_ECOMM;
1217         }
1218         if (ret != PKGMGR_R_OK) {
1219                 g_variant_unref(result);
1220                 return ret;
1221         }
1222
1223         cb_info = __create_app_event_cb_info(client, app_event_cb, NULL,
1224                         req_key);
1225         if (cb_info == NULL) {
1226                 g_variant_unref(result);
1227                 return PKGMGR_R_ENOMEM;
1228         }
1229         g_variant_unref(result);
1230         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1231         if (ret != PKGMGR_R_OK) {
1232                 __free_cb_info(cb_info);
1233                 return ret;
1234         }
1235         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1236
1237         return PKGMGR_R_OK;
1238 }
1239
1240 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1241                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1242                 uid_t uid)
1243 {
1244         GVariant *result;
1245         int ret;
1246         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1247
1248         if (pc == NULL || appid == NULL) {
1249                 ERR("invalid parameter");
1250                 return PKGMGR_R_EINVAL;
1251         }
1252
1253         if (client->pc_type != PC_REQUEST) {
1254                 ERR("client->pc_type is not PC_REQUEST");
1255                 return PKGMGR_R_EINVAL;
1256         }
1257
1258         ret = pkgmgr_client_connection_send_request(client, "cleardata",
1259                         g_variant_new("(us)", uid, appid), &result);
1260         if (ret == PKGMGR_R_OK) {
1261                 ERR("request failed: %d", ret);
1262                 return ret;
1263         }
1264
1265         g_variant_get(result, "(i)", &ret);
1266         g_variant_unref(result);
1267
1268         return ret;
1269 }
1270
1271 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1272                 const char *appid, pkgmgr_mode mode)
1273 {
1274         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1275                         _getuid());
1276 }
1277
1278 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1279 {
1280         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1281
1282         if (pc == NULL) {
1283                 ERR("invalid parameter");
1284                 return PKGMGR_R_EINVAL;
1285         }
1286
1287         client->status_type = status_type;
1288
1289         return PKGMGR_R_OK;
1290 }
1291
1292 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1293                 void *data)
1294 {
1295         int ret;
1296         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1297         struct cb_info *cb_info;
1298
1299         if (pc == NULL || event_cb == NULL) {
1300                 ERR("invalid parameter");
1301                 return PKGMGR_R_EINVAL;
1302         }
1303
1304         if (client->pc_type != PC_LISTENING) {
1305                 ERR("client->pc_type is not PC_LISTENING");
1306                 return PKGMGR_R_EINVAL;
1307         }
1308
1309         cb_info = __create_event_cb_info(client, event_cb, data, NULL);
1310         if (cb_info == NULL)
1311                 return PKGMGR_R_ENOMEM;
1312         cb_info->status_type = client->status_type;
1313         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1314         if (ret != PKGMGR_R_OK) {
1315                 __free_cb_info(cb_info);
1316                 return ret;
1317         }
1318         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1319
1320         return cb_info->req_id;
1321 }
1322
1323 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
1324                 pkgmgr_app_handler app_event_cb, void *data)
1325 {
1326         int ret;
1327         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1328         struct cb_info *cb_info;
1329
1330         if (pc == NULL || app_event_cb == NULL) {
1331                 ERR("invalid parameter");
1332                 return PKGMGR_R_EINVAL;
1333         }
1334
1335         if (client->pc_type != PC_LISTENING) {
1336                 ERR("client->pc_type is not PC_LISTENING");
1337                 return PKGMGR_R_EINVAL;
1338         }
1339
1340         cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
1341         if (cb_info == NULL)
1342                 return PKGMGR_R_ENOMEM;
1343         cb_info->status_type = client->status_type;
1344         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1345         if (ret != PKGMGR_R_OK) {
1346                 __free_cb_info(cb_info);
1347                 return ret;
1348         }
1349         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1350
1351         return cb_info->req_id;
1352 }
1353
1354 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1355 {
1356         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1357         GList *tmp;
1358         GList *next;
1359         struct cb_info *cb_info;
1360
1361         if (pc == NULL) {
1362                 ERR("invalid parameter");
1363                 return PKGMGR_R_EINVAL;
1364         }
1365
1366         /* unset all callback */
1367         tmp = client->cb_info_list;
1368         while (tmp != NULL) {
1369                 next = tmp->next;
1370                 cb_info = (struct cb_info *)tmp->data;
1371                 pkgmgr_client_connection_unset_callback(pc, cb_info);
1372                 client->cb_info_list = g_list_delete_link(client->cb_info_list,
1373                                 tmp);
1374                 __free_cb_info(cb_info);
1375                 tmp = next;
1376         }
1377
1378         return PKGMGR_R_OK;
1379 }
1380
1381 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1382                 const char *pkgid, const char *key, const char *val)
1383 {
1384         /* client cannot broadcast signal */
1385         return PKGMGR_R_OK;
1386 }
1387
1388 /* TODO: deprecate(or remove) */
1389 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
1390                 int service_mode, pkgmgr_client *pc, const char *pkg_type,
1391                 const char *pkgid, const char *custom_info,
1392                 pkgmgr_handler event_cb, void *data)
1393 {
1394         return pkgmgr_client_usr_request_service(service_type, service_mode,
1395                         pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
1396                         data);
1397 }
1398
1399 API int pkgmgr_client_usr_request_service(
1400                 pkgmgr_request_service_type service_type, int service_mode,
1401                 pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
1402                 uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
1403                 void *data)
1404 {
1405         int ret = 0;
1406
1407         /* Check for NULL value of service type */
1408         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1409         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1410
1411         switch (service_type) {
1412         case PM_REQUEST_MOVE:
1413                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1414                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1415                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1416
1417                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1418                 break;
1419
1420         case PM_REQUEST_GET_SIZE:
1421                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1422                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1423                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1424
1425                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1426                 break;
1427
1428         case PM_REQUEST_KILL_APP:
1429         case PM_REQUEST_CHECK_APP:
1430                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1431                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1432
1433                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1434                 if (ret < 0)
1435                         ERR("__check_app_process fail \n");
1436                 else
1437                         ret = PKGMGR_R_OK;
1438
1439                 break;
1440
1441         default:
1442                 ERR("Wrong Request\n");
1443                 ret = -1;
1444                 break;
1445         }
1446
1447 catch:
1448
1449         return ret;
1450 }
1451
1452
1453 API int pkgmgr_client_usr_request_size_info(uid_t uid)
1454 {
1455         int ret;
1456         struct pkgmgr_client *client;
1457
1458         client = pkgmgr_client_new(PC_REQUEST);
1459         if (client == NULL) {
1460                 ERR("out of memory");
1461                 return PKGMGR_R_ENOMEM;
1462         }
1463
1464         ret = __request_size_info(client, uid);
1465         if (ret < 0)
1466                 ERR("__request_size_info fail");
1467
1468         pkgmgr_client_free(client);
1469         return ret;
1470 }
1471
1472 API int pkgmgr_client_request_size_info(void)
1473 {
1474         /* get all package size (data, total) */
1475         return pkgmgr_client_usr_request_size_info(_getuid());
1476 }
1477
1478 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
1479 {
1480         GVariant *result;
1481         int ret;
1482         struct pkgmgr_client_t *client;
1483
1484         if (pkgid == NULL) {
1485                 ERR("invalid parameter");
1486                 return PKGMGR_R_EINVAL;
1487         }
1488
1489         client = pkgmgr_client_new(PC_REQUEST);
1490         if (client == NULL) {
1491                 ERR("out of memory");
1492                 return PKGMGR_R_ENOMEM;
1493         }
1494
1495         ret = pkgmgr_client_connection_send_request(client, "clearcache",
1496                         g_variant_new("(us)", uid, pkgid), &result);
1497         if (ret != PKGMGR_R_OK) {
1498                 ERR("request failed: %d", ret);
1499                 return ret;
1500         }
1501
1502         g_variant_get(result, "(i)", &ret);
1503         g_variant_unref(result);
1504
1505         return ret;
1506 }
1507
1508 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
1509 {
1510         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
1511 }
1512
1513 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
1514 {
1515         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
1516 }
1517
1518 API int pkgmgr_client_clear_all_cache_dir(void)
1519 {
1520         return pkgmgr_client_usr_clear_cache_dir(
1521                         PKG_CLEAR_ALL_CACHE, getuid());
1522 }
1523
1524 API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
1525                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1526                 void *data)
1527 {
1528         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
1529                         _getuid());
1530 }
1531
1532 /* TODO: deprecate(or remove) */
1533 API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
1534                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
1535                 void *data, uid_t uid)
1536 {
1537         GVariant *result;
1538         int ret = PKGMGR_R_ECOMM;
1539         char *req_key = NULL;
1540         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1541         struct cb_info *cb_info;
1542
1543         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1544                 ERR("invalid parameter");
1545                 return PKGMGR_R_EINVAL;
1546         }
1547
1548         if (client->pc_type != PC_REQUEST) {
1549                 ERR("client->pc_type is not PC_REQUEST");
1550                 return PKGMGR_R_EINVAL;
1551         }
1552
1553         /* FIXME */
1554         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1555                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1556         else
1557                 get_type = PM_GET_PKG_SIZE_INFO;
1558
1559         ret = pkgmgr_client_connection_send_request(client, "getsize",
1560                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1561         if (ret != PKGMGR_R_OK) {
1562                 ERR("request failed: %d", ret);
1563                 return ret;
1564         }
1565
1566         g_variant_get(result, "(i&s)", &ret, &req_key);
1567         if (req_key == NULL) {
1568                 g_variant_unref(result);
1569                 return PKGMGR_R_ECOMM;
1570         }
1571         if (ret != PKGMGR_R_OK) {
1572                 g_variant_unref(result);
1573                 return ret;
1574         }
1575
1576         cb_info = __create_event_cb_info(client, event_cb, data, req_key);
1577         if (cb_info == NULL) {
1578                 g_variant_unref(result);
1579                 return PKGMGR_R_ENOMEM;
1580         }
1581         g_variant_unref(result);
1582         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1583         if (ret != PKGMGR_R_OK) {
1584                 __free_cb_info(cb_info);
1585                 return ret;
1586         }
1587         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1588
1589         return PKGMGR_R_OK;
1590 }
1591
1592 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
1593                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1594                 void *user_data, uid_t uid)
1595 {
1596         GVariant *result;
1597         int ret = PKGMGR_R_ECOMM;
1598         char *req_key = NULL;
1599         int get_type;
1600         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1601         struct cb_info *cb_info;
1602
1603         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
1604                 ERR("invalid parameter");
1605                 return PKGMGR_R_EINVAL;
1606         }
1607
1608         if (client->pc_type != PC_REQUEST) {
1609                 ERR("client->pc_type is not PC_REQUEST");
1610                 return PKGMGR_R_EINVAL;
1611         }
1612
1613         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
1614                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
1615         else
1616                 get_type = PM_GET_PKG_SIZE_INFO;
1617
1618         ret = pkgmgr_client_connection_send_request(client, "getsize",
1619                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
1620         if (ret != PKGMGR_R_OK) {
1621                 ERR("request failed: %d", ret);
1622                 return ret;
1623         }
1624
1625         g_variant_get(result, "(i&s)", &ret, &req_key);
1626         if (req_key == NULL) {
1627                 g_variant_unref(result);
1628                 return PKGMGR_R_ECOMM;
1629         }
1630         if (ret != PKGMGR_R_OK) {
1631                 g_variant_unref(result);
1632                 return ret;
1633         }
1634
1635         cb_info = __create_size_info_cb_info(client, event_cb, user_data,
1636                         req_key);
1637         if (cb_info == NULL) {
1638                 g_variant_unref(result);
1639                 return PKGMGR_R_ENOMEM;
1640         }
1641         g_variant_unref(result);
1642         ret = pkgmgr_client_connection_set_callback(client, cb_info);
1643         if (ret != PKGMGR_R_OK) {
1644                 __free_cb_info(cb_info);
1645                 return ret;
1646         }
1647         client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
1648
1649         return PKGMGR_R_OK;
1650 }
1651
1652 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
1653                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
1654                 void *user_data)
1655 {
1656         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
1657                         user_data, _getuid());
1658 }
1659
1660 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
1661                 pkgmgr_total_pkg_size_info_receive_cb event_cb,
1662                 void *user_data, uid_t uid)
1663 {       /* total package size info */
1664         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1665                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1666                         user_data, uid);
1667 }
1668
1669 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
1670                 pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
1671 {
1672         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
1673                         (pkgmgr_pkg_size_info_receive_cb)event_cb,
1674                         user_data, _getuid());
1675 }
1676
1677 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
1678                 const char *resp_data, char **req_data, char **license_url)
1679 {
1680         GVariant *result;
1681         int ret;
1682         char *data;
1683         char *url;
1684         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1685
1686         if (pc == NULL || resp_data == NULL || req_data == NULL ||
1687                         license_url == NULL) {
1688                 ERR("invalid parameter");
1689                 return PKGMGR_R_EINVAL;
1690         }
1691
1692         if (client->pc_type != PC_REQUEST) {
1693                 ERR("client->pc_type is not PC_REQUEST");
1694                 return PKGMGR_R_EINVAL;
1695         }
1696
1697         ret = pkgmgr_client_connection_send_request(client,
1698                         "generate_license_request",
1699                         g_variant_new("(s)", resp_data), &result);
1700         if (ret != PKGMGR_R_OK) {
1701                 ERR("request failed: %d", ret);
1702                 return ret;
1703         }
1704
1705         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
1706         if (ret != PKGMGR_R_OK) {
1707                 ERR("generate_license_request failed: %d", ret);
1708                 g_variant_unref(result);
1709                 return ret;
1710         }
1711
1712         *req_data = strdup(data);
1713         *license_url = strdup(url);
1714
1715         g_variant_unref(result);
1716
1717         return PKGMGR_R_OK;
1718 }
1719
1720 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
1721 {
1722         GVariant *result;
1723         int ret;
1724         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1725
1726         if (pc == NULL || resp_data == NULL) {
1727                 ERR("invalid parameter");
1728                 return PKGMGR_R_EINVAL;
1729         }
1730
1731         if (client->pc_type != PC_REQUEST) {
1732                 ERR("client->pc_type is not PC_REQUEST");
1733                 return PKGMGR_R_EINVAL;
1734         }
1735
1736         ret = pkgmgr_client_connection_send_request(client, "register_license",
1737                         g_variant_new("(s)", resp_data), &result);
1738         if (ret != PKGMGR_R_OK) {
1739                 ERR("request failed: %d", ret);
1740                 return ret;
1741         }
1742
1743         g_variant_get(result, "(i)", &ret);
1744         g_variant_unref(result);
1745         if (ret != PKGMGR_R_OK)
1746                 ERR("register license failed: %d", ret);
1747
1748         return ret;
1749 }
1750
1751 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
1752                 const char *drm_file_path, const char *decrypted_file_path)
1753 {
1754         GVariant *result;
1755         int ret;
1756         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1757
1758         if (pc == NULL || drm_file_path == NULL ||
1759                         decrypted_file_path == NULL) {
1760                 ERR("invalid parameter");
1761                 return PKGMGR_R_EINVAL;
1762         }
1763
1764         if (client->pc_type != PC_REQUEST) {
1765                 ERR("client->pc_type is not PC_REQUEST");
1766                 return PKGMGR_R_EINVAL;
1767         }
1768
1769         ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
1770                         g_variant_new("(ss)", drm_file_path,
1771                                 decrypted_file_path), &result);
1772         if (ret != PKGMGR_R_OK) {
1773                 ERR("request failed: %d", ret);
1774                 return ret;
1775         }
1776
1777         g_variant_get(result, "(i)", &ret);
1778         g_variant_unref(result);
1779         if (ret != PKGMGR_R_OK)
1780                 ERR("decrypt_package failed: %d", ret);
1781
1782         return ret;
1783 }
1784
1785 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
1786 {
1787         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
1788 }
1789
1790 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
1791                 const char *appid, uid_t uid)
1792 {
1793         int ret;
1794         GVariant *result;
1795         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1796
1797         if (pc == NULL || appid == NULL) {
1798                 ERR("Invalid parameter");
1799                 return PKGMGR_R_EINVAL;
1800         }
1801
1802         ret = pkgmgr_client_connection_send_request(client,
1803                         "enable_app_splash_screen",
1804                         g_variant_new("(us)", uid, appid), &result);
1805         if (ret != PKGMGR_R_OK) {
1806                 ERR("request failed: %d", ret);
1807                 return ret;
1808         }
1809
1810         g_variant_get(result, "(i)", &ret);
1811         g_variant_unref(result);
1812         if (ret != PKGMGR_R_OK)
1813                 ERR("enable splash screen failed: %d", ret);
1814
1815         return ret;
1816 }
1817
1818 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
1819                 const char *appid)
1820 {
1821         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
1822                         _getuid());
1823 }
1824
1825 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
1826                 const char *appid, uid_t uid)
1827 {
1828         int ret;
1829         GVariant *result;
1830         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1831
1832         if (pc == NULL || appid == NULL) {
1833                 ERR("Invalid parameter");
1834                 return PKGMGR_R_EINVAL;
1835         }
1836
1837         ret = pkgmgr_client_connection_send_request(client,
1838                         "disable_app_splash_screen",
1839                         g_variant_new("(us)", uid, appid), &result);
1840         if (ret != PKGMGR_R_OK) {
1841                 ERR("request failed: %d", ret);
1842                 return ret;
1843         }
1844
1845         g_variant_get(result, "(i)", &ret);
1846         g_variant_unref(result);
1847         if (ret != PKGMGR_R_OK)
1848                 ERR("disable splash screen failed: %d", ret);
1849
1850         return ret;
1851 }
1852
1853 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1854                 int mode, uid_t uid)
1855 {
1856         GVariant *result;
1857         int ret = PKGMGR_R_ECOMM;
1858         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1859
1860         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1861                 ERR("invalid parameter");
1862                 return PKGMGR_R_EINVAL;
1863         }
1864
1865         ret = pkgmgr_client_connection_send_request(client,
1866                         "set_restriction_mode",
1867                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1868         if (ret != PKGMGR_R_OK) {
1869                 ERR("request failed: %d", ret);
1870                 return ret;
1871         }
1872
1873         g_variant_get(result, "(i)", &ret);
1874         g_variant_unref(result);
1875
1876         return ret;
1877 }
1878
1879 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
1880                 const char *pkgid, int mode, uid_t uid)
1881 {
1882         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
1883 }
1884
1885 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
1886                 const char *pkgid, int mode)
1887 {
1888         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
1889                         _getuid());
1890 }
1891
1892 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1893                 int mode, uid_t uid)
1894 {
1895         GVariant *result;
1896         int ret = PKGMGR_R_ECOMM;
1897         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1898
1899         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
1900                 ERR("invalid parameter");
1901                 return PKGMGR_R_EINVAL;
1902         }
1903
1904         ret = pkgmgr_client_connection_send_request(client,
1905                         "unset_restriction_mode",
1906                         g_variant_new("(usi)", uid, pkgid, mode), &result);
1907         if (ret != PKGMGR_R_OK) {
1908                 ERR("request failed: %d", ret);
1909                 return ret;
1910         }
1911
1912         g_variant_get(result, "(i)", &ret);
1913         g_variant_unref(result);
1914
1915         return ret;
1916
1917 }
1918
1919 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
1920                 const char *pkgid, int mode, uid_t uid)
1921 {
1922         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
1923 }
1924
1925 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
1926                 const char *pkgid, int mode)
1927 {
1928         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
1929                         _getuid());
1930 }
1931
1932 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
1933                 int *mode, uid_t uid)
1934 {
1935         GVariant *result;
1936         int ret = PKGMGR_R_ECOMM;
1937         gint m;
1938         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1939
1940         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
1941                 ERR("invalid parameter");
1942                 return PKGMGR_R_EINVAL;
1943         }
1944
1945         ret = pkgmgr_client_connection_send_request(client,
1946                         "get_restriction_mode",
1947                         g_variant_new("(us)", uid, pkgid), &result);
1948         if (ret != PKGMGR_R_OK) {
1949                 ERR("request failed: %d", ret);
1950                 return ret;
1951         }
1952
1953         g_variant_get(result, "(ii)", &m, &ret);
1954         g_variant_unref(result);
1955         if (ret != PKGMGR_R_OK)
1956                 return ret;
1957
1958         *mode = m;
1959
1960         return PKGMGR_R_OK;
1961 }
1962
1963 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
1964                 const char *pkgid, int *mode, uid_t uid)
1965 {
1966         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
1967 }
1968
1969 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
1970                 const char *pkgid, int *mode)
1971 {
1972         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
1973                         _getuid());
1974 }
1975
1976 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
1977                 uid_t uid)
1978 {
1979         GVariant *result;
1980         int ret = PKGMGR_R_ECOMM;
1981         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
1982
1983         if (pc == NULL) {
1984                 ERR("invalid parameter");
1985                 return PKGMGR_R_EINVAL;
1986         }
1987
1988         ret = pkgmgr_client_connection_send_request(client,
1989                         "set_restriction_mode",
1990                         g_variant_new("(usi)", uid, "", mode), &result);
1991         if (ret != PKGMGR_R_OK) {
1992                 ERR("request failed: %d", ret);
1993                 return ret;
1994         }
1995
1996         g_variant_get(result, "(i)", &ret);
1997         g_variant_unref(result);
1998
1999         return ret;
2000 }
2001
2002 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2003 {
2004         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2005 }
2006
2007 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2008                 uid_t uid)
2009 {
2010         GVariant *result;
2011         int ret = PKGMGR_R_ECOMM;
2012         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2013
2014         if (pc == NULL) {
2015                 ERR("invalid parameter");
2016                 return PKGMGR_R_EINVAL;
2017         }
2018
2019         ret = pkgmgr_client_connection_send_request(client,
2020                         "unset_restriction_mode",
2021                         g_variant_new("(usi)", uid, "", mode), &result);
2022         if (ret != PKGMGR_R_OK) {
2023                 ERR("request failed: %d", ret);
2024                 return ret;
2025         }
2026
2027         g_variant_get(result, "(i)", &ret);
2028         g_variant_unref(result);
2029
2030         return ret;
2031 }
2032
2033 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2034 {
2035         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2036 }
2037
2038 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2039                 int *mode, uid_t uid)
2040 {
2041         GVariant *result;
2042         int ret = PKGMGR_R_ECOMM;
2043         gint m;
2044         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2045
2046         if (pc == NULL) {
2047                 ERR("invalid parameter");
2048                 return PKGMGR_R_EINVAL;
2049         }
2050
2051         ret = pkgmgr_client_connection_send_request(client,
2052                         "get_restriction_mode",
2053                         g_variant_new("(us)", uid, ""), &result);
2054         if (ret != PKGMGR_R_OK) {
2055                 ERR("request failed: %d", ret);
2056                 return ret;
2057         }
2058
2059         g_variant_get(result, "(ii)", &m, &ret);
2060         g_variant_unref(result);
2061         if (ret != PKGMGR_R_OK)
2062                 return ret;
2063
2064         *mode = m;
2065
2066         return PKGMGR_R_OK;
2067 }
2068
2069 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
2070 {
2071         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2072 }
2073
2074 API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
2075 {
2076         int ret;
2077         pkg_plugin_set *plugin_set;
2078         package_manager_pkg_detail_info_t *info;
2079         char *pkg_type;
2080
2081         if (pkg_path == NULL) {
2082                 ERR("invalid parameter");
2083                 return NULL;
2084         }
2085
2086         pkg_type = __get_type_from_path(pkg_path);
2087         if (pkg_type == NULL) {
2088                 ERR("cannot get pkg type");
2089                 return NULL;
2090         }
2091
2092         plugin_set = _package_manager_load_library(pkg_type);
2093         if (plugin_set == NULL) {
2094                 ERR("failed to load library for %s", pkg_type);
2095                 free(pkg_type);
2096                 return NULL;
2097         }
2098
2099         info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
2100         if (info == NULL) {
2101                 ERR("out of memory");
2102                 free(pkg_type);
2103                 return NULL;
2104         }
2105
2106         ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
2107         if (ret) {
2108                 ERR("get_pkg_detail_info_from_package failed");
2109                 free(info);
2110                 free(pkg_type);
2111                 return NULL;
2112         }
2113
2114         free(pkg_type);
2115
2116         return (pkgmgr_info *)info;
2117 }
2118
2119 API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
2120 {
2121         package_manager_pkg_detail_info_t *pkg_info =
2122                 (package_manager_pkg_detail_info_t *)info;
2123
2124         if (info == NULL) {
2125                 ERR("invalid parameter");
2126                 return PKGMGR_R_EINVAL;
2127         }
2128
2129         free(pkg_info->icon_buf);
2130         free(pkg_info);
2131
2132         return PKGMGR_R_OK;
2133 }
2134
2135 API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
2136                 char *label, uid_t uid)
2137 {
2138         GVariant *result;
2139         int ret = -1;
2140         struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
2141
2142         if (pc == NULL || appid == NULL || label == NULL) {
2143                 ERR("Invalid parameter");
2144                 return PKGMGR_R_EINVAL;
2145         }
2146
2147         ret = pkgmgr_client_connection_send_request(client,
2148                         "set_app_label",
2149                         g_variant_new("(uss)", uid, appid, label), &result);
2150         if (ret != PKGMGR_R_OK) {
2151                 ERR("Request failed: %d", ret);
2152                 return ret;
2153         }
2154
2155         g_variant_get(result, "(i)", &ret);
2156         g_variant_unref(result);
2157
2158         return ret;
2159 }
2160
2161 API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
2162 {
2163         return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
2164 }