Fix pkgmgr move API to get event callback
[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-internal.h"
42 #include "pkgmgr-debug.h"
43 #include "comm_client.h"
44 #include "comm_config.h"
45
46 /* API export macro */
47 #ifndef API
48 #define API __attribute__ ((visibility("default")))
49 #endif
50
51 #define PKG_TMP_PATH tzplatform_mkpath(TZ_USER_APP, "tmp")
52
53 #define BINSH_NAME      "/bin/sh"
54 #define BINSH_SIZE      7
55
56 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
57 #define REGULAR_USER 5000
58
59 static inline uid_t _getuid(void)
60 {
61         uid_t uid = getuid();
62
63         if (uid < REGULAR_USER)
64                 return GLOBAL_USER;
65         else
66                 return uid;
67 }
68
69 static int _get_request_id()
70 {
71         static int internal_req_id = 1;
72
73         return internal_req_id++;
74 }
75
76 typedef struct _req_cb_info {
77         int request_id;
78         char *req_key;
79         pkgmgr_handler event_cb;
80         pkgmgr_app_handler app_event_cb;
81         void *data;
82         struct _req_cb_info *next;
83 } req_cb_info;
84
85 typedef struct _listen_cb_info {
86         int request_id;
87         pkgmgr_handler event_cb;
88         pkgmgr_app_handler app_event_cb;
89         void *data;
90         struct _listen_cb_info *next;
91 } listen_cb_info;
92
93 typedef struct _pkgmgr_client_t {
94         client_type ctype;
95         int status_type;
96         union {
97                 struct _request {
98                         comm_client *cc;
99                         req_cb_info *rhead;
100                 } request;
101                 struct _listening {
102                         comm_client *cc;
103                         listen_cb_info *lhead;
104                 } listening;
105         } info;
106         void *new_event_cb;
107         char *tep_path;
108         char *tep_move;
109 } pkgmgr_client_t;
110
111 typedef struct _iter_data {
112         pkgmgr_iter_fn iter_fn;
113         void *data;
114 } iter_data;
115
116 static int __xsystem(const char *argv[])
117 {
118         int status = 0;
119         pid_t pid;
120         pid = fork();
121         switch (pid) {
122         case -1:
123                 perror("fork failed");
124                 return -1;
125         case 0:
126                 /* child */
127                 execvp(argv[0], (char *const *)argv);
128                 _exit(-1);
129         default:
130                 /* parent */
131                 break;
132         }
133         if (waitpid(pid, &status, 0) == -1) {
134                 perror("waitpid failed");
135                 return -1;
136         }
137         if (WIFSIGNALED(status)) {
138                 perror("signal");
139                 return -1;
140         }
141         if (!WIFEXITED(status)) {
142                 /* shouldn't happen */
143                 perror("should not happen");
144                 return -1;
145         }
146         return WEXITSTATUS(status);
147 }
148
149 static void __error_to_string(int errnumber, char **errstr)
150 {
151         if (errstr == NULL)
152                 return;
153         switch (errnumber) {
154         case PKGCMD_ERR_PACKAGE_NOT_FOUND:
155                 *errstr = PKGCMD_ERR_PACKAGE_NOT_FOUND_STR;
156                 break;
157         case PKGCMD_ERR_PACKAGE_INVALID:
158                 *errstr = PKGCMD_ERR_PACKAGE_INVALID_STR;
159                 break;
160         case PKGCMD_ERR_PACKAGE_LOWER_VERSION:
161                 *errstr = PKGCMD_ERR_PACKAGE_LOWER_VERSION_STR;
162                 break;
163         case PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND:
164                 *errstr = PKGCMD_ERR_PACKAGE_EXECUTABLE_NOT_FOUND_STR;
165                 break;
166         case PKGCMD_ERR_MANIFEST_INVALID:
167                 *errstr = PKGCMD_ERR_MANIFEST_INVALID_STR;
168                 break;
169         case PKGCMD_ERR_CONFIG_NOT_FOUND:
170                 *errstr = PKGCMD_ERR_CONFIG_NOT_FOUND_STR;
171                 break;
172         case PKGCMD_ERR_CONFIG_INVALID:
173                 *errstr = PKGCMD_ERR_CONFIG_INVALID_STR;
174                 break;
175         case PKGCMD_ERR_SIGNATURE_NOT_FOUND:
176                 *errstr = PKGCMD_ERR_SIGNATURE_NOT_FOUND_STR;
177                 break;
178         case PKGCMD_ERR_SIGNATURE_INVALID:
179                 *errstr = PKGCMD_ERR_SIGNATURE_INVALID_STR;
180                 break;
181         case PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED:
182                 *errstr = PKGCMD_ERR_SIGNATURE_VERIFICATION_FAILED_STR;
183                 break;
184         case PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND:
185                 *errstr = PKGCMD_ERR_ROOT_CERTIFICATE_NOT_FOUND_STR;
186                 break;
187         case PKGCMD_ERR_CERTIFICATE_INVALID:
188                 *errstr = PKGCMD_ERR_CERTIFICATE_INVALID_STR;
189                 break;
190         case PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED:
191                 *errstr = PKGCMD_ERR_CERTIFICATE_CHAIN_VERIFICATION_FAILED_STR;
192                 break;
193         case PKGCMD_ERR_CERTIFICATE_EXPIRED:
194                 *errstr = PKGCMD_ERR_CERTIFICATE_EXPIRED_STR;
195                 break;
196         case PKGCMD_ERR_INVALID_PRIVILEGE:
197                 *errstr = PKGCMD_ERR_INVALID_PRIVILEGE_STR;
198                 break;
199         case PKGCMD_ERR_MENU_ICON_NOT_FOUND:
200                 *errstr = PKGCMD_ERR_MENU_ICON_NOT_FOUND_STR;
201                 break;
202         case PKGCMD_ERR_FATAL_ERROR:
203                 *errstr = PKGCMD_ERR_FATAL_ERROR_STR;
204                 break;
205         case PKGCMD_ERR_OUT_OF_STORAGE:
206                 *errstr = PKGCMD_ERR_OUT_OF_STORAGE_STR;
207                 break;
208         case PKGCMD_ERR_OUT_OF_MEMORY:
209                 *errstr = PKGCMD_ERR_OUT_OF_MEMORY_STR;
210                 break;
211         case PKGCMD_ERR_ARGUMENT_INVALID:
212                 *errstr = PKGCMD_ERR_ARGUMENT_INVALID_STR;
213                 break;
214         default:
215                 *errstr = PKGCMD_ERR_UNKNOWN_STR;
216                 break;
217         }
218 }
219
220 static void __add_op_cbinfo(pkgmgr_client_t *pc, int request_id,
221                             const char *req_key, pkgmgr_handler event_cb, void *new_event_cb,
222                             void *data)
223 {
224         req_cb_info *cb_info;
225         req_cb_info *current;
226         req_cb_info *prev;
227
228         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
229         if (cb_info == NULL) {
230                 DBG("calloc failed");
231                 return;
232         }
233         cb_info->request_id = request_id;
234         cb_info->req_key = strdup(req_key);
235         cb_info->event_cb = event_cb;
236         cb_info->data = data;
237         cb_info->next = NULL;
238         cb_info->app_event_cb = NULL;
239         pc->new_event_cb = new_event_cb;
240
241         if (pc->info.request.rhead == NULL)
242                 pc->info.request.rhead = cb_info;
243         else {
244                 current = prev = pc->info.request.rhead;
245                 while (current) {
246                         prev = current;
247                         current = current->next;
248                 }
249
250                 prev->next = cb_info;
251         }
252 }
253
254 static void __add_op_app_cbinfo(pkgmgr_client_t *pc, int request_id,
255                             const char *req_key, pkgmgr_app_handler app_event_cb, void *data)
256 {
257         req_cb_info *cb_info;
258         req_cb_info *current;
259         req_cb_info *prev;
260
261         cb_info = (req_cb_info *) calloc(1, sizeof(req_cb_info));
262         if (cb_info == NULL) {
263                 DBG("calloc failed");
264                 return;
265         }
266         cb_info->request_id = request_id;
267         cb_info->req_key = strdup(req_key);
268         cb_info->event_cb = NULL;
269         cb_info->app_event_cb = app_event_cb;
270         cb_info->data = data;
271         cb_info->next = NULL;
272         pc->new_event_cb = NULL;
273
274         if (pc->info.request.rhead == NULL)
275                 pc->info.request.rhead = cb_info;
276         else {
277                 current = prev = pc->info.request.rhead;
278                 while (current) {
279                         prev = current;
280                         current = current->next;
281                 }
282
283                 prev->next = cb_info;
284         }
285 }
286
287 static req_cb_info *__find_op_cbinfo(pkgmgr_client_t *pc, const char *req_key)
288 {
289         req_cb_info *tmp;
290
291         tmp = pc->info.request.rhead;
292
293         if (tmp == NULL) {
294                 ERR("tmp is NULL");
295                 return NULL;
296         }
297
298         DBG("tmp->req_key %s, req_key %s", tmp->req_key, req_key);
299
300         while (tmp) {
301                 if (strncmp(tmp->req_key, req_key, strlen(tmp->req_key)) == 0)
302                         return tmp;
303                 tmp = tmp->next;
304         }
305         return NULL;
306 }
307
308 static int __remove_stat_cbinfo(pkgmgr_client_t *pc)
309 {
310         listen_cb_info *info = pc->info.listening.lhead;
311         listen_cb_info *next = NULL;
312
313         while (info != NULL) {
314                 next = info->next;
315                 free(info);
316                 info = next;
317         }
318
319         pc->info.listening.lhead = NULL;
320         return 0;
321 }
322
323 static void __add_app_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
324                               pkgmgr_app_handler event_cb, void *data)
325 {
326         listen_cb_info *cb_info;
327         listen_cb_info *current;
328         listen_cb_info *prev;
329
330         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
331         if (cb_info == NULL) {
332                 DBG("calloc failed");
333                 return;
334         }
335         cb_info->request_id = request_id;
336         cb_info->app_event_cb = event_cb;
337         cb_info->data = data;
338         cb_info->next = NULL;
339
340         if (pc->info.listening.lhead == NULL)
341                 pc->info.listening.lhead = cb_info;
342         else {
343                 current = prev = pc->info.listening.lhead;
344                 while (current) {
345                         prev = current;
346                         current = current->next;
347                 }
348
349                 prev->next = cb_info;
350         }
351 }
352
353 static void __add_stat_cbinfo(pkgmgr_client_t *pc, int request_id,
354                               pkgmgr_handler event_cb, void *data)
355 {
356         listen_cb_info *cb_info;
357         listen_cb_info *current;
358         listen_cb_info *prev;
359
360         cb_info = (listen_cb_info *) calloc(1, sizeof(listen_cb_info));
361         if (cb_info == NULL) {
362                 DBG("calloc failed");
363                 return;
364         }
365         cb_info->request_id = request_id;
366         cb_info->event_cb = event_cb;
367         cb_info->data = data;
368         cb_info->next = NULL;
369
370         /* TODO - check the order of callback - FIFO or LIFO => Should be changed to LIFO */
371         if (pc->info.listening.lhead == NULL)
372                 pc->info.listening.lhead = cb_info;
373         else {
374                 current = prev = pc->info.listening.lhead;
375                 while (current) {
376                         prev = current;
377                         current = current->next;
378                 }
379
380                 prev->next = cb_info;
381         }
382 }
383
384 static void __operation_callback(void *cb_data, uid_t target_uid,
385                                  const char *req_id, const char *pkg_type,
386                                  const char *pkgid,  const char *appid,
387                                  const char *key,    const char *val)
388 {
389         pkgmgr_client_t *pc;
390         req_cb_info *cb_info;
391
392         pc = (pkgmgr_client_t *) cb_data;
393
394         /* find callback info */
395         cb_info = __find_op_cbinfo(pc, req_id);
396         if (cb_info == NULL) {
397                 ERR("cannot find cb_info for req_id:%s", req_id);
398                 return;
399         }
400
401         /* call callback */
402         if (appid != NULL && strlen(appid) != 0 && cb_info->app_event_cb) {
403                 /* run app callback */
404                 if (pc->new_event_cb)
405                         cb_info->app_event_cb(target_uid, cb_info->request_id,
406                                         pkg_type, pkgid, appid, key, val, pc,
407                                         cb_info->data);
408                 else
409                         cb_info->app_event_cb(target_uid, cb_info->request_id,
410                                         pkg_type, pkgid, appid, key, val, NULL,
411                                         cb_info->data);
412         } else if (cb_info->event_cb) {
413                 /* run pkg callback */
414                 if (pc->new_event_cb)
415                         cb_info->event_cb(target_uid, cb_info->request_id,
416                                         pkg_type, pkgid, key, val, pc,
417                                         cb_info->data);
418                 else
419                         cb_info->event_cb(target_uid, cb_info->request_id,
420                                         pkg_type, pkgid, key, val, NULL,
421                                         cb_info->data);
422         }
423
424         return;
425 }
426
427 static void __status_callback(void *cb_data, uid_t target_uid,
428                               const char *req_id, const char *pkg_type,
429                               const char *pkgid,  const char *appid,
430                               const char *key,    const char *val)
431 {
432         pkgmgr_client_t *pc;
433         listen_cb_info *tmp;
434
435         pc = (pkgmgr_client_t *) cb_data;
436
437         tmp = pc->info.listening.lhead;
438         while (tmp) {
439                 if (appid != NULL && strlen(appid) != 0) {
440                         /* run app callback */
441                         if (tmp->app_event_cb && tmp->app_event_cb(
442                                         target_uid, tmp->request_id, pkg_type, pkgid,
443                                         appid, key, val, NULL, tmp->data) != 0)
444                                 break;
445                 } else {
446                         /* run pkg callback */
447                         if (tmp->event_cb && tmp->event_cb(
448                                 target_uid, tmp->request_id, pkg_type, pkgid,
449                                 key, val, NULL, tmp->data) != 0)
450                                 break;
451                 }
452                 tmp = tmp->next;
453         }
454
455         return;
456 }
457
458 static inline int __read_proc(const char *path, char *buf, int size)
459 {
460         int fd = 0;
461         int ret = 0;
462
463         if (buf == NULL || path == NULL)
464                 return -1;
465
466         fd = open(path, O_RDONLY);
467         if (fd < 0)
468                 return -1;
469
470         ret = read(fd, buf, size - 1);
471         if (ret <= 0) {
472                 close(fd);
473                 return -1;
474         } else
475                 buf[ret] = 0;
476
477         close(fd);
478
479         return ret;
480 }
481
482 char *__proc_get_cmdline_bypid(int pid)
483 {
484         char buf[PKG_STRING_LEN_MAX] = {'\0', };
485         int ret = 0;
486
487         snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
488         ret = __read_proc(buf, buf, sizeof(buf));
489         if (ret <= 0)
490                 return NULL;
491
492         /* support app launched by shell script*/
493         if (strncmp(buf, BINSH_NAME, BINSH_SIZE) == 0)
494                 return strdup(&buf[BINSH_SIZE + 1]);
495         else
496                 return strdup(buf);
497 }
498
499 static inline int __pkgmgr_read_proc(const char *path, char *buf, int size)
500 {
501         int fd;
502         int ret;
503
504         if (buf == NULL || path == NULL)
505                 return -1;
506
507         fd = open(path, O_RDONLY);
508         if (fd < 0)
509                 return -1;
510
511         ret = read(fd, buf, size - 1);
512         if (ret <= 0) {
513                 close(fd);
514                 return -1;
515         } else
516                 buf[ret] = 0;
517
518         close(fd);
519
520         return ret;
521 }
522
523 static inline int __pkgmgr_find_pid_by_cmdline(const char *dname,
524                                       const char *cmdline, const char *apppath)
525 {
526         int pid = 0;
527
528         if (strncmp(cmdline, apppath, PKG_STRING_LEN_MAX-1) == 0) {
529                 pid = atoi(dname);
530                 if (pid != getpgid(pid))
531                         pid = 0;
532         }
533
534         return pid;
535 }
536
537 static int __sync_process(const char *req_key)
538 {
539         int ret;
540         char info_file[PKG_STRING_LEN_MAX] = {'\0', };
541         int result = -1;
542         int check_cnt = 0;
543         FILE *fp;
544         char buf[PKG_STRING_LEN_MAX] = {0, };
545
546         snprintf(info_file, PKG_STRING_LEN_MAX, "%s/%s", PKG_SIZE_INFO_PATH, req_key);
547         while(1)
548         {
549                 check_cnt++;
550
551                 if (access(info_file, F_OK) == 0) {
552                         fp = fopen(info_file, "r");
553                         if (fp == NULL) {
554                                 DBG("file is not generated yet.... wait\n");
555                                 usleep(100 * 1000);     /* 100ms sleep*/
556                                 continue;
557                         }
558
559                         if (fgets(buf, PKG_STRING_LEN_MAX, fp) == NULL) {
560                                 ERR("failed to read info file");
561                                 fclose(fp);
562                                 break;
563                         }
564                         fclose(fp);
565
566                         DBG("info_file file is generated, result = %s. \n", buf);
567                         result = atoi(buf);
568                         break;
569                 }
570
571                 DBG("file is not generated yet.... wait\n");
572                 usleep(100 * 1000);     /* 100ms sleep*/
573
574                 if (check_cnt > 6000) { /* 60s * 10 time over*/
575                         ERR("wait time over!!\n");
576                         break;
577                 }
578         }
579
580         ret = remove(info_file);
581         if (ret < 0)
582                 ERR("file is can not remove[%s, %d]\n", info_file, ret);
583
584         return result;
585 }
586
587 static int __csc_process(const char *csc_path, char *result_path)
588 {
589         int ret = 0;
590         int cnt = 0;
591         int count = 0;
592         int csc_fail = 0;
593         int fd = 0;
594         char *pkgtype = NULL;
595         char *des = NULL;
596         char buf[PKG_STRING_LEN_MAX] = {0,};
597         char type_buf[1024] = { 0 };
598         char des_buf[1024] = { 0 };
599         dictionary *csc = NULL;
600         FILE* file = NULL;
601
602         csc = iniparser_load(csc_path);
603         retvm_if(csc == NULL, PKGMGR_R_EINVAL, "cannot open parse file [%s]", csc_path);
604
605         file = fopen(result_path, "w");
606         tryvm_if(file == NULL, ret = PKGMGR_R_EINVAL, "cannot open result file [%s]", result_path);
607
608         count = iniparser_getint(csc, "csc packages:count", -1);
609         tryvm_if(count == 0, ret = PKGMGR_R_ERROR, "csc [%s] dont have packages", csc_path);
610
611         snprintf(buf, PKG_STRING_LEN_MAX, "[result]\n");
612         fwrite(buf, 1, strlen(buf), file);
613         snprintf(buf, PKG_STRING_LEN_MAX, "count = %d\n", count);
614         fwrite(buf, 1, strlen(buf), file);
615
616         for(cnt = 1 ; cnt <= count ; cnt++)
617         {
618                 snprintf(type_buf, PKG_STRING_LEN_MAX - 1, "csc packages:type_%03d", cnt);
619                 snprintf(des_buf, PKG_STRING_LEN_MAX - 1, "csc packages:description_%03d", cnt);
620
621                 pkgtype = iniparser_getstring(csc, type_buf, NULL);
622                 des = iniparser_getstring(csc, des_buf, NULL);
623                 ret = 0;
624
625                 if (pkgtype == NULL) {
626                         csc_fail++;
627                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get pkgtype\n", type_buf);
628                         fwrite(buf, 1, strlen(buf), file);
629                         continue;
630                 } else if (des == NULL) {
631                         csc_fail++;
632                         snprintf(buf, PKG_STRING_LEN_MAX, "%s = Fail to get description\n", des_buf);
633                         fwrite(buf, 1, strlen(buf), file);
634                         continue;
635                 }
636
637                 snprintf(buf, PKG_STRING_LEN_MAX, "type_%03d = %s\n", cnt, pkgtype);
638                 fwrite(buf, 1, strlen(buf), file);
639                 snprintf(buf, PKG_STRING_LEN_MAX, "description_%03d = %s\n", cnt, des);
640                 fwrite(buf, 1, strlen(buf), file);
641
642                 if (strcmp(pkgtype, "tpk") == 0) {
643                         const char *ospinstaller_argv[] = { "/usr/bin/osp-installer", "-c", des, NULL };
644                         ret = __xsystem(ospinstaller_argv);
645                 } else if (strcmp(pkgtype, "wgt")== 0) {
646                         const char *wrtinstaller_argv[] = { "/usr/bin/wrt-installer", "-c", des, NULL };
647                         ret = __xsystem(wrtinstaller_argv);
648                 } else {
649                         csc_fail++;
650                         ret = -1;
651                 }
652
653                 if (ret != 0) {
654                         char *errstr = NULL;
655                         __error_to_string(ret, &errstr);
656                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = fail[%s]\n", cnt, errstr);
657                 }
658                 else
659                         snprintf(buf, PKG_STRING_LEN_MAX, "result_%03d = success\n", cnt);
660
661                 fwrite(buf, 1, strlen(buf), file);
662         }
663
664 catch:
665         iniparser_freedict(csc);
666         if (file != NULL) {
667                 fflush(file);
668                 fd = fileno(file);
669                 fsync(fd);
670                 fclose(file);
671         }
672         return ret;
673 }
674
675 static int __get_size_process(pkgmgr_client * pc, const char *pkgid, uid_t uid,
676                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
677                 void *data)
678 {
679         GVariant *result;
680         int ret = PKGMGR_R_ECOMM;
681         char *req_key = NULL;
682         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
683
684         if (pc == NULL || pkgid == NULL) {
685                 ERR("invalid parameter");
686                 return PKGMGR_R_EINVAL;
687         }
688
689         if (mpc->ctype != PC_REQUEST) {
690                 ERR("mpc->ctype is not PC_REQUEST");
691                 return PKGMGR_R_EINVAL;
692         }
693
694         ret = comm_client_request(mpc->info.request.cc, "getsize",
695                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
696         if (ret != PKGMGR_R_OK) {
697                 ERR("request failed: %d", ret);
698                 return ret;
699         }
700
701         g_variant_get(result, "(i&s)", &ret, &req_key);
702         if (req_key == NULL) {
703                 g_variant_unref(result);
704                 return PKGMGR_R_ECOMM;
705         }
706         if (ret != PKGMGR_R_OK) {
707                 g_variant_unref(result);
708                 return ret;
709         }
710
711         ret = __sync_process(req_key);
712         if (ret < 0)
713                 ERR("get size failed, ret=%d\n", ret);
714
715         g_variant_unref(result);
716
717         return ret;
718 }
719
720 static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
721                 const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
722                 pkgmgr_handler event_cb, void *data)
723 {
724         int ret;
725
726         ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
727         if (ret < 0) {
728                 ERR("move request failed");
729                 return ret;
730         }
731
732         return ret;
733 }
734
735 static int __check_app_process(pkgmgr_request_service_type service_type,
736                 pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
737 {
738         GVariant *result;
739         int ret = PKGMGR_R_ECOMM;
740         pkgmgrinfo_pkginfo_h handle;
741         int pid = -1;
742         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
743
744         retvm_if(mpc->ctype != PC_REQUEST, PKGMGR_R_EINVAL, "mpc->ctype is not PC_REQUEST\n");
745
746         if (uid != GLOBAL_USER)
747                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
748         else
749                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgid, &handle);
750         retvm_if(ret < 0, PKGMGR_R_ERROR, "pkgmgrinfo_pkginfo_get_pkginfo failed");
751
752         if (service_type == PM_REQUEST_KILL_APP)
753                 ret = comm_client_request(mpc->info.request.cc, "kill",
754                                 g_variant_new("(us)", uid, pkgid), &result);
755         else if (service_type == PM_REQUEST_CHECK_APP)
756                 ret = comm_client_request(mpc->info.request.cc, "check",
757                                 g_variant_new("(us)", uid, pkgid), &result);
758         if (ret != PKGMGR_R_OK) {
759                 ERR("request failed: %d", ret);
760                 return ret;
761         }
762
763         g_variant_get(result, "(i)", &ret);
764         g_variant_unref(result);
765         if (ret != PKGMGR_R_OK) {
766                 ERR("request failed, ret=%d", ret);
767                 return ret;
768         }
769
770         /* FIXME */
771         pid  = __sync_process(pkgid);
772         *(int *)data = pid;
773
774         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
775
776         return ret;
777
778 }
779
780 static int __request_size_info(pkgmgr_client *pc, uid_t uid)
781 {
782         GVariant *result;
783         int ret = PKGMGR_R_ECOMM;
784         char *req_key = NULL;
785         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
786
787         if (pc == NULL) {
788                 ERR("invalid parameter");
789                 return PKGMGR_R_EINVAL;
790         }
791
792         if (mpc->ctype != PC_REQUEST) {
793                 ERR("mpc->ctype is not PC_REQUEST");
794                 return PKGMGR_R_EINVAL;
795         }
796
797         ret = comm_client_request(mpc->info.request.cc, "getsize",
798                         g_variant_new("(usi)", uid, "size_info",
799                                 PM_GET_SIZE_INFO),
800                         &result);
801         if (ret != PKGMGR_R_OK) {
802                 ERR("request failed: %d", ret);
803                 return ret;
804         }
805
806         g_variant_get(result, "(i&s)", &ret, &req_key);
807         if (req_key == NULL) {
808                 g_variant_unref(result);
809                 return PKGMGR_R_ECOMM;
810         }
811
812         g_variant_unref(result);
813
814         return ret;
815 }
816
817 static int __change_op_cb_for_getsize(pkgmgr_client *pc)
818 {
819         int ret = -1;
820
821         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
822         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
823
824         /*  free listening head */
825         req_cb_info *tmp = NULL;
826         req_cb_info *prev = NULL;
827         for (tmp = mpc->info.request.rhead; tmp;) {
828                 prev = tmp;
829                 tmp = tmp->next;
830                 free(prev);
831         }
832
833         /* free dbus connection */
834         ret = comm_client_free(mpc->info.request.cc);
835         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
836
837         /* Manage pc for seperated event */
838         mpc->ctype = PC_REQUEST;
839         mpc->status_type = PKGMGR_CLIENT_STATUS_GET_SIZE;
840
841
842         mpc->info.request.cc = comm_client_new();
843         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
844
845         ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_GET_SIZE, mpc->info.request.cc, __operation_callback, pc);
846         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
847
848         return PKGMGR_R_OK;
849 }
850
851 static int __change_op_cb_for_enable_disable(pkgmgr_client *pc, bool is_disable)
852 {
853         int ret = -1;
854
855         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
856         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
857
858         /*  free listening head */
859         req_cb_info *tmp = NULL;
860         req_cb_info *prev = NULL;
861         for (tmp = mpc->info.request.rhead; tmp;) {
862                 prev = tmp;
863                 tmp = tmp->next;
864                 free(prev);
865         }
866
867         /* free dbus connection */
868         ret = comm_client_free(mpc->info.request.cc);
869         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
870
871         /* Manage pc for seperated event */
872         mpc->ctype = PC_REQUEST;
873         if (is_disable)
874                 mpc->status_type = PKGMGR_CLIENT_STATUS_DISABLE_APP;
875         else
876                 mpc->status_type = PKGMGR_CLIENT_STATUS_ENABLE_APP;
877
878
879         mpc->info.request.cc = comm_client_new();
880         retvm_if(mpc->info.request.cc == NULL, PKGMGR_R_ERROR, "client creation failed");
881
882         if (is_disable)
883                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_DISABLE_APP, mpc->info.request.cc, __operation_callback, pc);
884         else
885                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ENABLE_APP, mpc->info.request.cc, __operation_callback, pc);
886         retvm_if(ret < 0, PKGMGR_R_ERROR, "set_status_callback() failed - %d", ret);
887
888         return PKGMGR_R_OK;
889 }
890
891 static int __get_pkg_size_info_cb(uid_t target_uid, int req_id, const char *req_type,
892                 const char *pkgid, const char *key,
893                 const char *value, const void *pc, void *user_data)
894 {
895         int ret = 0;
896         DBG("target_uid: %u, reqid: %d, req type: %s, pkgid: %s, unused key: %s, size info: %s",
897                         target_uid, req_id, req_type, pkgid, key, value);
898
899         pkg_size_info_t *size_info = (pkg_size_info_t *)malloc(sizeof(pkg_size_info_t));
900         retvm_if(size_info == NULL, -1, "The memory is insufficient.");
901
902         char *save_ptr = NULL;
903         char *token = strtok_r((char*)value, ":", &save_ptr);
904         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
905         size_info->data_size = atoll(token);
906         token = strtok_r(NULL, ":", &save_ptr);
907         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
908         size_info->cache_size = atoll(token);
909         token = strtok_r(NULL, ":", &save_ptr);
910         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
911         size_info->app_size = atoll(token);
912         token = strtok_r(NULL, ":", &save_ptr);
913         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
914         size_info->ext_data_size = atoll(token);
915         token = strtok_r(NULL, ":", &save_ptr);
916         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
917         size_info->ext_cache_size = atoll(token);
918         token = strtok_r(NULL, ":", &save_ptr);
919         tryvm_if(token == NULL, ret = -1, "failed to parse sizeinfo");
920         size_info->ext_app_size = atoll(token);
921
922         DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, ext_cache: %lld, ext_app: %lld",
923                         size_info->data_size, size_info->cache_size, size_info->app_size,
924                         size_info->ext_data_size, size_info->ext_cache_size, size_info->ext_app_size);
925
926         pkgmgr_client_t *pmc = (pkgmgr_client_t *)pc;
927         tryvm_if(pmc == NULL, ret = -1, "pkgmgr_client instance is null.");
928
929         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
930         {       // total package size info
931                 pkgmgr_total_pkg_size_info_receive_cb callback = (pkgmgr_total_pkg_size_info_receive_cb)(pmc->new_event_cb);
932                 callback((pkgmgr_client *)pc, size_info, user_data);
933         }
934         else
935         {
936                 pkgmgr_pkg_size_info_receive_cb callback = (pkgmgr_pkg_size_info_receive_cb)(pmc->new_event_cb);
937                 callback((pkgmgr_client *)pc, pkgid, size_info, user_data);
938         }
939
940 catch:
941
942         if(size_info){
943                 free(size_info);
944                 size_info = NULL;
945         }
946         return ret;
947 }
948
949 API pkgmgr_client *pkgmgr_client_new(client_type ctype)
950 {
951         pkgmgr_client_t *pc = NULL;
952         int ret = -1;
953
954         retvm_if(ctype == PC_BROADCAST, NULL, "broadcast type is not supported");
955         retvm_if(ctype != PC_REQUEST && ctype != PC_LISTENING, NULL, "ctype is not client_type");
956
957         /* Allocate memory for ADT:pkgmgr_client */
958         pc = calloc(1, sizeof(pkgmgr_client_t));
959         retvm_if(pc == NULL, NULL, "No memory");
960
961         /* Manage pc */
962         pc->ctype = ctype;
963         pc->status_type = PKGMGR_CLIENT_STATUS_ALL;
964         pc->tep_path = NULL;
965
966         if (pc->ctype == PC_REQUEST) {
967                 pc->info.request.cc = comm_client_new();
968                 trym_if(pc->info.request.cc == NULL, "client creation failed");
969
970                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.request.cc, __operation_callback, pc);
971                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
972         } else if (pc->ctype == PC_LISTENING) {
973                 pc->info.listening.cc = comm_client_new();
974                 trym_if(pc->info.listening.cc == NULL, "client creation failed");
975
976                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ALL, pc->info.listening.cc, __status_callback, pc);
977                 trym_if(ret < 0L, "comm_client_set_status_callback() failed - %d", ret);
978         }
979
980         return (pkgmgr_client *) pc;
981
982  catch:
983         if (pc)
984                 free(pc);
985         return NULL;
986 }
987
988 API int pkgmgr_client_free(pkgmgr_client *pc)
989 {
990         int ret = -1;
991         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
992         retvm_if(mpc == NULL, PKGMGR_R_EINVAL, "Invalid argument");
993
994         if (mpc->ctype == PC_REQUEST) {
995                 req_cb_info *tmp;
996                 req_cb_info *prev;
997                 for (tmp = mpc->info.request.rhead; tmp;) {
998                         prev = tmp;
999                         tmp = tmp->next;
1000                         free(prev);
1001                 }
1002
1003                 ret = comm_client_free(mpc->info.request.cc);
1004                 tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1005         } else if (mpc->ctype == PC_LISTENING) {
1006                         listen_cb_info *tmp;
1007                         listen_cb_info *prev;
1008                         for (tmp = mpc->info.listening.lhead; tmp;) {
1009                                 prev = tmp;
1010                                 tmp = tmp->next;
1011                                 free(prev);
1012                         }
1013
1014                         ret = comm_client_free(mpc->info.listening.cc);
1015                         tryvm_if(ret < 0, ret = PKGMGR_R_ERROR, "comm_client_free() failed");
1016         } else if (mpc->ctype == PC_BROADCAST) {
1017                 ret = 0;
1018         } else {
1019                 ERR("Invalid client type\n");
1020                 return PKGMGR_R_EINVAL;
1021         }
1022
1023         if (mpc->tep_path) {
1024                 free(mpc->tep_path);
1025                 mpc->tep_path = NULL;
1026         }
1027
1028         if (mpc->tep_move) {
1029                 free(mpc->tep_move);
1030                 mpc->tep_move = NULL;
1031         }
1032
1033         free(mpc);
1034         mpc = NULL;
1035         return PKGMGR_R_OK;
1036
1037  catch:
1038         if (mpc) {
1039                 free(mpc);
1040                 mpc = NULL;
1041         }
1042         return PKGMGR_R_ERROR;
1043 }
1044
1045 static char *__get_type_from_path(const char *pkg_path)
1046 {
1047         int ret;
1048         char mimetype[255] = { '\0', };
1049         char extlist[256] = { '\0', };
1050         char *pkg_type;
1051
1052         ret = _get_mime_from_file(pkg_path, mimetype, sizeof(mimetype));
1053         if (ret) {
1054                 ERR("_get_mime_from_file() failed - error code[%d]\n", ret);
1055                 return NULL;
1056         }
1057
1058         ret = _get_mime_extension(mimetype, extlist, sizeof(extlist));
1059         if (ret) {
1060                 ERR("_get_mime_extension() failed - error code[%d]\n", ret);
1061                 return NULL;
1062         }
1063
1064         if (strlen(extlist) == 0)
1065                 return NULL;
1066
1067         if (strchr(extlist, ','))
1068                 extlist[strlen(extlist) - strlen(strchr(extlist, ','))] = '\0';
1069
1070         pkg_type = strchr(extlist, '.') + 1;
1071         return strdup(pkg_type);
1072 }
1073
1074 static int __change_op_cb_for_enable_disable_splash_screen(pkgmgr_client *pc,
1075                 bool is_enable)
1076 {
1077         int ret;
1078         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1079         req_cb_info *tmp;
1080         req_cb_info *prev;
1081
1082         if (mpc == NULL) {
1083                 ERR("package mananger client pc is NULL");
1084                 return PKGMGR_R_EINVAL;
1085         }
1086
1087         for (tmp = mpc->info.request.rhead; tmp;) {
1088                 prev = tmp;
1089                 tmp = tmp->next;
1090                 free(prev);
1091         }
1092
1093         ret = comm_client_free(mpc->info.request.cc);
1094         if (ret < 0) {
1095                 ERR("comm_client_free() failed - %d", ret);
1096                 return PKGMGR_R_ERROR;
1097         }
1098
1099         mpc->ctype = PC_REQUEST;
1100         if (is_enable)
1101                 mpc->status_type = PKGMGR_CLIENT_STATUS_ENABLE_APP_SPLASH_SCREEN;
1102         else
1103                 mpc->status_type = PKGMGR_CLIENT_STATUS_DISABLE_APP_SPLASH_SCREEN;
1104
1105         mpc->info.request.cc = comm_client_new();
1106         if (mpc->info.request.cc == NULL) {
1107                 ERR("client creation failed");
1108                 return PKGMGR_R_ENOMEM;
1109         }
1110
1111         if (is_enable)
1112                 ret = comm_client_set_status_callback(
1113                                 COMM_STATUS_BROADCAST_ENABLE_APP_SPLASH_SCREEN,
1114                                 mpc->info.request.cc, __operation_callback, pc);
1115         else
1116                 ret = comm_client_set_status_callback(
1117                                 COMM_STATUS_BROADCAST_DISABLE_APP_SPLASH_SCREEN,
1118                                 mpc->info.request.cc, __operation_callback, pc);
1119
1120         if (ret < 0) {
1121                 ERR("set_status_callback() failed - %d", ret);
1122                 return PKGMGR_R_ERROR;
1123         }
1124
1125         return PKGMGR_R_OK;
1126 }
1127
1128 API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, char *tep_path, char *tep_move)
1129 {
1130         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1131         retvm_if(tep_path == NULL, PKGMGR_R_EINVAL, "tep path is NULL");
1132         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1133
1134         mpc->tep_path = strdup(tep_path);
1135         mpc->tep_move = strdup(tep_move);
1136
1137         return PKGMGR_R_OK;
1138 }
1139
1140 API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
1141                 const char *descriptor_path, const char *pkg_path,
1142                 const char *optional_data, pkgmgr_mode mode,
1143                 pkgmgr_handler event_cb, void *data, uid_t uid)
1144 {
1145         GVariant *result;
1146         int ret = PKGMGR_R_ECOMM;
1147         char *req_key = NULL;
1148         GVariantBuilder *builder = NULL;
1149         GVariant *args = NULL;
1150         int req_id;
1151         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1152         char *pkgtype;
1153
1154         if (pc == NULL || pkg_path == NULL) {
1155                 ERR("invalid parameter");
1156                 return PKGMGR_R_EINVAL;
1157         }
1158
1159         if (mpc->ctype != PC_REQUEST) {
1160                 ERR("mpc->ctype is not PC_REQUEST");
1161                 return PKGMGR_R_EINVAL;
1162         }
1163
1164         if (access(pkg_path, F_OK) != 0) {
1165                 ERR("failed to access: %s", pkg_path);
1166                 return PKGMGR_R_EINVAL;
1167         }
1168
1169         if (mpc->tep_path != NULL && access(mpc->tep_path, F_OK) != 0) {
1170                 ERR("failed to access: %s", mpc->tep_path);
1171                 return PKGMGR_R_EINVAL;
1172         }
1173
1174         /* TODO: check pkg's type on server-side */
1175         if (pkg_type == NULL)
1176                 pkgtype = __get_type_from_path(pkg_path);
1177         else
1178                 pkgtype = strdup(pkg_type);
1179
1180         /* build arguments */
1181         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1182         if (mpc->tep_path) {
1183                 g_variant_builder_add(builder, "s", "-e");
1184                 g_variant_builder_add(builder, "s", mpc->tep_path);
1185                 g_variant_builder_add(builder, "s", "-M");
1186                 g_variant_builder_add(builder, "s", mpc->tep_move);
1187         }
1188
1189         args = g_variant_new("as", builder);
1190         g_variant_builder_unref(builder);
1191
1192         ret = comm_client_request(mpc->info.request.cc, "install",
1193                         g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
1194                         &result);
1195         if (ret != PKGMGR_R_OK) {
1196                 ERR("request failed: %d", ret);
1197                 return ret;
1198         }
1199
1200         g_variant_get(result, "(i&s)", &ret, &req_key);
1201         if (req_key == NULL) {
1202                 g_variant_unref(result);
1203                 return PKGMGR_R_ECOMM;
1204         }
1205         if (ret != PKGMGR_R_OK) {
1206                 g_variant_unref(result);
1207                 return ret;
1208         }
1209
1210         req_id = _get_request_id();
1211         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1212
1213         g_variant_unref(result);
1214
1215         return req_id;
1216 }
1217
1218 API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
1219                 const char *descriptor_path, const char *pkg_path,
1220                 const char *optional_data, pkgmgr_mode mode,
1221                 pkgmgr_handler event_cb, void *data)
1222 {
1223         return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
1224                         pkg_path, optional_data, mode, event_cb,data,
1225                         _getuid());
1226 }
1227
1228 API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
1229                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
1230                 pkgmgr_handler event_cb, void *data)
1231 {
1232         return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
1233                         mode, event_cb, data, _getuid());
1234 }
1235
1236 API int pkgmgr_client_usr_reinstall(pkgmgr_client * pc, const char *pkg_type,
1237                 const char *pkgid, const char *optional_data, pkgmgr_mode mode,
1238                 pkgmgr_handler event_cb, void *data, uid_t uid)
1239 {
1240         GVariant *result;
1241         int ret = PKGMGR_R_ECOMM;
1242         char *req_key = NULL;
1243         int req_id;
1244         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1245         char *pkgtype;
1246         pkgmgrinfo_pkginfo_h handle;
1247
1248         if (pc == NULL || pkgid == NULL) {
1249                 ERR("invalid parameter");
1250                 return PKGMGR_R_EINVAL;
1251         }
1252
1253         if (mpc->ctype != PC_REQUEST) {
1254                 ERR("mpc->ctype is not PC_REQUEST");
1255                 return PKGMGR_R_EINVAL;
1256         }
1257
1258         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1259         if (ret < 0)
1260                 return PKGMGR_R_EINVAL;
1261
1262         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1263         if (ret < 0) {
1264                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1265                 return PKGMGR_R_ERROR;
1266         }
1267
1268         ret = comm_client_request(mpc->info.request.cc, "reinstall",
1269                         g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
1270         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1271         if (ret != PKGMGR_R_OK) {
1272                 ERR("request failed: %d", ret);
1273                 return ret;
1274         }
1275
1276         g_variant_get(result, "(i&s)", &ret, &req_key);
1277         if (req_key == NULL) {
1278                 g_variant_unref(result);
1279                 return PKGMGR_R_ECOMM;
1280         }
1281         if (ret != PKGMGR_R_OK) {
1282                 g_variant_unref(result);
1283                 return ret;
1284         }
1285
1286         req_id = _get_request_id();
1287         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1288
1289         g_variant_unref(result);
1290
1291         return req_id;
1292 }
1293
1294 API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
1295                 const char *descriptor_path, const char *pkg_path,
1296                 const char *optional_data, pkgmgr_mode mode,
1297                 pkgmgr_handler event_cb, void *data, uid_t uid)
1298 {
1299         GVariant *result;
1300         int ret = PKGMGR_R_ECOMM;
1301         char *req_key = NULL;
1302         GVariantBuilder *builder = NULL;
1303         GVariant *args = NULL;
1304         int req_id;
1305         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1306         char *pkgtype;
1307
1308         if (pc == NULL || pkg_path == NULL) {
1309                 ERR("invalid parameter");
1310                 return PKGMGR_R_EINVAL;
1311         }
1312
1313         if (mpc->ctype != PC_REQUEST) {
1314                 ERR("mpc->ctype is not PC_REQUEST");
1315                 return PKGMGR_R_EINVAL;
1316         }
1317
1318         if (access(pkg_path, F_OK) != 0) {
1319                 ERR("failed to access: %s", pkg_path);
1320                 return PKGMGR_R_EINVAL;
1321         }
1322
1323         if (mpc->tep_path != NULL && access(mpc->tep_path, F_OK) != 0) {
1324                 ERR("failed to access: %s", mpc->tep_path);
1325                 return PKGMGR_R_EINVAL;
1326         }
1327
1328         /* TODO: check pkg's type on server-side */
1329         if (pkg_type == NULL)
1330                 pkgtype = __get_type_from_path(pkg_path);
1331         else
1332                 pkgtype = strdup(pkg_type);
1333
1334         /* build arguments */
1335         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1336         if (mpc->tep_path) {
1337                 g_variant_builder_add(builder, "s", "-e");
1338                 g_variant_builder_add(builder, "s", mpc->tep_path);
1339                 g_variant_builder_add(builder, "s", "-M");
1340                 g_variant_builder_add(builder, "s", mpc->tep_move);
1341         }
1342
1343         args = g_variant_new("as", builder);
1344         g_variant_builder_unref(builder);
1345
1346         ret = comm_client_request(mpc->info.request.cc, "mount_install",
1347                         g_variant_new("(uss@as)", uid, pkgtype, pkg_path, args),
1348                         &result);
1349         if (ret != PKGMGR_R_OK) {
1350                 ERR("request failed: %d", ret);
1351                 return ret;
1352         }
1353
1354         g_variant_get(result, "(i&s)", &ret, &req_key);
1355         if (req_key == NULL) {
1356                 g_variant_unref(result);
1357                 return PKGMGR_R_ECOMM;
1358         }
1359         if (ret != PKGMGR_R_OK) {
1360                 g_variant_unref(result);
1361                 return ret;
1362         }
1363
1364         req_id = _get_request_id();
1365         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1366
1367         g_variant_unref(result);
1368
1369         return req_id;
1370 }
1371
1372 API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
1373                 const char *descriptor_path, const char *pkg_path,
1374                 const char *optional_data, pkgmgr_mode mode,
1375                 pkgmgr_handler event_cb, void *data)
1376 {
1377         return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
1378                         pkg_path, optional_data, mode, event_cb,data,
1379                         _getuid());
1380 }
1381
1382 API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
1383                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1384                 void *data)
1385 {
1386         return pkgmgr_client_usr_uninstall(pc, pkg_type,pkgid, mode, event_cb,
1387                         data, _getuid());
1388 }
1389
1390 API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
1391                 const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
1392                 void *data, uid_t uid)
1393 {
1394         GVariant *result;
1395         int ret = PKGMGR_R_ECOMM;
1396         char *req_key = NULL;
1397         int req_id;
1398         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1399         char *pkgtype;
1400         pkgmgrinfo_pkginfo_h handle;
1401
1402         if (pc == NULL || pkgid == NULL) {
1403                 ERR("invalid parameter");
1404                 return PKGMGR_R_EINVAL;
1405         }
1406
1407         if (mpc->ctype != PC_REQUEST) {
1408                 ERR("mpc->ctype is not PC_REQUEST");
1409                 return PKGMGR_R_EINVAL;
1410         }
1411
1412         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
1413         if (ret < 0)
1414                 return PKGMGR_R_EINVAL;
1415
1416         ret = pkgmgrinfo_pkginfo_get_type(handle, &pkgtype);
1417         if (ret < 0) {
1418                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1419                 return PKGMGR_R_ERROR;
1420         }
1421
1422         ret = comm_client_request(mpc->info.request.cc, "uninstall",
1423                         g_variant_new("(uss)", uid, pkgtype, pkgid), &result);
1424         if (ret != PKGMGR_R_OK) {
1425                 ERR("request failed: %d", ret);
1426                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1427                 return ret;
1428         }
1429
1430         g_variant_get(result, "(i&s)", &ret, &req_key);
1431         if (req_key == NULL) {
1432                 g_variant_unref(result);
1433                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1434                 return PKGMGR_R_ECOMM;
1435         }
1436         if (ret != PKGMGR_R_OK) {
1437                 g_variant_unref(result);
1438                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1439                 return ret;
1440         }
1441
1442         req_id = _get_request_id();
1443         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1444
1445         g_variant_unref(result);
1446         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
1447
1448         return req_id;
1449 }
1450
1451 API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
1452                 const char *pkgid, pkgmgr_move_type move_type,
1453                 pkgmgr_handler event_cb, void *data)
1454 {
1455         return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
1456                         event_cb, data, _getuid());
1457 }
1458 API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
1459                 const char *pkgid, pkgmgr_move_type move_type,
1460                 pkgmgr_handler event_cb, void *data, uid_t uid)
1461 {
1462         GVariant *result;
1463         int ret = PKGMGR_R_ECOMM;
1464         int req_id;
1465         char *req_key = NULL;
1466         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1467
1468         if (pc == NULL || pkg_type == NULL || pkgid == NULL) {
1469                 ERR("invalid parameter");
1470                 return PKGMGR_R_EINVAL;
1471         }
1472
1473         if ((move_type < PM_MOVE_TO_INTERNAL) || (move_type > PM_MOVE_TO_SDCARD))
1474                 return PKGMGR_R_EINVAL;
1475
1476         if (mpc->ctype != PC_REQUEST) {
1477                 ERR("mpc->ctype is not PC_REQUEST");
1478                 return PKGMGR_R_EINVAL;
1479         }
1480
1481         ret = comm_client_request(mpc->info.request.cc, "move",
1482                         g_variant_new("(ussi)", uid, pkg_type, pkgid, move_type), &result);
1483         if (ret != PKGMGR_R_OK) {
1484                 ERR("request failed: %d", ret);
1485                 return ret;
1486         }
1487
1488         g_variant_get(result, "(i&s)", &ret, &req_key);
1489         if (req_key == NULL) {
1490                 g_variant_unref(result);
1491                 return PKGMGR_R_ECOMM;
1492         }
1493         if (ret != PKGMGR_R_OK) {
1494                 g_variant_unref(result);
1495                 return ret;
1496         }
1497
1498         req_id = _get_request_id();
1499         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
1500         g_variant_unref(result);
1501
1502         return ret;
1503 }
1504
1505 API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
1506                 const char *pkgid, uid_t uid)
1507 {
1508         GVariant *result;
1509         int ret = PKGMGR_R_ECOMM;
1510         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1511
1512         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
1513                 ERR("invalid parameter");
1514                 return PKGMGR_R_EINVAL;
1515         }
1516
1517         ret = comm_client_request(mpc->info.request.cc, "enable_pkg",
1518                         g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
1519         if (ret != PKGMGR_R_OK) {
1520                 ERR("request failed: %d", ret);
1521                 return ret;
1522         }
1523
1524         g_variant_get(result, "(i)", &ret);
1525         g_variant_unref(result);
1526
1527         return ret;
1528 }
1529
1530 API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
1531                 const char *pkgid)
1532 {
1533         return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
1534 }
1535
1536 API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
1537                                  const char *pkgid, uid_t uid)
1538 {
1539         GVariant *result;
1540         int ret = PKGMGR_R_ECOMM;
1541         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1542
1543         if (pc == NULL || pkgid == NULL || pkg_type == NULL) {
1544                 ERR("invalid parameter");
1545                 return PKGMGR_R_EINVAL;
1546         }
1547
1548         ret = comm_client_request(mpc->info.request.cc, "disable_pkg",
1549                         g_variant_new("(uss)", uid, pkg_type, pkgid), &result);
1550         if (ret != PKGMGR_R_OK) {
1551                 ERR("request failed: %d", ret);
1552                 return ret;
1553         }
1554
1555         g_variant_get(result, "(i)", &ret);
1556         g_variant_unref(result);
1557
1558         return ret;
1559 }
1560
1561 API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
1562                                  const char *pkgid)
1563 {
1564         return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
1565 }
1566
1567 /* TODO: deprecate? */
1568 API int pkgmgr_client_usr_activate_appv(pkgmgr_client *pc, const char *appid,
1569                 char *const argv[], uid_t uid)
1570 {
1571         return pkgmgr_client_usr_activate_app(pc, appid, NULL, uid);
1572 }
1573
1574 API int pkgmgr_client_activate_appv(pkgmgr_client *pc, const char *appid,
1575                 char *const argv[])
1576 {
1577         return pkgmgr_client_usr_activate_app(pc, appid, NULL, _getuid());
1578 }
1579
1580 API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
1581                 pkgmgr_app_handler app_event_cb, uid_t uid)
1582 {
1583         GVariant *result;
1584         int ret = PKGMGR_R_ECOMM;
1585         int req_id;
1586         char *req_key = NULL;
1587         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1588
1589         if (pc == NULL || appid == NULL) {
1590                 ERR("invalid parameter");
1591                 return PKGMGR_R_EINVAL;
1592         }
1593
1594         if (__change_op_cb_for_enable_disable(mpc, false) < 0) {
1595                 ERR("__change_op_cb_for_enable_disable failed");
1596                 return PKGMGR_R_ESYSTEM;
1597         }
1598
1599         ret = comm_client_request(mpc->info.request.cc, "enable_app",
1600                         g_variant_new("(us)", uid, appid), &result);
1601         if (ret != PKGMGR_R_OK) {
1602                 ERR("request failed: %d", ret);
1603                 return ret;
1604         }
1605
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;
1610         }
1611         if (ret != PKGMGR_R_OK) {
1612                 g_variant_unref(result);
1613                 return ret;
1614         }
1615
1616         req_id = _get_request_id();
1617         __add_op_app_cbinfo(pc, req_id, req_key, app_event_cb, NULL);
1618         g_variant_unref(result);
1619         return ret;
1620 }
1621
1622 API int pkgmgr_client_activate_app(pkgmgr_client * pc, const char *appid, pkgmgr_app_handler app_event_cb)
1623 {
1624         return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb, _getuid());
1625 }
1626
1627 API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
1628                                  const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1629 {
1630         GVariant *result;
1631         int ret = PKGMGR_R_ECOMM;
1632         int req_id;
1633         char *req_key = NULL;
1634         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1635
1636         if (pc == NULL || appid == NULL) {
1637                 ERR("invalid parameter");
1638                 return PKGMGR_R_EINVAL;
1639         }
1640
1641         if (__change_op_cb_for_enable_disable(mpc, false) < 0) {
1642                 ERR("__change_op_cb_for_enable_disable failed");
1643                 return PKGMGR_R_ESYSTEM;
1644         }
1645
1646         ret = comm_client_request(mpc->info.request.cc, "enable_global_app_for_uid",
1647                         g_variant_new("(us)", uid, appid), &result);
1648         if (ret != PKGMGR_R_OK) {
1649                 ERR("request failed: %d", ret);
1650                 return ret;
1651         }
1652
1653         g_variant_get(result, "(i&s)", &ret, &req_key);
1654         if (req_key == NULL) {
1655                 g_variant_unref(result);
1656                 return PKGMGR_R_ECOMM;
1657         }
1658         if (ret != PKGMGR_R_OK) {
1659                 g_variant_unref(result);
1660                 return ret;
1661         }
1662
1663         req_id = _get_request_id();
1664         __add_op_app_cbinfo(pc, req_id, req_key, app_event_cb, NULL);
1665
1666         return ret;
1667 }
1668
1669 API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
1670                 pkgmgr_app_handler app_event_cb, uid_t uid)
1671 {
1672         GVariant *result;
1673         int ret = PKGMGR_R_ECOMM;
1674         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1675         int req_id;
1676         char *req_key = NULL;
1677
1678         if (pc == NULL || appid == NULL) {
1679                 ERR("invalid parameter");
1680                 return PKGMGR_R_EINVAL;
1681         }
1682
1683         /* FIXME */
1684         if (__change_op_cb_for_enable_disable(mpc, true) < 0) {
1685                 ERR("__change_op_cb_for_enable_disable failed");
1686                 return PKGMGR_R_ESYSTEM;
1687         }
1688
1689         ret = comm_client_request(mpc->info.request.cc, "disable_app",
1690                         g_variant_new("(us)", uid, appid), &result);
1691         if (ret != PKGMGR_R_OK) {
1692                 ERR("request failed: %d", ret);
1693                 return ret;
1694         }
1695
1696         g_variant_get(result, "(i&s)", &ret, &req_key);
1697         if (req_key == NULL) {
1698                 g_variant_unref(result);
1699                 return PKGMGR_R_ECOMM;
1700         }
1701         if (ret != PKGMGR_R_OK) {
1702                 g_variant_unref(result);
1703                 return ret;
1704         }
1705
1706         req_id = _get_request_id();
1707         __add_op_app_cbinfo(pc, req_id, req_key, app_event_cb, NULL);
1708
1709         g_variant_unref(result);
1710         return ret;
1711 }
1712
1713 API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid, pkgmgr_app_handler app_event_cb)
1714 {
1715         return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, _getuid());
1716 }
1717
1718 API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
1719                                  const char *appid, pkgmgr_app_handler app_event_cb, uid_t uid)
1720 {
1721         GVariant *result;
1722         int ret = PKGMGR_R_ECOMM;
1723         int req_id;
1724         char *req_key = NULL;
1725         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1726
1727         if (pc == NULL || appid == NULL) {
1728                 ERR("invalid parameter");
1729                 return PKGMGR_R_EINVAL;
1730         }
1731
1732         if (__change_op_cb_for_enable_disable(mpc, true) < 0) {
1733                 ERR("__change_op_cb_for_enable_disable failed");
1734                 return PKGMGR_R_ESYSTEM;
1735         }
1736
1737         ret = comm_client_request(mpc->info.request.cc, "disable_global_app_for_uid",
1738                         g_variant_new("(us)", uid, appid), &result);
1739         if (ret != PKGMGR_R_OK) {
1740                 ERR("request failed: %d", ret);
1741                 return ret;
1742         }
1743
1744         g_variant_get(result, "(i&s)", &ret, &req_key);
1745         if (req_key == NULL) {
1746                 g_variant_unref(result);
1747                 return PKGMGR_R_ECOMM;
1748         }
1749         if (ret != PKGMGR_R_OK) {
1750                 g_variant_unref(result);
1751                 return ret;
1752         }
1753
1754         req_id = _get_request_id();
1755         __add_op_app_cbinfo(pc, req_id, req_key, app_event_cb, NULL);
1756         return ret;
1757 }
1758
1759 API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
1760                 const char *pkg_type, const char *appid, pkgmgr_mode mode,
1761                 uid_t uid)
1762 {
1763         GVariant *result;
1764         int ret = PKGMGR_R_ECOMM;
1765         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1766
1767         if (pc == NULL || pkg_type == NULL || appid == NULL) {
1768                 ERR("invalid parameter");
1769                 return PKGMGR_R_EINVAL;
1770         }
1771
1772         if (mpc->ctype != PC_REQUEST) {
1773                 ERR("mpc->ctype is not PC_REQUEST");
1774                 return PKGMGR_R_EINVAL;
1775         }
1776
1777         ret = comm_client_request(mpc->info.request.cc, "cleardata",
1778                         g_variant_new("(uss)", uid, pkg_type, appid), &result);
1779         if (ret == PKGMGR_R_OK) {
1780                 ERR("request failed: %d", ret);
1781                 return ret;
1782         }
1783
1784         g_variant_get(result, "(i)", &ret);
1785         g_variant_unref(result);
1786
1787         return ret;
1788 }
1789
1790 API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
1791                 const char *appid, pkgmgr_mode mode)
1792 {
1793         return pkgmgr_client_usr_clear_user_data(pc, pkg_type, appid, mode,
1794                         _getuid());
1795 }
1796
1797 API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
1798 {
1799         int ret = -1;
1800
1801         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1802         retvm_if(status_type == PKGMGR_CLIENT_STATUS_ALL, PKGMGR_R_OK, "status_type is PKGMGR_CLIENT_STATUS_ALL");
1803         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
1804
1805         /*  free listening head */
1806         listen_cb_info *tmp = NULL;
1807         listen_cb_info *prev = NULL;
1808         for (tmp = mpc->info.listening.lhead; tmp;) {
1809                 prev = tmp;
1810                 tmp = tmp->next;
1811                 free(prev);
1812         }
1813
1814         /* free dbus connection */
1815         ret = comm_client_free(mpc->info.listening.cc);
1816         retvm_if(ret < 0, PKGMGR_R_ERROR, "comm_client_free() failed - %d", ret);
1817
1818         /* Manage pc for seperated event */
1819         mpc->ctype = PC_LISTENING;
1820         mpc->status_type = status_type;
1821
1822         mpc->info.listening.cc = comm_client_new();
1823         retvm_if(mpc->info.listening.cc == NULL, PKGMGR_R_EINVAL, "client creation failed");
1824
1825         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL) == PKGMGR_CLIENT_STATUS_INSTALL) {
1826                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL, mpc->info.listening.cc, __status_callback, pc);
1827                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "PKGMGR_CLIENT_STATUS_INSTALL failed - %d", ret);
1828         }
1829
1830         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UNINSTALL) == PKGMGR_CLIENT_STATUS_UNINSTALL) {
1831                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UNINSTALL, mpc->info.listening.cc, __status_callback, pc);
1832                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UNINSTALL failed - %d", ret);
1833         }
1834
1835         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_MOVE) == PKGMGR_CLIENT_STATUS_MOVE) {
1836                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_MOVE, mpc->info.listening.cc, __status_callback, pc);
1837                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_MOVE failed - %d", ret);
1838         }
1839
1840         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) == PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS) {
1841                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_INSTALL_PROGRESS, mpc->info.listening.cc, __status_callback, pc);
1842                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_INSTALL_PROGRESS failed - %d", ret);
1843         }
1844
1845         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_UPGRADE) == PKGMGR_CLIENT_STATUS_UPGRADE) {
1846                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_UPGRADE, mpc->info.listening.cc, __status_callback, pc);
1847                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_UPGRADE failed - %d", ret);
1848         }
1849
1850         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_ENABLE_APP) == PKGMGR_CLIENT_STATUS_ENABLE_APP) {
1851                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ENABLE_APP, mpc->info.listening.cc, __status_callback, pc);
1852                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_ENABLE_APP failed - %d", ret);
1853         }
1854
1855         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_DISABLE_APP) == PKGMGR_CLIENT_STATUS_DISABLE_APP) {
1856                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_DISABLE_APP, mpc->info.listening.cc, __status_callback, pc);
1857                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_DISABLE_APP failed - %d", ret);
1858         }
1859
1860         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_ENABLE_APP_SPLASH_SCREEN) == PKGMGR_CLIENT_STATUS_ENABLE_APP_SPLASH_SCREEN) {
1861                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_ENABLE_APP_SPLASH_SCREEN, mpc->info.listening.cc, __status_callback, pc);
1862                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_ENABLE_APP_SPLASH_SCREEN failed - %d", ret);
1863         }
1864
1865         if ((mpc->status_type & PKGMGR_CLIENT_STATUS_DISABLE_APP_SPLASH_SCREEN) == PKGMGR_CLIENT_STATUS_DISABLE_APP_SPLASH_SCREEN) {
1866                 ret = comm_client_set_status_callback(COMM_STATUS_BROADCAST_DISABLE_APP_SPLASH_SCREEN, mpc->info.listening.cc, __status_callback, pc);
1867                 retvm_if(ret < 0, PKGMGR_R_ECOMM, "COMM_STATUS_BROADCAST_DISABLE_APP_SPLASH_SCREEN failed - %d", ret);
1868         }
1869
1870         return PKGMGR_R_OK;
1871 }
1872
1873 API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
1874                                     void *data)
1875 {
1876         int req_id;
1877         /* Check for NULL value of pc */
1878         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1879         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1880
1881         /* 0. check input */
1882         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
1883         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
1884
1885         /* 1. get id */
1886         req_id = _get_request_id();
1887
1888         /* 2. add callback info to pkgmgr_client */
1889         __add_stat_cbinfo(mpc, req_id, event_cb, data);
1890         return req_id;
1891 }
1892
1893 API int pkgmgr_client_listen_app_status(pkgmgr_client *pc, pkgmgr_app_handler event_cb,
1894                                     void *data)
1895 {
1896         int req_id;
1897         /* Check for NULL value of pc */
1898         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1899         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1900
1901         /* 0. check input */
1902         retvm_if(mpc->ctype != PC_LISTENING, PKGMGR_R_EINVAL, "ctype is not PC_LISTENING");
1903         retvm_if(event_cb == NULL, PKGMGR_R_EINVAL, "event_cb is NULL");
1904
1905         /* 1. get id */
1906         req_id = _get_request_id();
1907
1908         /* 2. add app callback info to pkgmgr_client */
1909         __add_app_stat_cbinfo(mpc, req_id, event_cb, data);
1910         return req_id;
1911 }
1912
1913 API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
1914 {
1915         int ret = -1;
1916
1917         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "package manager client pc is NULL");
1918         pkgmgr_client_t *mpc = (pkgmgr_client_t *) pc;
1919
1920         ret = __remove_stat_cbinfo(mpc);
1921         if (ret != 0) {
1922                 ERR("failed to remove status callback");
1923                 return PKGMGR_R_ERROR;
1924         }
1925
1926         return PKGMGR_R_OK;
1927 }
1928
1929 API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
1930                                        const char *pkgid, const char *key,
1931                                        const char *val)
1932 {
1933         /* client cannot broadcast signal */
1934         return PKGMGR_R_OK;
1935 }
1936
1937 API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type, int service_mode,
1938                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid,
1939                               const char *custom_info, pkgmgr_handler event_cb, void *data)
1940 {
1941         return pkgmgr_client_usr_request_service(service_type, service_mode, pc, pkg_type, pkgid, _getuid(), custom_info, event_cb, data);
1942 }
1943
1944 API int pkgmgr_client_usr_request_service(pkgmgr_request_service_type service_type, int service_mode,
1945                                   pkgmgr_client * pc, const char *pkg_type, const char *pkgid, uid_t uid,
1946                               const char *custom_info, pkgmgr_handler event_cb, void *data)
1947 {
1948         int ret =0;
1949
1950         /* Check for NULL value of service type */
1951         retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
1952         retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
1953
1954         switch (service_type) {
1955         case PM_REQUEST_CSC:
1956                 tryvm_if(custom_info == NULL, ret = PKGMGR_R_EINVAL, "custom_info is NULL\n");
1957                 tryvm_if(strlen(custom_info) >= PKG_STRING_LEN_MAX, ret = PKGMGR_R_EINVAL, "custom_info over PKG_STRING_LEN_MAX");
1958                 tryvm_if(data == NULL, ret = PKGMGR_R_EINVAL, "data is NULL\n");
1959
1960                 ret = __csc_process(custom_info, (char *)data);
1961                 if (ret < 0)
1962                         ERR("__csc_process fail \n");
1963                 else
1964                         ret = PKGMGR_R_OK;
1965
1966                 break;
1967
1968         case PM_REQUEST_MOVE:
1969                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1970                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1971                 tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_SDCARD), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1972
1973                 ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
1974                 break;
1975
1976         case PM_REQUEST_GET_SIZE:
1977                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1978                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1979                 tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
1980
1981                 ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
1982                 break;
1983
1984         case PM_REQUEST_KILL_APP:
1985         case PM_REQUEST_CHECK_APP:
1986                 tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
1987                 tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
1988
1989                 ret = __check_app_process(service_type, pc, pkgid, uid, data);
1990                 if (ret < 0)
1991                         ERR("__check_app_process fail \n");
1992                 else
1993                         ret = PKGMGR_R_OK;
1994
1995                 break;
1996
1997         default:
1998                 ERR("Wrong Request\n");
1999                 ret = -1;
2000                 break;
2001         }
2002
2003 catch:
2004
2005         return ret;
2006 }
2007
2008
2009 API int pkgmgr_client_usr_request_size_info(uid_t uid)
2010 {
2011         int ret = 0;
2012         pkgmgr_client *pc = NULL;
2013
2014         pc = pkgmgr_client_new(PC_REQUEST);
2015         retvm_if(pc == NULL, PKGMGR_R_EINVAL, "request pc is null\n");
2016
2017         ret = __request_size_info(pc, uid);
2018         if (ret < 0) {
2019                 ERR("__request_size_info fail \n");
2020         }
2021
2022         pkgmgr_client_free(pc);
2023         return ret;
2024 }
2025
2026 API int pkgmgr_client_request_size_info(void) // get all package size (data, total)
2027 {
2028         return pkgmgr_client_usr_request_size_info(_getuid());
2029 }
2030
2031 API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
2032 {
2033         GVariant *result;
2034         int ret = PKGMGR_R_ECOMM;
2035         pkgmgr_client_t *pc;
2036
2037         if (pkgid == NULL) {
2038                 ERR("invalid parameter");
2039                 return PKGMGR_R_EINVAL;
2040         }
2041
2042         pc = pkgmgr_client_new(PC_REQUEST);
2043         if (pc == NULL) {
2044                 ERR("out of memory");
2045                 return PKGMGR_R_ESYSTEM;
2046         }
2047
2048         ret = comm_client_request(pc->info.request.cc, "clearcache",
2049                         g_variant_new("(us)", uid, pkgid), &result);
2050         if (ret != PKGMGR_R_OK) {
2051                 ERR("request failed: %d", ret);
2052                 return ret;
2053         }
2054
2055         g_variant_get(result, "(i)", &ret);
2056         g_variant_unref(result);
2057
2058         return ret;
2059 }
2060
2061 API int pkgmgr_client_clear_cache_dir(const char *pkgid)
2062 {
2063         return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
2064 }
2065
2066 API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
2067 {
2068         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
2069 }
2070
2071 API int pkgmgr_client_clear_all_cache_dir(void)
2072 {
2073         return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, _getuid());
2074 }
2075
2076 API int pkgmgr_client_get_size(pkgmgr_client * pc, const char *pkgid,
2077                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2078                 void *data)
2079 {
2080         return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
2081                         _getuid());
2082 }
2083
2084 API int pkgmgr_client_usr_get_size(pkgmgr_client * pc, const char *pkgid,
2085                 pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
2086                 void *data, uid_t uid)
2087 {
2088         GVariant *result;
2089         int ret = PKGMGR_R_ECOMM;
2090         char *req_key = NULL;
2091         int req_id;
2092         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2093
2094         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2095                 ERR("invalid parameter");
2096                 return PKGMGR_R_EINVAL;
2097         }
2098
2099         if (mpc->ctype != PC_REQUEST) {
2100                 ERR("mpc->ctype is not PC_REQUEST");
2101                 return PKGMGR_R_EINVAL;
2102         }
2103
2104         /* FIXME */
2105         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2106                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2107         else
2108                 get_type = PM_GET_PKG_SIZE_INFO;
2109
2110         ret = comm_client_request(mpc->info.request.cc, "getsize",
2111                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2112         if (ret != PKGMGR_R_OK) {
2113                 ERR("request failed: %d", ret);
2114                 return ret;
2115         }
2116
2117         g_variant_get(result, "(i&s)", &ret, &req_key);
2118         if (req_key == NULL) {
2119                 g_variant_unref(result);
2120                 return PKGMGR_R_ECOMM;
2121         }
2122         if (ret != PKGMGR_R_OK) {
2123                 g_variant_unref(result);
2124                 return ret;
2125         }
2126
2127         req_id = _get_request_id();
2128         __add_op_cbinfo(mpc, req_id, req_key, event_cb, NULL, data);
2129
2130         g_variant_unref(result);
2131
2132         return PKGMGR_R_OK;
2133 }
2134
2135 API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
2136                 const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
2137                 void *user_data, uid_t uid)
2138 {
2139         GVariant *result;
2140         int ret = PKGMGR_R_ECOMM;
2141         char *req_key = NULL;
2142         int req_id;
2143         int get_type;
2144         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2145
2146         if (pc == NULL || pkgid == NULL || event_cb == NULL) {
2147                 ERR("invalid parameter");
2148                 return PKGMGR_R_EINVAL;
2149         }
2150
2151         if (mpc->ctype != PC_REQUEST) {
2152                 ERR("mpc->ctype is not PC_REQUEST");
2153                 return PKGMGR_R_EINVAL;
2154         }
2155
2156         /* FIXME */
2157         if (__change_op_cb_for_getsize(mpc) < 0) {
2158                 ERR("__change_op_cb_for_getsize failed");
2159                 return PKGMGR_R_ESYSTEM;
2160         }
2161
2162         if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
2163                 get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
2164         else
2165                 get_type = PM_GET_PKG_SIZE_INFO;
2166
2167         ret = comm_client_request(mpc->info.request.cc, "getsize",
2168                         g_variant_new("(usi)", uid, pkgid, get_type), &result);
2169         if (ret != PKGMGR_R_OK) {
2170                 ERR("request failed: %d", ret);
2171                 return ret;
2172         }
2173
2174         g_variant_get(result, "(i&s)", &ret, &req_key);
2175         if (req_key == NULL) {
2176                 g_variant_unref(result);
2177                 return PKGMGR_R_ECOMM;
2178         }
2179         if (ret != PKGMGR_R_OK) {
2180                 g_variant_unref(result);
2181                 return ret;
2182         }
2183
2184         req_id = _get_request_id();
2185         __add_op_cbinfo(mpc, req_id, req_key, __get_pkg_size_info_cb, event_cb,
2186                         user_data);
2187
2188         g_variant_unref(result);
2189
2190         return PKGMGR_R_OK;
2191 }
2192
2193 API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc, const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb, void *user_data)
2194 {
2195         return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb, user_data, _getuid());
2196 }
2197
2198 API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data, uid_t uid)
2199 {       // total package size info
2200         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, uid);
2201 }
2202
2203 API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc, pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
2204 {
2205         return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL, (pkgmgr_pkg_size_info_receive_cb)event_cb, user_data, _getuid());
2206 }
2207
2208 API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
2209                 const char *resp_data, char **req_data, char **license_url)
2210 {
2211         GVariant *result;
2212         int ret;
2213         char *data;
2214         char *url;
2215         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2216
2217         if (pc == NULL || resp_data == NULL || req_data == NULL ||
2218                         license_url == NULL) {
2219                 ERR("invalid parameter");
2220                 return PKGMGR_R_EINVAL;
2221         }
2222
2223         if (mpc->ctype != PC_REQUEST) {
2224                 ERR("mpc->ctype is not PC_REQUEST");
2225                 return PKGMGR_R_EINVAL;
2226         }
2227
2228         ret = comm_client_request(mpc->info.request.cc,
2229                         "generate_license_request",
2230                         g_variant_new("(s)", resp_data), &result);
2231         if (ret != PKGMGR_R_OK) {
2232                 ERR("request failed: %d", ret);
2233                 return ret;
2234         }
2235
2236         g_variant_get(result, "(i&s&s)", &ret, &data, &url);
2237         if (ret != PKGMGR_R_OK) {
2238                 ERR("generate_license_request failed: %d", ret);
2239                 g_variant_unref(result);
2240                 return ret;
2241         }
2242
2243         *req_data = strdup(data);
2244         *license_url = strdup(url);
2245
2246         g_variant_unref(result);
2247
2248         return PKGMGR_R_OK;
2249 }
2250
2251 API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
2252 {
2253         GVariant *result;
2254         int ret;
2255         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2256
2257         if (pc == NULL || resp_data == NULL) {
2258                 ERR("invalid parameter");
2259                 return PKGMGR_R_EINVAL;
2260         }
2261
2262         if (mpc->ctype != PC_REQUEST) {
2263                 ERR("mpc->ctype is not PC_REQUEST");
2264                 return PKGMGR_R_EINVAL;
2265         }
2266
2267         ret = comm_client_request(mpc->info.request.cc,
2268                         "register_license", g_variant_new("(s)", resp_data),
2269                         &result);
2270         if (ret != PKGMGR_R_OK) {
2271                 ERR("request failed: %d", ret);
2272                 return ret;
2273         }
2274
2275         g_variant_get(result, "(i)", &ret);
2276         g_variant_unref(result);
2277         if (ret != PKGMGR_R_OK) {
2278                 ERR("register license failed: %d", ret);
2279                 return ret;
2280         }
2281
2282         return PKGMGR_R_OK;
2283 }
2284
2285 API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
2286                 const char *drm_file_path, const char *decrypted_file_path)
2287 {
2288         GVariant *result;
2289         int ret;
2290         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2291
2292         if (pc == NULL || drm_file_path == NULL ||
2293                         decrypted_file_path == NULL) {
2294                 ERR("invalid parameter");
2295                 return PKGMGR_R_EINVAL;
2296         }
2297
2298         if (mpc->ctype != PC_REQUEST) {
2299                 ERR("mpc->ctype is not PC_REQUEST");
2300                 return PKGMGR_R_EINVAL;
2301         }
2302
2303         ret = comm_client_request(mpc->info.request.cc,
2304                         "decrypt_package",
2305                         g_variant_new("(ss)", drm_file_path,
2306                                 decrypted_file_path),
2307                         &result);
2308         if (ret != PKGMGR_R_OK) {
2309                 ERR("request failed: %d", ret);
2310                 return ret;
2311         }
2312
2313         g_variant_get(result, "(i)", &ret);
2314         g_variant_unref(result);
2315         if (ret != PKGMGR_R_OK) {
2316                 ERR("decrypt_package failed: %d", ret);
2317                 return ret;
2318         }
2319
2320         return PKGMGR_R_OK;
2321 }
2322
2323 API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
2324 {
2325         return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
2326 }
2327
2328 API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
2329                 const char *appid, uid_t uid)
2330 {
2331         int ret;
2332         GVariant *result;
2333         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2334
2335         if (pc == NULL || appid == NULL) {
2336                 ERR("Invalid parameter");
2337                 return PKGMGR_R_EINVAL;
2338         }
2339
2340         ret = __change_op_cb_for_enable_disable_splash_screen(mpc, true);
2341         if (ret < 0) {
2342                 ERR("__change_op_cb_for_enable_disable_splash_screen failed");
2343                 return PKGMGR_R_ESYSTEM;
2344         }
2345
2346         ret = comm_client_request(mpc->info.request.cc,
2347                         "enable_app_splash_screen",
2348                         g_variant_new("(us)", uid, appid), &result);
2349         if (ret != PKGMGR_R_OK) {
2350                 ERR("request failed: %d", ret);
2351                 return ret;
2352         }
2353
2354         g_variant_get(result, "(i)", &ret);
2355         if (ret != PKGMGR_R_OK) {
2356                 g_variant_unref(result);
2357                 return ret;
2358         }
2359
2360         g_variant_unref(result);
2361
2362         return ret;
2363 }
2364
2365 API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
2366                 const char *appid)
2367 {
2368         return pkgmgr_client_usr_disable_splash_screen(pc, appid,
2369                         _getuid());
2370 }
2371
2372 API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
2373                 const char *appid, uid_t uid)
2374 {
2375         int ret;
2376         GVariant *result;
2377         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2378
2379         if (pc == NULL || appid == NULL) {
2380                 ERR("Invalid parameter");
2381                 return PKGMGR_R_EINVAL;
2382         }
2383
2384         ret = __change_op_cb_for_enable_disable_splash_screen(mpc, false);
2385         if (ret < 0) {
2386                 ERR("__change_op_cb_for_enable_disable_splash_screen failed");
2387                 return ret;
2388         }
2389
2390         ret = comm_client_request(mpc->info.request.cc,
2391                         "disable_app_splash_screen",
2392                         g_variant_new("(us)", uid, appid), &result);
2393         if (ret != PKGMGR_R_OK) {
2394                 ERR("request failed: %d", ret);
2395                 return ret;
2396         }
2397
2398         g_variant_get(result, "(i)", &ret);
2399         if (ret != PKGMGR_R_OK) {
2400                 g_variant_unref(result);
2401                 return ret;
2402         }
2403
2404         g_variant_unref(result);
2405
2406         return ret;
2407 }
2408
2409 static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode, uid_t uid)
2410 {
2411         GVariant *result;
2412         int ret = PKGMGR_R_ECOMM;
2413         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2414
2415         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2416                 ERR("invalid parameter");
2417                 return PKGMGR_R_EINVAL;
2418         }
2419
2420         ret = comm_client_request(mpc->info.request.cc, "set_restriction_mode",
2421                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2422         if (ret != PKGMGR_R_OK) {
2423                 ERR("request failed: %d", ret);
2424                 return ret;
2425         }
2426
2427         g_variant_get(result, "(i)", &ret);
2428         g_variant_unref(result);
2429
2430         return ret;
2431 }
2432
2433 API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode, uid_t uid)
2434 {
2435         return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
2436 }
2437
2438 API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode)
2439 {
2440         return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode, _getuid());
2441 }
2442
2443 static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode, uid_t uid)
2444 {
2445         GVariant *result;
2446         int ret = PKGMGR_R_ECOMM;
2447         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2448
2449         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
2450                 ERR("invalid parameter");
2451                 return PKGMGR_R_EINVAL;
2452         }
2453
2454         ret = comm_client_request(mpc->info.request.cc,
2455                         "unset_restriction_mode",
2456                         g_variant_new("(usi)", uid, pkgid, mode), &result);
2457         if (ret != PKGMGR_R_OK) {
2458                 ERR("request failed: %d", ret);
2459                 return ret;
2460         }
2461
2462         g_variant_get(result, "(i)", &ret);
2463         g_variant_unref(result);
2464
2465         return ret;
2466
2467 }
2468
2469 API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode, uid_t uid)
2470 {
2471         return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
2472 }
2473
2474 API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int mode)
2475 {
2476         return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode, _getuid());
2477 }
2478
2479 static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int *mode, uid_t uid)
2480 {
2481         GVariant *result;
2482         int ret = PKGMGR_R_ECOMM;
2483         gint m;
2484         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2485
2486         if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
2487                 ERR("invalid parameter");
2488                 return PKGMGR_R_EINVAL;
2489         }
2490
2491         ret = comm_client_request(mpc->info.request.cc,
2492                         "get_restriction_mode",
2493                         g_variant_new("(us)", uid, pkgid), &result);
2494         if (ret != PKGMGR_R_OK) {
2495                 ERR("request failed: %d", ret);
2496                 return ret;
2497         }
2498
2499         g_variant_get(result, "(ii)", &m, &ret);
2500         g_variant_unref(result);
2501         if (ret != PKGMGR_R_OK)
2502                 return ret;
2503
2504         *mode = m;
2505
2506         return PKGMGR_R_OK;
2507 }
2508
2509 API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int *mode, uid_t uid)
2510 {
2511         return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
2512 }
2513
2514 API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid, int *mode)
2515 {
2516         return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode, _getuid());
2517 }
2518
2519 API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
2520                 uid_t uid)
2521 {
2522         GVariant *result;
2523         int ret = PKGMGR_R_ECOMM;
2524         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2525
2526         if (pc == NULL) {
2527                 ERR("invalid parameter");
2528                 return PKGMGR_R_EINVAL;
2529         }
2530
2531         ret = comm_client_request(mpc->info.request.cc, "set_restriction_mode",
2532                         g_variant_new("(usi)", uid, "", mode), &result);
2533         if (ret != PKGMGR_R_OK) {
2534                 ERR("request failed: %d", ret);
2535                 return ret;
2536         }
2537
2538         g_variant_get(result, "(i)", &ret);
2539         g_variant_unref(result);
2540
2541         return ret;
2542 }
2543
2544 API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
2545 {
2546         return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
2547 }
2548
2549 API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
2550                 uid_t uid)
2551 {
2552         GVariant *result;
2553         int ret = PKGMGR_R_ECOMM;
2554         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2555
2556         if (pc == NULL) {
2557                 ERR("invalid parameter");
2558                 return PKGMGR_R_EINVAL;
2559         }
2560
2561         ret = comm_client_request(mpc->info.request.cc,
2562                         "unset_restriction_mode",
2563                         g_variant_new("(usi)", uid, "", mode), &result);
2564         if (ret != PKGMGR_R_OK) {
2565                 ERR("request failed: %d", ret);
2566                 return ret;
2567         }
2568
2569         g_variant_get(result, "(i)", &ret);
2570         g_variant_unref(result);
2571
2572         return ret;
2573 }
2574
2575 API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
2576 {
2577         return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
2578 }
2579
2580 API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
2581                 int *mode, uid_t uid)
2582 {
2583         GVariant *result;
2584         int ret = PKGMGR_R_ECOMM;
2585         gint m;
2586         pkgmgr_client_t *mpc = (pkgmgr_client_t *)pc;
2587
2588         if (pc == NULL) {
2589                 ERR("invalid parameter");
2590                 return PKGMGR_R_EINVAL;
2591         }
2592
2593         ret = comm_client_request(mpc->info.request.cc,
2594                         "get_restriction_mode",
2595                         g_variant_new("(us)", uid, ""), &result);
2596         if (ret != PKGMGR_R_OK) {
2597                 ERR("request failed: %d", ret);
2598                 return ret;
2599         }
2600
2601         g_variant_get(result, "(ii)", &m, &ret);
2602         g_variant_unref(result);
2603         if (ret != PKGMGR_R_OK)
2604                 return ret;
2605
2606         *mode = m;
2607
2608         return PKGMGR_R_OK;
2609 }
2610
2611 API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc,
2612                 int *mode)
2613 {
2614         return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
2615 }