implement smack to rpm pkg
[platform/core/appfw/pkgmgr-info.git] / parser / pkgmgr_parser.c
1 /*
2  * pkgmgr-info
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 #define _GNU_SOURCE
23 #include <dlfcn.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <unistd.h>
28 #include <ctype.h>
29 #include <time.h>
30 #include <string.h>
31 #include <libxml/parser.h>
32 #include <libxml/xmlreader.h>
33 #include <libxml/xmlschemas.h>
34 #include <vconf.h>
35 #include <glib.h>
36 #include <sys/stat.h>
37
38 #include "pkgmgr_parser.h"
39 #include "pkgmgr_parser_internal.h"
40 #include "pkgmgr_parser_db.h"
41 #include "pkgmgr-info.h"
42
43 #define MANIFEST_RW_DIRECTORY "/opt/share/packages"
44 #define MANIFEST_RO_DIRECTORY "/usr/share/packages"
45 #define ASCII(s) (const char *)s
46 #define XMLCHAR(s) (const xmlChar *)s
47
48 #define PRELOAD_PACKAGE_LIST "/usr/etc/package-manager/preload/preload_list.txt"
49 #define SCHEMA_FILE "/usr/etc/package-manager/preload/manifest.xsd"
50
51 #define MDPARSER_LIST "/usr/etc/package-manager/parserlib/metadata/mdparser_list.txt"
52 #define MDPARSER_NAME   "mdparser:"
53
54 #define SMACK_LIST "/usr/etc/package-manager/pkgmgr_smack_list.txt"
55
56 #define BUFMAX 1024*128
57
58 #define BUFF_SIZE                       256
59 #define APP_OWNER_ID            5000
60 #define APP_GROUP_ID            5000
61
62 #define LIBAPPSVC_PATH "/usr/lib/libappsvc.so.0"
63 #define LIBAIL_PATH "/usr/lib/libail.so.0"
64 #define DESKTOP_RW_PATH "/opt/share/applications/"
65 #define DESKTOP_RO_PATH "/usr/share/applications/"
66 #define MANIFEST_RO_PREFIX "/usr/share/packages/"
67
68 /* operation_type */
69 typedef enum {
70         AIL_INSTALL = 0,
71         AIL_UPDATE,
72         AIL_REMOVE,
73         AIL_CLEAN,
74         AIL_MAX
75 } AIL_TYPE;
76
77 enum rpm_path_type {
78         RPM_PATH_PRIVATE,
79         RPM_PATH_GROUP_RW,
80         RPM_PATH_PUBLIC_RO,
81         RPM_PATH_SETTINGS_RW,
82         RPM_PATH_ANY_LABEL
83 };
84
85 /* operation_type */
86 typedef enum {
87         ACTION_INSTALL = 0,
88         ACTION_UPGRADE,
89         ACTION_UNINSTALL,
90         ACTION_MAX
91 } ACTION_TYPE;
92
93 typedef struct {
94         const char *key;
95         const char *value;
96 } __metadata_t;
97
98 const char *package;
99
100 static int __ps_process_label(xmlTextReaderPtr reader, label_x *label);
101 static int __ps_process_privilege(xmlTextReaderPtr reader, privilege_x *privilege);
102 static int __ps_process_privileges(xmlTextReaderPtr reader, privileges_x *privileges);
103 static int __ps_process_deviceprofile(xmlTextReaderPtr reader, deviceprofile_x *deviceprofile);
104 static int __ps_process_allowed(xmlTextReaderPtr reader, allowed_x *allowed);
105 static int __ps_process_operation(xmlTextReaderPtr reader, operation_x *operation);
106 static int __ps_process_uri(xmlTextReaderPtr reader, uri_x *uri);
107 static int __ps_process_mime(xmlTextReaderPtr reader, mime_x *mime);
108 static int __ps_process_subapp(xmlTextReaderPtr reader, subapp_x *subapp);
109 static int __ps_process_condition(xmlTextReaderPtr reader, condition_x *condition);
110 static int __ps_process_notification(xmlTextReaderPtr reader, notification_x *notifiation);
111 static int __ps_process_category(xmlTextReaderPtr reader, category_x *category);
112 static int __ps_process_metadata(xmlTextReaderPtr reader, metadata_x *metadata);
113 static int __ps_process_permission(xmlTextReaderPtr reader, permission_x *permission);
114 static int __ps_process_compatibility(xmlTextReaderPtr reader, compatibility_x *compatibility);
115 static int __ps_process_resolution(xmlTextReaderPtr reader, resolution_x *resolution);
116 static int __ps_process_request(xmlTextReaderPtr reader, request_x *request);
117 static int __ps_process_define(xmlTextReaderPtr reader, define_x *define);
118 static int __ps_process_appsvc(xmlTextReaderPtr reader, appsvc_x *appsvc);
119 static int __ps_process_launchconditions(xmlTextReaderPtr reader, launchconditions_x *launchconditions);
120 static int __ps_process_datashare(xmlTextReaderPtr reader, datashare_x *datashare);
121 static int __ps_process_icon(xmlTextReaderPtr reader, icon_x *icon);
122 static int __ps_process_author(xmlTextReaderPtr reader, author_x *author);
123 static int __ps_process_description(xmlTextReaderPtr reader, description_x *description);
124 static int __ps_process_capability(xmlTextReaderPtr reader, capability_x *capability);
125 static int __ps_process_license(xmlTextReaderPtr reader, license_x *license);
126 static int __ps_process_appcontrol(xmlTextReaderPtr reader, appcontrol_x *appcontrol);
127 static int __ps_process_datacontrol(xmlTextReaderPtr reader, datacontrol_x *datacontrol);
128 static int __ps_process_uiapplication(xmlTextReaderPtr reader, uiapplication_x *uiapplication);
129 static int __ps_process_serviceapplication(xmlTextReaderPtr reader, serviceapplication_x *serviceapplication);
130 static int __ps_process_font(xmlTextReaderPtr reader, font_x *font);
131 static int __ps_process_theme(xmlTextReaderPtr reader, theme_x *theme);
132 static int __ps_process_daemon(xmlTextReaderPtr reader, daemon_x *daemon);
133 static int __ps_process_ime(xmlTextReaderPtr reader, ime_x *ime);
134 static void __ps_free_label(label_x *label);
135 static void __ps_free_privilege(privilege_x *privilege);
136 static void __ps_free_privileges(privileges_x *privileges);
137 static void __ps_free_deviceprofile(deviceprofile_x * deviceprofile);
138 static void __ps_free_allowed(allowed_x *allowed);
139 static void __ps_free_operation(operation_x *operation);
140 static void __ps_free_uri(uri_x *uri);
141 static void __ps_free_mime(mime_x *mime);
142 static void __ps_free_subapp(subapp_x *subapp);
143 static void __ps_free_condition(condition_x *condition);
144 static void __ps_free_notification(notification_x *notifiation);
145 static void __ps_free_category(category_x *category);
146 static void __ps_free_metadata(metadata_x *metadata);
147 static void __ps_free_permission(permission_x *permission);
148 static void __ps_free_compatibility(compatibility_x *compatibility);
149 static void __ps_free_resolution(resolution_x *resolution);
150 static void __ps_free_request(request_x *request);
151 static void __ps_free_define(define_x *define);
152 static void __ps_free_appsvc(appsvc_x *appsvc);
153 static void __ps_free_launchconditions(launchconditions_x *launchconditions);
154 static void __ps_free_datashare(datashare_x *datashare);
155 static void __ps_free_icon(icon_x *icon);
156 static void __ps_free_author(author_x *author);
157 static void __ps_free_description(description_x *description);
158 static void __ps_free_capability(capability_x *capability);
159 static void __ps_free_license(license_x *license);
160 static void __ps_free_appcontrol(appcontrol_x *appcontrol);
161 static void __ps_free_datacontrol(datacontrol_x *datacontrol);
162 static void __ps_free_uiapplication(uiapplication_x *uiapplication);
163 static void __ps_free_serviceapplication(serviceapplication_x *serviceapplication);
164 static void __ps_free_font(font_x *font);
165 static void __ps_free_theme(theme_x *theme);
166 static void __ps_free_daemon(daemon_x *daemon);
167 static void __ps_free_ime(ime_x *ime);
168 static char *__pkgid_to_manifest(const char *pkgid);
169 static int __next_child_element(xmlTextReaderPtr reader, int depth);
170 static int __start_process(xmlTextReaderPtr reader, manifest_x * mfx);
171 static int __process_manifest(xmlTextReaderPtr reader, manifest_x * mfx);
172 static void __str_trim(char *input);
173 static char *__get_parser_plugin(const char *type);
174 static int __ps_run_parser(xmlDocPtr docPtr, const char *tag, ACTION_TYPE action, const char *pkgid);
175 static int __run_parser_prestep(xmlTextReaderPtr reader, ACTION_TYPE action, const char *pkgid);
176 static void __processNode(xmlTextReaderPtr reader, ACTION_TYPE action, char *const tagv[], const char *pkgid);
177 static void __streamFile(const char *filename, ACTION_TYPE action, char *const tagv[], const char *pkgid);
178 static int __validate_appid(const char *pkgid, const char *appid, char **newappid);
179
180 static int __is_dir(char *dirname)
181 {
182         struct stat stFileInfo;
183         stat(dirname, &stFileInfo);
184         if (S_ISDIR(stFileInfo.st_mode)) {
185                 return 1;
186         }
187         return 0;
188 }
189
190 static void __apply_shared_privileges(char *pkgname, int flag)
191 {
192         char dirpath[BUFF_SIZE] = {'\0'};
193         /*execute privilege APIs. The APIs should not fail*/
194         pkgmgr_parser_privilege_register_package(pkgname);
195
196 #if 0
197         /*home dir. Dont setup path but change smack access to "_" */
198         snprintf(dirpath, BUFF_SIZE, "/usr/apps/%s", pkgname);
199         if (__is_dir(dirpath))
200                 pkgmgr_parser_privilege_change_smack_label(dirpath, "_", 0);/*0 is SMACK_LABEL_ACCESS*/
201         memset(dirpath, '\0', BUFF_SIZE);
202         snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s", pkgname);
203         if (__is_dir(dirpath))
204                 pkgmgr_parser_privilege_change_smack_label(dirpath, "_", 0);/*0 is SMACK_LABEL_ACCESS*/
205         memset(dirpath, '\0', BUFF_SIZE);
206
207         /*/shared dir. Dont setup path but change smack access to "_" */
208         snprintf(dirpath, BUFF_SIZE, "/usr/apps/%s/shared", pkgname);
209         if (__is_dir(dirpath))
210                 pkgmgr_parser_privilege_change_smack_label(dirpath, "_", 0);/*0 is SMACK_LABEL_ACCESS*/
211         memset(dirpath, '\0', BUFF_SIZE);
212         snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s/shared", pkgname);
213         if (__is_dir(dirpath))
214                 pkgmgr_parser_privilege_change_smack_label(dirpath, "_", 0);/*0 is SMACK_LABEL_ACCESS*/
215         memset(dirpath, '\0', BUFF_SIZE);
216
217         /*/shared/res dir. setup path */
218         if (flag == 0)
219                 snprintf(dirpath, BUFF_SIZE, "/usr/apps/%s/shared/res", pkgname);
220         else
221                 snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s/shared/res", pkgname);
222         if (__is_dir(dirpath))
223                 pkgmgr_parser_privilege_setup_path(pkgname, dirpath, RPM_PATH_PUBLIC_RO, NULL);
224         memset(dirpath, '\0', BUFF_SIZE);
225
226         /*/shared/data dir. setup path and change group to 'app'*/
227         if (flag == 0)
228                 snprintf(dirpath, BUFF_SIZE, "/usr/apps/%s/shared/data", pkgname);
229         else
230                 snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s/shared/data", pkgname);
231         if (__is_dir(dirpath)) {
232                 chown(dirpath, APP_OWNER_ID, APP_GROUP_ID);
233                 pkgmgr_parser_privilege_setup_path(pkgname, dirpath, RPM_PATH_PUBLIC_RO, NULL);
234         } else {
235                 memset(dirpath, '\0', BUFF_SIZE);
236                 if (flag == 0)
237                         snprintf(dirpath, BUFF_SIZE, "/opt/usr/apps/%s/shared/data", pkgname);
238                 else
239                         snprintf(dirpath, BUFF_SIZE, "/usr/apps/%s/shared/data", pkgname);
240                 if (__is_dir(dirpath))
241                         chown(dirpath, APP_OWNER_ID, APP_GROUP_ID);
242                         pkgmgr_parser_privilege_setup_path(pkgname, dirpath, RPM_PATH_PUBLIC_RO, NULL);
243         }
244 #endif
245 }
246
247 static void __str_trim(char *input)
248 {
249         char *trim_str = input;
250
251         if (input == NULL)
252                 return;
253
254         while (*input != 0) {
255                 if (!isspace(*input)) {
256                         *trim_str = *input;
257                         trim_str++;
258                 }
259                 input++;
260         }
261
262         *trim_str = 0;
263         return;
264 }
265
266 static int __validate_appid(const char *pkgid, const char *appid, char **newappid)
267 {
268         if (!pkgid || !appid || !newappid) {
269                 DBG("Arg supplied is NULL\n");
270                 return -1;
271         }
272         int pkglen = strlen(pkgid);
273         int applen = strlen(appid);
274         char *ptr = NULL;
275         char *newapp = NULL;
276         int len = 0;
277         if (strncmp(appid, ".", 1) == 0) {
278                 len = pkglen + applen + 1;
279                 newapp = calloc(1,len);
280                 if (newapp == NULL) {
281                         DBG("Malloc failed\n");
282                         return -1;
283                 }
284                 strncpy(newapp, pkgid, pkglen);
285                 strncat(newapp, appid, applen);
286                 DBG("new appid is %s\n", newapp);
287                 *newappid = newapp;
288                 return 0;
289         }
290         if (applen < pkglen) {
291                 DBG("app id is not proper\n");
292                 *newappid = NULL;
293 #ifdef _VALIDATE_APPID_
294                 return -1;
295 #else
296                 return 0;
297 #endif
298         }
299         if (!strcmp(appid, pkgid)) {
300                 DBG("appid is proper\n");
301                 *newappid = NULL;
302                 return 0;
303         }
304         else if (strncmp(appid, pkgid, pkglen) == 0) {
305                 ptr = strstr(appid, pkgid);
306                 ptr = ptr + pkglen;
307                 if (strncmp(ptr, ".", 1) == 0) {
308                         DBG("appid is proper\n");
309                         *newappid = NULL;
310                         return 0;
311                 }
312                 else {
313                         DBG("appid is not proper\n");
314                         *newappid = NULL;
315 #ifdef _VALIDATE_APPID_
316                         return -1;
317 #else
318                         return 0;
319 #endif
320                 }
321         } else {
322                 DBG("appid is not proper\n");
323                 *newappid = NULL;
324 #ifdef _VALIDATE_APPID_
325                 return -1;
326 #else
327                 return 0;
328 #endif
329         }
330         return 0;
331 }
332
333 static char * __get_tag_by_key(char *md_key)
334 {
335         char *md_tag = NULL;
336
337         if (md_key == NULL) {
338                 DBG("md_key is NULL\n");
339                 return NULL;
340         }
341
342         md_tag = strrchr(md_key, 47) + 1;
343
344
345         return strdup(md_tag);
346 }
347
348 static char *__get_mdparser_plugin(const char *type)
349 {
350         FILE *fp = NULL;
351         char buffer[1024] = { 0 };
352         char temp_path[1024] = { 0 };
353         char *path = NULL;
354
355         if (type == NULL) {
356                 DBGE("invalid argument\n");
357                 return NULL;
358         }
359
360         fp = fopen(PKG_PARSER_CONF_PATH, "r");
361         if (fp == NULL) {
362                 DBGE("no matching mdparser\n");
363                 return NULL;
364         }
365
366         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
367                 if (buffer[0] == '#')
368                         continue;
369
370                 __str_trim(buffer);
371
372                 if ((path = strstr(buffer, MDPARSER_NAME)) != NULL) {
373                         path = path + strlen(MDPARSER_NAME);
374
375                         break;
376                 }
377
378                 memset(buffer, 0x00, 1024);
379         }
380
381         if (fp != NULL)
382                 fclose(fp);
383
384         if (path == NULL) {
385                 DBGE("no matching backendlib\n");
386                 return NULL;
387         }
388
389         snprintf(temp_path, sizeof(temp_path) - 1, "%slib%s.so", path, type);
390
391         return strdup(temp_path);
392 }
393
394 static char *__get_parser_plugin(const char *type)
395 {
396         FILE *fp = NULL;
397         char buffer[1024] = { 0 };
398         char temp_path[1024] = { 0 };
399         char *path = NULL;
400
401         if (type == NULL) {
402                 DBGE("invalid argument\n");
403                 return NULL;
404         }
405
406         fp = fopen(PKG_PARSER_CONF_PATH, "r");
407         if (fp == NULL) {
408                 DBGE("no matching backendlib\n");
409                 return NULL;
410         }
411
412         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
413                 if (buffer[0] == '#')
414                         continue;
415
416                 __str_trim(buffer);
417
418                 if ((path = strstr(buffer, PKG_PARSERLIB)) != NULL) {
419                         DBG("[%s]\n", path);
420                         path = path + strlen(PKG_PARSERLIB);
421                         DBG("[%s]\n", path);
422
423                         break;
424                 }
425
426                 memset(buffer, 0x00, 1024);
427         }
428
429         if (fp != NULL)
430                 fclose(fp);
431
432         if (path == NULL) {
433                 DBGE("no matching backendlib\n");
434                 return NULL;
435         }
436
437         snprintf(temp_path, sizeof(temp_path) - 1, "%slib%s.so", path, type);
438         DBG("[%s]\n", temp_path);
439
440         return strdup(temp_path);
441 }
442
443 static int __ps_run_mdparser(GList *md_list, const char *tag,
444                                 ACTION_TYPE action, const char *pkgid, const char *appid)
445 {
446         char *lib_path = NULL;
447         void *lib_handle = NULL;
448         int (*mdparser_plugin) (const char *, const char *, GList *);
449         int ret = -1;
450         char *ac = NULL;
451
452         switch (action) {
453         case ACTION_INSTALL:
454                 ac = "PKGMGR_MDPARSER_PLUGIN_INSTALL";
455                 break;
456         case ACTION_UPGRADE:
457                 ac = "PKGMGR_MDPARSER_PLUGIN_UPGRADE";
458                 break;
459         case ACTION_UNINSTALL:
460                 ac = "PKGMGR_MDPARSER_PLUGIN_UNINSTALL";
461                 break;
462         default:
463                 goto END;
464         }
465
466         lib_path = __get_mdparser_plugin(tag);
467         if (!lib_path) {
468                 DBGE("__get_mdparser_plugin fail\n");
469                 goto END;
470         }
471
472         if ((lib_handle = dlopen(lib_path, RTLD_LAZY)) == NULL) {
473                 DBGE("dlopen is failed lib_path[%s]\n", lib_path);
474                 goto END;
475         }
476
477         if ((mdparser_plugin =
478                 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
479                 DBGE("can not find symbol \n");
480                 goto END;
481         }
482
483         ret = mdparser_plugin(pkgid, appid, md_list);
484         if (ret < 0)
485                 DBGE("[appid = %s, libpath = %s] plugin fail\n", appid, lib_path);
486         else
487                 DBGE("[appid = %s, libpath = %s] plugin success\n", appid, lib_path);
488
489 END:
490         if (lib_path)
491                 free(lib_path);
492         if (lib_handle)
493                 dlclose(lib_handle);
494         return ret;
495 }
496
497 static int __ps_run_parser(xmlDocPtr docPtr, const char *tag,
498                            ACTION_TYPE action, const char *pkgid)
499 {
500         char *lib_path = NULL;
501         void *lib_handle = NULL;
502         int (*plugin_install) (xmlDocPtr, const char *);
503         int ret = -1;
504         char *ac = NULL;
505
506         switch (action) {
507         case ACTION_INSTALL:
508                 ac = "PKGMGR_PARSER_PLUGIN_INSTALL";
509                 break;
510         case ACTION_UPGRADE:
511                 ac = "PKGMGR_PARSER_PLUGIN_UPGRADE";
512                 break;
513         case ACTION_UNINSTALL:
514                 ac = "PKGMGR_PARSER_PLUGIN_UNINSTALL";
515                 break;
516         default:
517                 goto END;
518         }
519
520         lib_path = __get_parser_plugin(tag);
521         if (!lib_path) {
522                 goto END;
523         }
524
525         if ((lib_handle = dlopen(lib_path, RTLD_LAZY)) == NULL) {
526                 DBGE("dlopen is failed lib_path[%s]\n", lib_path);
527                 goto END;
528         }
529         if ((plugin_install =
530                 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
531                 DBGE("can not find symbol \n");
532                 goto END;
533         }
534
535         ret = plugin_install(docPtr, pkgid);
536
537 END:
538         if (lib_path)
539                 free(lib_path);
540         if (lib_handle)
541                 dlclose(lib_handle);
542         return ret;
543 }
544
545 static char *__pkgid_to_manifest(const char *pkgid)
546 {
547         char *manifest;
548         int size;
549
550         if (pkgid == NULL) {
551                 DBGE("pkgid is NULL");
552                 return NULL;
553         }
554
555         size = strlen(MANIFEST_RW_DIRECTORY) + strlen(pkgid) + 10;
556         manifest = malloc(size);
557         if (manifest == NULL) {
558                 DBGE("No memory");
559                 return NULL;
560         }
561         memset(manifest, '\0', size);
562         snprintf(manifest, size, MANIFEST_RW_DIRECTORY "/%s.xml", pkgid);
563
564         if (access(manifest, F_OK)) {
565                 snprintf(manifest, size, MANIFEST_RO_DIRECTORY "/%s.xml", pkgid);
566         }
567
568         return manifest;
569 }
570
571 static void __mdparser_clear_dir_list(GList* dir_list)
572 {
573         GList *list = NULL;
574         __metadata_t* detail = NULL;
575
576         if (dir_list) {
577                 list = g_list_first(dir_list);
578                 while (list) {
579                         detail = (__metadata_t *)list->data;
580                         if (detail) {
581                                 if (detail->key)
582                                         free(detail->key);
583                                 if (detail->value)
584                                         free(detail->value);
585                                 free(detail);
586                         }
587                         list = g_list_next(list);
588                 }
589                 g_list_free(dir_list);
590         }
591 }
592
593 static int __run_mdparser_prestep (manifest_x *mfx, char *md_key, ACTION_TYPE action)
594 {
595         int ret = -1;
596         int tag_exist = 0;
597         char buffer[1024] = { 0, };
598         uiapplication_x *up = mfx->uiapplication;
599         metadata_x *md = NULL;
600         char *md_tag = NULL;
601
602         GList *md_list = NULL;
603         __metadata_t *md_detail = NULL;
604
605         md_tag = __get_tag_by_key(md_key);
606         if (md_tag == NULL) {
607                 DBG("md_tag is NULL\n");
608                 return -1;
609         }
610         DBG("md_tag = %s\n", md_tag);
611
612         while(up != NULL)
613         {
614                 md = up->metadata;
615                 while (md != NULL)
616                 {
617                         //get glist of meatdata key and value combination
618                         memset(buffer, 0x00, 1024);
619                         snprintf(buffer, 1024, "%s/", md_key);
620                         if ((md->key && md->value) && (strncmp(md->key, md_key, strlen(md_key)) == 0) && (strncmp(buffer, md->key, strlen(buffer)) == 0)) {
621                                 md_detail = (__metadata_t*) calloc(1, sizeof(__metadata_t));
622                                 if (md_detail == NULL) {
623                                         DBG("Memory allocation failed\n");
624                                         goto END;
625                                 }
626
627                                 md_detail->key = (char*) calloc(1, sizeof(char)*(strlen(md->key)+2));
628                                 if (md_detail->key == NULL) {
629                                         DBG("Memory allocation failed\n");
630                                         free(md_detail);
631                                         goto END;
632                                 }
633                                 snprintf(md_detail->key, (strlen(md->key)+1), "%s", md->key);
634
635                                 md_detail->value = (char*) calloc(1, sizeof(char)*(strlen(md->value)+2));
636                                 if (md_detail->value == NULL) {
637                                         DBG("Memory allocation failed\n");
638                                         free(md_detail->key);
639                                         free(md_detail);
640                                         goto END;
641                                 }
642                                 snprintf(md_detail->value, (strlen(md->value)+1), "%s", md->value);
643
644                                 md_list = g_list_append(md_list, (gpointer)md_detail);
645                                 tag_exist = 1;
646                         }
647                         md = md->next;
648                 }
649
650                 //send glist to parser when tags for metadata plugin parser exist.
651                 if (tag_exist) {
652                         ret = __ps_run_mdparser(md_list, md_tag, action, mfx->package, up->appid);
653                         if (ret < 0)
654                                 DBG("mdparser failed[%d]\n", ret);
655                         else
656                                 DBG("mdparser success, done[%d]\n", ret);
657                 }
658                 __mdparser_clear_dir_list(md_list);
659                 md_list = NULL;
660                 tag_exist = 0;
661                 up = up->next;
662         }
663
664         return 0;
665 END:
666         __mdparser_clear_dir_list(md_list);
667
668         if (md_tag)
669                 free(md_tag);
670
671         return ret;
672 }
673
674 static int __run_parser_prestep(xmlTextReaderPtr reader, ACTION_TYPE action, const char *pkgid)
675 {
676         int ret = -1;
677         const xmlChar *name;
678
679         DBG("__run_parser_prestep");
680
681         if (xmlTextReaderDepth(reader) != 1) {
682                 DBGE("Node depth is not 1");
683                 goto END;
684         }
685
686         if (xmlTextReaderNodeType(reader) != 1) {
687                 DBGE("Node type is not 1");
688                 goto END;
689         }
690
691         const xmlChar *value;
692         name = xmlTextReaderConstName(reader);
693         if (name == NULL) {
694                 DBGE("TEST TEST TES\n");
695                 name = BAD_CAST "--";
696         }
697
698         value = xmlTextReaderConstValue(reader);
699         DBG("%d %d %s %d %d",
700             xmlTextReaderDepth(reader),
701             xmlTextReaderNodeType(reader),
702             name,
703             xmlTextReaderIsEmptyElement(reader), xmlTextReaderHasValue(reader));
704
705         if (value == NULL) {
706                 DBG("ConstValue NULL");
707         } else {
708                 if (xmlStrlen(value) > 40) {
709                         DBG(" %.40s...", value);
710                 } else {
711                         DBG(" %s", value);
712                 }
713         }
714
715         name = xmlTextReaderConstName(reader);
716         if (name == NULL) {
717                 DBGE("TEST TEST TES\n");
718                 name = BAD_CAST "--";
719         }
720
721         xmlDocPtr docPtr = xmlTextReaderCurrentDoc(reader);
722         DBG("docPtr->URL %s\n", (char *)docPtr->URL);
723         xmlDocPtr copyDocPtr = xmlCopyDoc(docPtr, 1);
724         if (copyDocPtr == NULL)
725                 return -1;
726         xmlNode *rootElement = xmlDocGetRootElement(copyDocPtr);
727         if (rootElement == NULL)
728                 return -1;
729         xmlNode *cur_node = xmlFirstElementChild(rootElement);
730         if (cur_node == NULL)
731                 return -1;
732         xmlNode *temp = xmlTextReaderExpand(reader);
733         if (temp == NULL)
734                 return -1;
735         xmlNode *next_node = NULL;
736         while(cur_node != NULL) {
737                 if ( (strcmp(ASCII(temp->name), ASCII(cur_node->name)) == 0) &&
738                         (temp->line == cur_node->line) ) {
739                         break;
740                 }
741                 else {
742                         next_node = xmlNextElementSibling(cur_node);
743                         xmlUnlinkNode(cur_node);
744                         xmlFreeNode(cur_node);
745                         cur_node = next_node;
746                 }
747         }
748         if (cur_node == NULL)
749                 return -1;
750         next_node = xmlNextElementSibling(cur_node);
751         if (next_node) {
752                 cur_node->next = NULL;
753                 next_node->prev = NULL;
754                 xmlFreeNodeList(next_node);
755                 xmlSetTreeDoc(cur_node, copyDocPtr);
756         } else {
757                 xmlSetTreeDoc(cur_node, copyDocPtr);
758         }
759
760 #ifdef __DEBUG__
761
762 //#else
763         DBG("node type: %d, name: %s children->name: %s last->name: %s\n"
764             "parent->name: %s next->name: %s prev->name: %s\n",
765             cur_node->type, cur_node->name,
766             cur_node->children ? cur_node->children->name : "NULL",
767             cur_node->last ? cur_node->last->name : "NULL",
768             cur_node->parent ? cur_node->parent->name : "NULL",
769             cur_node->next ? cur_node->next->name : "NULL",
770             cur_node->prev ? cur_node->prev->name : "NULL");
771
772         FILE *fp = fopen("/opt/share/test.xml", "a");
773         xmlDocDump(fp, copyDocPtr);
774         fprintf(fp, "\n");
775         fclose(fp);
776 #endif
777
778         ret = __ps_run_parser(copyDocPtr, ASCII(name), action, pkgid);
779  END:
780
781         return ret;
782 }
783
784 static void
785 __processNode(xmlTextReaderPtr reader, ACTION_TYPE action, char *const tagv[], const char *pkgid)
786 {
787         char *tag = NULL;
788         int i = 0;
789
790         switch (xmlTextReaderNodeType(reader)) {
791         case XML_READER_TYPE_END_ELEMENT:
792                 {
793                         //            DBG("XML_READER_TYPE_END_ELEMENT");
794                         break;
795                 }
796
797         case XML_READER_TYPE_ELEMENT:
798                 {
799                         // Elements without closing tag don't receive
800                         // XML_READER_TYPE_END_ELEMENT event.
801
802                         const xmlChar *elementName =
803                             xmlTextReaderLocalName(reader);
804                         if (elementName == NULL) {
805 //                              DBG("elementName %s\n", (char *)elementName);
806                                 break;
807                         }
808
809                         const xmlChar *nameSpace =
810                             xmlTextReaderConstNamespaceUri(reader);
811                         if (nameSpace) {
812 //                              DBG("nameSpace %s\n", (char *)nameSpace);
813                         }
814 /*
815                         DBG("XML_READER_TYPE_ELEMENT %s, %s\n",
816                             elementName ? elementName : "NULL",
817                             nameSpace ? nameSpace : "NULL");
818 */
819                         if (tagv == NULL) {
820                                 DBG("__run_parser_prestep pkgid[%s]\n", pkgid);
821                                 __run_parser_prestep(reader, action, pkgid);
822                         }
823                         else {
824                                 i = 0;
825                                 for (tag = tagv[0]; tag; tag = tagv[++i])
826                                         if (strcmp(tag, ASCII(elementName)) == 0) {
827                                                 DBG("__run_parser_prestep tag[%s] pkgid[%s]\n", tag, pkgid);
828                                                 __run_parser_prestep(reader,
829                                                                      action, pkgid);
830                                                 break;
831                                         }
832                         }
833
834                         break;
835                 }
836         case XML_READER_TYPE_TEXT:
837         case XML_READER_TYPE_CDATA:
838                 {
839                         const xmlChar *value = xmlTextReaderConstValue(reader);
840                         if (value) {
841 //                              DBG("value %s\n", value);
842                         }
843
844                         const xmlChar *lang = xmlTextReaderConstXmlLang(reader);
845                         if (lang) {
846 //                              DBG("lang\n", lang);
847                         }
848
849 /*                      DBG("XML_READER_TYPE_TEXT %s, %s\n",
850                             value ? value : "NULL", lang ? lang : "NULL");
851 */
852                         break;
853                 }
854         default:
855 //              DBG("Ignoring Node of Type: %d", xmlTextReaderNodeType(reader));
856                 break;
857         }
858 }
859
860 static void
861 __streamFile(const char *filename, ACTION_TYPE action, char *const tagv[], const char *pkgid)
862 {
863         xmlTextReaderPtr reader;
864         xmlDocPtr docPtr;
865         int ret;
866
867         docPtr = xmlReadFile(filename, NULL, 0);
868         reader = xmlReaderWalker(docPtr);
869         if (reader != NULL) {
870                 ret = xmlTextReaderRead(reader);
871                 while (ret == 1) {
872                         __processNode(reader, action, tagv, pkgid);
873                         ret = xmlTextReaderRead(reader);
874                 }
875                 xmlFreeTextReader(reader);
876
877                 if (ret != 0) {
878                         DBGE("%s : failed to parse", filename);
879                 }
880         } else {
881                 DBGE("Unable to open %s", filename);
882         }
883 }
884
885 static int __next_child_element(xmlTextReaderPtr reader, int depth)
886 {
887         int ret = xmlTextReaderRead(reader);
888         int cur = xmlTextReaderDepth(reader);
889         while (ret == 1) {
890
891                 switch (xmlTextReaderNodeType(reader)) {
892                 case XML_READER_TYPE_ELEMENT:
893                         if (cur == depth + 1)
894                                 return 1;
895                         break;
896                 case XML_READER_TYPE_TEXT:
897                         /*text is handled by each function separately*/
898                         if (cur == depth + 1)
899                                 return 0;
900                         break;
901                 case XML_READER_TYPE_END_ELEMENT:
902                         if (cur == depth)
903                                 return 0;
904                         break;
905                 default:
906                         if (cur <= depth)
907                                 return 0;
908                         break;
909                 }
910                 ret = xmlTextReaderRead(reader);
911                 cur = xmlTextReaderDepth(reader);
912         }
913         return ret;
914 }
915
916 static void __ps_free_category(category_x *category)
917 {
918         if (category == NULL)
919                 return;
920         if (category->name) {
921                 free((void *)category->name);
922                 category->name = NULL;
923         }
924         free((void*)category);
925         category = NULL;
926 }
927
928 static void __ps_free_privilege(privilege_x *privilege)
929 {
930         if (privilege == NULL)
931                 return;
932         if (privilege->text) {
933                 free((void *)privilege->text);
934                 privilege->text = NULL;
935         }
936         free((void*)privilege);
937         privilege = NULL;
938 }
939
940 static void __ps_free_privileges(privileges_x *privileges)
941 {
942         if (privileges == NULL)
943                 return;
944         /*Free Privilege*/
945         if (privileges->privilege) {
946                 privilege_x *privilege = privileges->privilege;
947                 privilege_x *tmp = NULL;
948                 while(privilege != NULL) {
949                         tmp = privilege->next;
950                         __ps_free_privilege(privilege);
951                         privilege = tmp;
952                 }
953         }
954         free((void*)privileges);
955         privileges = NULL;
956 }
957
958 static void __ps_free_metadata(metadata_x *metadata)
959 {
960         if (metadata == NULL)
961                 return;
962         if (metadata->key) {
963                 free((void *)metadata->key);
964                 metadata->key = NULL;
965         }
966         if (metadata->value) {
967                 free((void *)metadata->value);
968                 metadata->value = NULL;
969         }
970         free((void*)metadata);
971         metadata = NULL;
972 }
973
974 static void __ps_free_permission(permission_x *permission)
975 {
976         if (permission == NULL)
977                 return;
978         if (permission->type) {
979                 free((void *)permission->type);
980                 permission->type = NULL;
981         }
982         if (permission->value) {
983                 free((void *)permission->value);
984                 permission->value = NULL;
985         }
986         free((void*)permission);
987         permission = NULL;
988 }
989
990 static void __ps_free_icon(icon_x *icon)
991 {
992         if (icon == NULL)
993                 return;
994         if (icon->text) {
995                 free((void *)icon->text);
996                 icon->text = NULL;
997         }
998         if (icon->lang) {
999                 free((void *)icon->lang);
1000                 icon->lang = NULL;
1001         }
1002         if (icon->name) {
1003                 free((void *)icon->name);
1004                 icon->name= NULL;
1005         }
1006         if (icon->section) {
1007                 free((void *)icon->section);
1008                 icon->section = NULL;
1009         }
1010         if (icon->size) {
1011                 free((void *)icon->size);
1012                 icon->size = NULL;
1013         }
1014         if (icon->resolution) {
1015                 free((void *)icon->resolution);
1016                 icon->resolution = NULL;
1017         }
1018         free((void*)icon);
1019         icon = NULL;
1020 }
1021
1022 static void __ps_free_image(image_x *image)
1023 {
1024         if (image == NULL)
1025                 return;
1026         if (image->text) {
1027                 free((void *)image->text);
1028                 image->text = NULL;
1029         }
1030         if (image->lang) {
1031                 free((void *)image->lang);
1032                 image->lang = NULL;
1033         }
1034         if (image->name) {
1035                 free((void *)image->name);
1036                 image->name= NULL;
1037         }
1038         if (image->section) {
1039                 free((void *)image->section);
1040                 image->section = NULL;
1041         }
1042         free((void*)image);
1043         image = NULL;
1044 }
1045
1046 static void __ps_free_operation(operation_x *operation)
1047 {
1048         if (operation == NULL)
1049                 return;
1050         if (operation->text) {
1051                 free((void *)operation->text);
1052                 operation->text = NULL;
1053         }
1054         free((void*)operation);
1055         operation = NULL;
1056 }
1057
1058 static void __ps_free_uri(uri_x *uri)
1059 {
1060         if (uri == NULL)
1061                 return;
1062         if (uri->text) {
1063                 free((void *)uri->text);
1064                 uri->text = NULL;
1065         }
1066         free((void*)uri);
1067         uri = NULL;
1068 }
1069
1070 static void __ps_free_mime(mime_x *mime)
1071 {
1072         if (mime == NULL)
1073                 return;
1074         if (mime->text) {
1075                 free((void *)mime->text);
1076                 mime->text = NULL;
1077         }
1078         free((void*)mime);
1079         mime = NULL;
1080 }
1081
1082 static void __ps_free_subapp(subapp_x *subapp)
1083 {
1084         if (subapp == NULL)
1085                 return;
1086         if (subapp->text) {
1087                 free((void *)subapp->text);
1088                 subapp->text = NULL;
1089         }
1090         free((void*)subapp);
1091         subapp = NULL;
1092 }
1093
1094 static void __ps_free_condition(condition_x *condition)
1095 {
1096         if (condition == NULL)
1097                 return;
1098         if (condition->text) {
1099                 free((void *)condition->text);
1100                 condition->text = NULL;
1101         }
1102         if (condition->name) {
1103                 free((void *)condition->name);
1104                 condition->name = NULL;
1105         }
1106         free((void*)condition);
1107         condition = NULL;
1108 }
1109
1110 static void __ps_free_notification(notification_x *notification)
1111 {
1112         if (notification == NULL)
1113                 return;
1114         if (notification->text) {
1115                 free((void *)notification->text);
1116                 notification->text = NULL;
1117         }
1118         if (notification->name) {
1119                 free((void *)notification->name);
1120                 notification->name = NULL;
1121         }
1122         free((void*)notification);
1123         notification = NULL;
1124 }
1125
1126 static void __ps_free_compatibility(compatibility_x *compatibility)
1127 {
1128         if (compatibility == NULL)
1129                 return;
1130         if (compatibility->text) {
1131                 free((void *)compatibility->text);
1132                 compatibility->text = NULL;
1133         }
1134         if (compatibility->name) {
1135                 free((void *)compatibility->name);
1136                 compatibility->name = NULL;
1137         }
1138         free((void*)compatibility);
1139         compatibility = NULL;
1140 }
1141
1142 static void __ps_free_resolution(resolution_x *resolution)
1143 {
1144         if (resolution == NULL)
1145                 return;
1146         if (resolution->mimetype) {
1147                 free((void *)resolution->mimetype);
1148                 resolution->mimetype = NULL;
1149         }
1150         if (resolution->urischeme) {
1151                 free((void *)resolution->urischeme);
1152                 resolution->urischeme = NULL;
1153         }
1154         free((void*)resolution);
1155         resolution = NULL;
1156 }
1157
1158 static void __ps_free_capability(capability_x *capability)
1159 {
1160         if (capability == NULL)
1161                 return;
1162         if (capability->operationid) {
1163                 free((void *)capability->operationid);
1164                 capability->operationid = NULL;
1165         }
1166         /*Free Resolution*/
1167         if (capability->resolution) {
1168                 resolution_x *resolution = capability->resolution;
1169                 resolution_x *tmp = NULL;
1170                 while(resolution != NULL) {
1171                         tmp = resolution->next;
1172                         __ps_free_resolution(resolution);
1173                         resolution = tmp;
1174                 }
1175         }
1176         free((void*)capability);
1177         capability = NULL;
1178 }
1179
1180 static void __ps_free_allowed(allowed_x *allowed)
1181 {
1182         if (allowed == NULL)
1183                 return;
1184         if (allowed->name) {
1185                 free((void *)allowed->name);
1186                 allowed->name = NULL;
1187         }
1188         if (allowed->text) {
1189                 free((void *)allowed->text);
1190                 allowed->text = NULL;
1191         }
1192         free((void*)allowed);
1193         allowed = NULL;
1194 }
1195
1196 static void __ps_free_request(request_x *request)
1197 {
1198         if (request == NULL)
1199                 return;
1200         if (request->text) {
1201                 free((void *)request->text);
1202                 request->text = NULL;
1203         }
1204         free((void*)request);
1205         request = NULL;
1206 }
1207
1208 static void __ps_free_datacontrol(datacontrol_x *datacontrol)
1209 {
1210         if (datacontrol == NULL)
1211                 return;
1212         if (datacontrol->providerid) {
1213                 free((void *)datacontrol->providerid);
1214                 datacontrol->providerid = NULL;
1215         }
1216         /*Free Capability*/
1217         if (datacontrol->capability) {
1218                 capability_x *capability = datacontrol->capability;
1219                 capability_x *tmp = NULL;
1220                 while(capability != NULL) {
1221                         tmp = capability->next;
1222                         __ps_free_capability(capability);
1223                         capability = tmp;
1224                 }
1225         }
1226         free((void*)datacontrol);
1227         datacontrol = NULL;
1228 }
1229
1230 static void __ps_free_launchconditions(launchconditions_x *launchconditions)
1231 {
1232         if (launchconditions == NULL)
1233                 return;
1234         if (launchconditions->text) {
1235                 free((void *)launchconditions->text);
1236                 launchconditions->text = NULL;
1237         }
1238         /*Free Condition*/
1239         if (launchconditions->condition) {
1240                 condition_x *condition = launchconditions->condition;
1241                 condition_x *tmp = NULL;
1242                 while(condition != NULL) {
1243                         tmp = condition->next;
1244                         __ps_free_condition(condition);
1245                         condition = tmp;
1246                 }
1247         }
1248         free((void*)launchconditions);
1249         launchconditions = NULL;
1250 }
1251
1252 static void __ps_free_appcontrol(appcontrol_x *appcontrol)
1253 {
1254         if (appcontrol == NULL)
1255                 return;
1256         if (appcontrol->text) {
1257                 free((void *)appcontrol->text);
1258                 appcontrol->text = NULL;
1259         }
1260         /*Free Operation*/
1261         if (appcontrol->operation) {
1262                 operation_x *operation = appcontrol->operation;
1263                 operation_x *tmp = NULL;
1264                 while(operation != NULL) {
1265                         tmp = operation->next;
1266                         __ps_free_operation(operation);
1267                         operation = tmp;
1268                 }
1269         }
1270         /*Free Uri*/
1271         if (appcontrol->uri) {
1272                 uri_x *uri = appcontrol->uri;
1273                 uri_x *tmp = NULL;
1274                 while(uri != NULL) {
1275                         tmp = uri->next;
1276                         __ps_free_uri(uri);
1277                         uri = tmp;
1278                 }
1279         }
1280         /*Free Mime*/
1281         if (appcontrol->mime) {
1282                 mime_x *mime = appcontrol->mime;
1283                 mime_x *tmp = NULL;
1284                 while(mime != NULL) {
1285                         tmp = mime->next;
1286                         __ps_free_mime(mime);
1287                         mime = tmp;
1288                 }
1289         }
1290         /*Free subapp*/
1291         if (appcontrol->subapp) {
1292                 subapp_x *subapp = appcontrol->subapp;
1293                 subapp_x *tmp = NULL;
1294                 while(subapp != NULL) {
1295                         tmp = subapp->next;
1296                         __ps_free_subapp(subapp);
1297                         subapp = tmp;
1298                 }
1299         }
1300         free((void*)appcontrol);
1301         appcontrol = NULL;
1302 }
1303
1304 static void __ps_free_appsvc(appsvc_x *appsvc)
1305 {
1306         if (appsvc == NULL)
1307                 return;
1308         if (appsvc->text) {
1309                 free((void *)appsvc->text);
1310                 appsvc->text = NULL;
1311         }
1312         /*Free Operation*/
1313         if (appsvc->operation) {
1314                 operation_x *operation = appsvc->operation;
1315                 operation_x *tmp = NULL;
1316                 while(operation != NULL) {
1317                         tmp = operation->next;
1318                         __ps_free_operation(operation);
1319                         operation = tmp;
1320                 }
1321         }
1322         /*Free Uri*/
1323         if (appsvc->uri) {
1324                 uri_x *uri = appsvc->uri;
1325                 uri_x *tmp = NULL;
1326                 while(uri != NULL) {
1327                         tmp = uri->next;
1328                         __ps_free_uri(uri);
1329                         uri = tmp;
1330                 }
1331         }
1332         /*Free Mime*/
1333         if (appsvc->mime) {
1334                 mime_x *mime = appsvc->mime;
1335                 mime_x *tmp = NULL;
1336                 while(mime != NULL) {
1337                         tmp = mime->next;
1338                         __ps_free_mime(mime);
1339                         mime = tmp;
1340                 }
1341         }
1342         /*Free subapp*/
1343         if (appsvc->subapp) {
1344                 subapp_x *subapp = appsvc->subapp;
1345                 subapp_x *tmp = NULL;
1346                 while(subapp != NULL) {
1347                         tmp = subapp->next;
1348                         __ps_free_subapp(subapp);
1349                         subapp = tmp;
1350                 }
1351         }
1352         free((void*)appsvc);
1353         appsvc = NULL;
1354 }
1355
1356 static void __ps_free_deviceprofile(deviceprofile_x *deviceprofile)
1357 {
1358         return;
1359 }
1360
1361 static void __ps_free_define(define_x *define)
1362 {
1363         if (define == NULL)
1364                 return;
1365         if (define->path) {
1366                 free((void *)define->path);
1367                 define->path = NULL;
1368         }
1369         /*Free Request*/
1370         if (define->request) {
1371                 request_x *request = define->request;
1372                 request_x *tmp = NULL;
1373                 while(request != NULL) {
1374                         tmp = request->next;
1375                         __ps_free_request(request);
1376                         request = tmp;
1377                 }
1378         }
1379         /*Free Allowed*/
1380         if (define->allowed) {
1381                 allowed_x *allowed = define->allowed;
1382                 allowed_x *tmp = NULL;
1383                 while(allowed != NULL) {
1384                         tmp = allowed->next;
1385                         __ps_free_allowed(allowed);
1386                         allowed = tmp;
1387                 }
1388         }
1389         free((void*)define);
1390         define = NULL;
1391 }
1392
1393 static void __ps_free_datashare(datashare_x *datashare)
1394 {
1395         if (datashare == NULL)
1396                 return;
1397         /*Free Define*/
1398         if (datashare->define) {
1399                 define_x *define =  datashare->define;
1400                 define_x *tmp = NULL;
1401                 while(define != NULL) {
1402                         tmp = define->next;
1403                         __ps_free_define(define);
1404                         define = tmp;
1405                 }
1406         }
1407         /*Free Request*/
1408         if (datashare->request) {
1409                 request_x *request = datashare->request;
1410                 request_x *tmp = NULL;
1411                 while(request != NULL) {
1412                         tmp = request->next;
1413                         __ps_free_request(request);
1414                         request = tmp;
1415                 }
1416         }
1417         free((void*)datashare);
1418         datashare = NULL;
1419 }
1420
1421 static void __ps_free_label(label_x *label)
1422 {
1423         if (label == NULL)
1424                 return;
1425         if (label->name) {
1426                 free((void *)label->name);
1427                 label->name = NULL;
1428         }
1429         if (label->text) {
1430                 free((void *)label->text);
1431                 label->text = NULL;
1432         }
1433         if (label->lang) {
1434                 free((void *)label->lang);
1435                 label->lang= NULL;
1436         }
1437         free((void*)label);
1438         label = NULL;
1439 }
1440
1441 static void __ps_free_author(author_x *author)
1442 {
1443         if (author == NULL)
1444                 return;
1445         if (author->email) {
1446                 free((void *)author->email);
1447                 author->email = NULL;
1448         }
1449         if (author->text) {
1450                 free((void *)author->text);
1451                 author->text = NULL;
1452         }
1453         if (author->href) {
1454                 free((void *)author->href);
1455                 author->href = NULL;
1456         }
1457         if (author->lang) {
1458                 free((void *)author->lang);
1459                 author->lang = NULL;
1460         }
1461         free((void*)author);
1462         author = NULL;
1463 }
1464
1465 static void __ps_free_description(description_x *description)
1466 {
1467         if (description == NULL)
1468                 return;
1469         if (description->name) {
1470                 free((void *)description->name);
1471                 description->name = NULL;
1472         }
1473         if (description->text) {
1474                 free((void *)description->text);
1475                 description->text = NULL;
1476         }
1477         if (description->lang) {
1478                 free((void *)description->lang);
1479                 description->lang = NULL;
1480         }
1481         free((void*)description);
1482         description = NULL;
1483 }
1484
1485 static void __ps_free_license(license_x *license)
1486 {
1487         if (license == NULL)
1488                 return;
1489         if (license->text) {
1490                 free((void *)license->text);
1491                 license->text = NULL;
1492         }
1493         if (license->lang) {
1494                 free((void *)license->lang);
1495                 license->lang = NULL;
1496         }
1497         free((void*)license);
1498         license = NULL;
1499 }
1500
1501 static void __ps_free_uiapplication(uiapplication_x *uiapplication)
1502 {
1503         if (uiapplication == NULL)
1504                 return;
1505         if (uiapplication->exec) {
1506                 free((void *)uiapplication->exec);
1507                 uiapplication->exec = NULL;
1508         }
1509         if (uiapplication->appid) {
1510                 free((void *)uiapplication->appid);
1511                 uiapplication->appid = NULL;
1512         }
1513         if (uiapplication->nodisplay) {
1514                 free((void *)uiapplication->nodisplay);
1515                 uiapplication->nodisplay = NULL;
1516         }
1517         if (uiapplication->multiple) {
1518                 free((void *)uiapplication->multiple);
1519                 uiapplication->multiple = NULL;
1520         }
1521         if (uiapplication->type) {
1522                 free((void *)uiapplication->type);
1523                 uiapplication->type = NULL;
1524         }
1525         if (uiapplication->categories) {
1526                 free((void *)uiapplication->categories);
1527                 uiapplication->categories = NULL;
1528         }
1529         if (uiapplication->extraid) {
1530                 free((void *)uiapplication->extraid);
1531                 uiapplication->extraid = NULL;
1532         }
1533         if (uiapplication->taskmanage) {
1534                 free((void *)uiapplication->taskmanage);
1535                 uiapplication->taskmanage = NULL;
1536         }
1537         if (uiapplication->enabled) {
1538                 free((void *)uiapplication->enabled);
1539                 uiapplication->enabled = NULL;
1540         }
1541         if (uiapplication->hwacceleration) {
1542                 free((void *)uiapplication->hwacceleration);
1543                 uiapplication->hwacceleration = NULL;
1544         }
1545         if (uiapplication->mainapp) {
1546                 free((void *)uiapplication->mainapp);
1547                 uiapplication->mainapp = NULL;
1548         }
1549         if (uiapplication->recentimage) {
1550                 free((void *)uiapplication->recentimage);
1551                 uiapplication->recentimage = NULL;
1552         }
1553         if (uiapplication->package) {
1554                 free((void *)uiapplication->package);
1555                 uiapplication->package = NULL;
1556         }
1557         if (uiapplication->launchcondition) {
1558                 free((void *)uiapplication->launchcondition);
1559                 uiapplication->launchcondition = NULL;
1560         }
1561         /*Free Label*/
1562         if (uiapplication->label) {
1563                 label_x *label = uiapplication->label;
1564                 label_x *tmp = NULL;
1565                 while(label != NULL) {
1566                         tmp = label->next;
1567                         __ps_free_label(label);
1568                         label = tmp;
1569                 }
1570         }
1571         /*Free Icon*/
1572         if (uiapplication->icon) {
1573                 icon_x *icon = uiapplication->icon;
1574                 icon_x *tmp = NULL;
1575                 while(icon != NULL) {
1576                         tmp = icon->next;
1577                         __ps_free_icon(icon);
1578                         icon = tmp;
1579                 }
1580         }
1581         /*Free image*/
1582         if (uiapplication->image) {
1583                 image_x *image = uiapplication->image;
1584                 image_x *tmp = NULL;
1585                 while(image != NULL) {
1586                         tmp = image->next;
1587                         __ps_free_image(image);
1588                         image = tmp;
1589                 }
1590         }
1591         /*Free AppControl*/
1592         if (uiapplication->appcontrol) {
1593                 appcontrol_x *appcontrol = uiapplication->appcontrol;
1594                 appcontrol_x *tmp = NULL;
1595                 while(appcontrol != NULL) {
1596                         tmp = appcontrol->next;
1597                         __ps_free_appcontrol(appcontrol);
1598                         appcontrol = tmp;
1599                 }
1600         }
1601         /*Free LaunchConditions*/
1602         if (uiapplication->launchconditions) {
1603                 launchconditions_x *launchconditions = uiapplication->launchconditions;
1604                 launchconditions_x *tmp = NULL;
1605                 while(launchconditions != NULL) {
1606                         tmp = launchconditions->next;
1607                         __ps_free_launchconditions(launchconditions);
1608                         launchconditions = tmp;
1609                 }
1610         }
1611         /*Free Notification*/
1612         if (uiapplication->notification) {
1613                 notification_x *notification = uiapplication->notification;
1614                 notification_x *tmp = NULL;
1615                 while(notification != NULL) {
1616                         tmp = notification->next;
1617                         __ps_free_notification(notification);
1618                         notification = tmp;
1619                 }
1620         }
1621         /*Free DataShare*/
1622         if (uiapplication->datashare) {
1623                 datashare_x *datashare = uiapplication->datashare;
1624                 datashare_x *tmp = NULL;
1625                 while(datashare != NULL) {
1626                         tmp = datashare->next;
1627                         __ps_free_datashare(datashare);
1628                         datashare = tmp;
1629                 }
1630         }
1631         /*Free AppSvc*/
1632         if (uiapplication->appsvc) {
1633                 appsvc_x *appsvc = uiapplication->appsvc;
1634                 appsvc_x *tmp = NULL;
1635                 while(appsvc != NULL) {
1636                         tmp = appsvc->next;
1637                         __ps_free_appsvc(appsvc);
1638                         appsvc = tmp;
1639                 }
1640         }
1641         /*Free Category*/
1642         if (uiapplication->category) {
1643                 category_x *category = uiapplication->category;
1644                 category_x *tmp = NULL;
1645                 while(category != NULL) {
1646                         tmp = category->next;
1647                         __ps_free_category(category);
1648                         category = tmp;
1649                 }
1650         }
1651         /*Free Metadata*/
1652         if (uiapplication->metadata) {
1653                 metadata_x *metadata = uiapplication->metadata;
1654                 metadata_x *tmp = NULL;
1655                 while(metadata != NULL) {
1656                         tmp = metadata->next;
1657                         __ps_free_metadata(metadata);
1658                         metadata = tmp;
1659                 }
1660         }
1661         /*Free permission*/
1662         if (uiapplication->permission) {
1663                 permission_x *permission = uiapplication->permission;
1664                 permission_x *tmp = NULL;
1665                 while(permission != NULL) {
1666                         tmp = permission->next;
1667                         __ps_free_permission(permission);
1668                         permission = tmp;
1669                 }
1670         }
1671         /* _PRODUCT_LAUNCHING_ENHANCED_ START */
1672         if (uiapplication->indicatordisplay) {
1673                 free((void *)uiapplication->indicatordisplay);
1674                 uiapplication->indicatordisplay = NULL;
1675         }
1676         if (uiapplication->portraitimg) {
1677                 free((void *)uiapplication->portraitimg);
1678                 uiapplication->portraitimg = NULL;
1679         }
1680         if (uiapplication->landscapeimg) {
1681                 free((void *)uiapplication->landscapeimg);
1682                 uiapplication->landscapeimg = NULL;
1683         }
1684         /* _PRODUCT_LAUNCHING_ENHANCED_ END */
1685         if (uiapplication->guestmode_visibility) {
1686                 free((void *)uiapplication->guestmode_visibility);
1687                 uiapplication->guestmode_visibility = NULL;
1688         }
1689         if (uiapplication->app_component) {
1690                 free((void *)uiapplication->app_component);
1691                 uiapplication->app_component = NULL;
1692         }
1693         if (uiapplication->permission_type) {
1694                 free((void *)uiapplication->permission_type);
1695                 uiapplication->permission_type = NULL;
1696         }
1697         if (uiapplication->component_type) {
1698                 free((void *)uiapplication->component_type);
1699                 uiapplication->component_type = NULL;
1700         }
1701         if (uiapplication->preload) {
1702                 free((void *)uiapplication->preload);
1703                 uiapplication->preload = NULL;
1704         }
1705         if (uiapplication->submode) {
1706                 free((void *)uiapplication->submode);
1707                 uiapplication->submode = NULL;
1708         }
1709         if (uiapplication->submode_mainid) {
1710                 free((void *)uiapplication->submode_mainid);
1711                 uiapplication->submode_mainid = NULL;
1712         }
1713
1714         free((void*)uiapplication);
1715         uiapplication = NULL;
1716 }
1717
1718 static void __ps_free_serviceapplication(serviceapplication_x *serviceapplication)
1719 {
1720         if (serviceapplication == NULL)
1721                 return;
1722         if (serviceapplication->exec) {
1723                 free((void *)serviceapplication->exec);
1724                 serviceapplication->exec = NULL;
1725         }
1726         if (serviceapplication->appid) {
1727                 free((void *)serviceapplication->appid);
1728                 serviceapplication->appid = NULL;
1729         }
1730         if (serviceapplication->onboot) {
1731                 free((void *)serviceapplication->onboot);
1732                 serviceapplication->onboot = NULL;
1733         }
1734         if (serviceapplication->autorestart) {
1735                 free((void *)serviceapplication->autorestart);
1736                 serviceapplication->autorestart = NULL;
1737         }
1738         if (serviceapplication->type) {
1739                 free((void *)serviceapplication->type);
1740                 serviceapplication->type = NULL;
1741         }
1742         if (serviceapplication->enabled) {
1743                 free((void *)serviceapplication->enabled);
1744                 serviceapplication->enabled = NULL;
1745         }
1746         if (serviceapplication->package) {
1747                 free((void *)serviceapplication->package);
1748                 serviceapplication->package = NULL;
1749         }
1750         if (serviceapplication->permission_type) {
1751                 free((void *)serviceapplication->permission_type);
1752                 serviceapplication->permission_type = NULL;
1753         }
1754         /*Free Label*/
1755         if (serviceapplication->label) {
1756                 label_x *label = serviceapplication->label;
1757                 label_x *tmp = NULL;
1758                 while(label != NULL) {
1759                         tmp = label->next;
1760                         __ps_free_label(label);
1761                         label = tmp;
1762                 }
1763         }
1764         /*Free Icon*/
1765         if (serviceapplication->icon) {
1766                 icon_x *icon = serviceapplication->icon;
1767                 icon_x *tmp = NULL;
1768                 while(icon != NULL) {
1769                         tmp = icon->next;
1770                         __ps_free_icon(icon);
1771                         icon = tmp;
1772                 }
1773         }
1774         /*Free AppControl*/
1775         if (serviceapplication->appcontrol) {
1776                 appcontrol_x *appcontrol = serviceapplication->appcontrol;
1777                 appcontrol_x *tmp = NULL;
1778                 while(appcontrol != NULL) {
1779                         tmp = appcontrol->next;
1780                         __ps_free_appcontrol(appcontrol);
1781                         appcontrol = tmp;
1782                 }
1783         }
1784         /*Free DataControl*/
1785         if (serviceapplication->datacontrol) {
1786                 datacontrol_x *datacontrol = serviceapplication->datacontrol;
1787                 datacontrol_x *tmp = NULL;
1788                 while(datacontrol != NULL) {
1789                         tmp = datacontrol->next;
1790                         __ps_free_datacontrol(datacontrol);
1791                         datacontrol = tmp;
1792                 }
1793         }
1794         /*Free LaunchConditions*/
1795         if (serviceapplication->launchconditions) {
1796                 launchconditions_x *launchconditions = serviceapplication->launchconditions;
1797                 launchconditions_x *tmp = NULL;
1798                 while(launchconditions != NULL) {
1799                         tmp = launchconditions->next;
1800                         __ps_free_launchconditions(launchconditions);
1801                         launchconditions = tmp;
1802                 }
1803         }
1804         /*Free Notification*/
1805         if (serviceapplication->notification) {
1806                 notification_x *notification = serviceapplication->notification;
1807                 notification_x *tmp = NULL;
1808                 while(notification != NULL) {
1809                         tmp = notification->next;
1810                         __ps_free_notification(notification);
1811                         notification = tmp;
1812                 }
1813         }
1814         /*Free DataShare*/
1815         if (serviceapplication->datashare) {
1816                 datashare_x *datashare = serviceapplication->datashare;
1817                 datashare_x *tmp = NULL;
1818                 while(datashare != NULL) {
1819                         tmp = datashare->next;
1820                         __ps_free_datashare(datashare);
1821                         datashare = tmp;
1822                 }
1823         }
1824         /*Free AppSvc*/
1825         if (serviceapplication->appsvc) {
1826                 appsvc_x *appsvc = serviceapplication->appsvc;
1827                 appsvc_x *tmp = NULL;
1828                 while(appsvc != NULL) {
1829                         tmp = appsvc->next;
1830                         __ps_free_appsvc(appsvc);
1831                         appsvc = tmp;
1832                 }
1833         }
1834         /*Free Category*/
1835         if (serviceapplication->category) {
1836                 category_x *category = serviceapplication->category;
1837                 category_x *tmp = NULL;
1838                 while(category != NULL) {
1839                         tmp = category->next;
1840                         __ps_free_category(category);
1841                         category = tmp;
1842                 }
1843         }
1844         /*Free Metadata*/
1845         if (serviceapplication->metadata) {
1846                 metadata_x *metadata = serviceapplication->metadata;
1847                 metadata_x *tmp = NULL;
1848                 while(metadata != NULL) {
1849                         tmp = metadata->next;
1850                         __ps_free_metadata(metadata);
1851                         metadata = tmp;
1852                 }
1853         }
1854         /*Free permission*/
1855         if (serviceapplication->permission) {
1856                 permission_x *permission = serviceapplication->permission;
1857                 permission_x *tmp = NULL;
1858                 while(permission != NULL) {
1859                         tmp = permission->next;
1860                         __ps_free_permission(permission);
1861                         permission = tmp;
1862                 }
1863         }
1864         free((void*)serviceapplication);
1865         serviceapplication = NULL;
1866 }
1867
1868 static void __ps_free_font(font_x *font)
1869 {
1870         if (font == NULL)
1871                 return;
1872         if (font->name) {
1873                 free((void *)font->name);
1874                 font->name = NULL;
1875         }
1876         if (font->text) {
1877                 free((void *)font->text);
1878                 font->text = NULL;
1879         }
1880         free((void*)font);
1881         font = NULL;
1882 }
1883
1884 static void __ps_free_theme(theme_x *theme)
1885 {
1886         if (theme == NULL)
1887                 return;
1888         if (theme->name) {
1889                 free((void *)theme->name);
1890                 theme->name = NULL;
1891         }
1892         if (theme->text) {
1893                 free((void *)theme->text);
1894                 theme->text = NULL;
1895         }
1896         free((void*)theme);
1897         theme = NULL;
1898 }
1899
1900 static void __ps_free_daemon(daemon_x *daemon)
1901 {
1902         if (daemon == NULL)
1903                 return;
1904         if (daemon->name) {
1905                 free((void *)daemon->name);
1906                 daemon->name = NULL;
1907         }
1908         if (daemon->text) {
1909                 free((void *)daemon->text);
1910                 daemon->text = NULL;
1911         }
1912         free((void*)daemon);
1913         daemon = NULL;
1914 }
1915
1916 static void __ps_free_ime(ime_x *ime)
1917 {
1918         if (ime == NULL)
1919                 return;
1920         if (ime->name) {
1921                 free((void *)ime->name);
1922                 ime->name = NULL;
1923         }
1924         if (ime->text) {
1925                 free((void *)ime->text);
1926                 ime->text = NULL;
1927         }
1928         free((void*)ime);
1929         ime = NULL;
1930 }
1931
1932 static void __ps_apply_shared_privileges(manifest_x * mfx, const char *manifest)
1933 {
1934         int home_dir = 0;
1935
1936         if(strstr(manifest, MANIFEST_RO_PREFIX))
1937                 home_dir = 0;
1938         else
1939                 home_dir = 1;
1940
1941         if ((strcmp(mfx->type,"tpk")!=0) || (strcmp(mfx->type,"wgt")!=0)){
1942                 DBG("rpm pkg is detected, apply smack\n");
1943                 __apply_shared_privileges(mfx->package, home_dir);
1944         }
1945 }
1946
1947 static void  __ps_process_smack()
1948 {
1949         FILE *fp = NULL;
1950         char pkgid[PKG_STRING_LEN_MAX] = { 0 };
1951
1952         fp = fopen(SMACK_LIST, "r");
1953         if (fp == NULL) {
1954                 DBG("no preload list\n");
1955                 return -1;
1956         }
1957
1958         while (fgets(pkgid, sizeof(pkgid), fp) != NULL) {
1959                 __str_trim(pkgid);
1960                 DBG("pkgid = %s\n", pkgid);
1961
1962                 __apply_shared_privileges(pkgid,0);
1963
1964                 memset(pkgid, 0x00, sizeof(pkgid));
1965         }
1966
1967         if (fp != NULL)
1968                 fclose(fp);
1969
1970         return 0;
1971 }
1972
1973 int __ps_process_mdparser(manifest_x *mfx, ACTION_TYPE action)
1974 {
1975         int ret = -1;
1976         FILE *fp = NULL;
1977         char md_key[PKG_STRING_LEN_MAX] = { 0 };
1978
1979         fp = fopen(MDPARSER_LIST, "r");
1980         if (fp == NULL) {
1981                 DBG("no preload list\n");
1982                 return -1;
1983         }
1984
1985         while (fgets(md_key, sizeof(md_key), fp) != NULL) {
1986                 __str_trim(md_key);
1987                 DBG("md_key = %s\n", md_key);
1988
1989                 ret = __run_mdparser_prestep(mfx, md_key, action);
1990
1991                 memset(md_key, 0x00, sizeof(md_key));
1992         }
1993
1994         if (fp != NULL)
1995                 fclose(fp);
1996
1997         return 0;
1998 }
1999
2000 static int __ps_process_allowed(xmlTextReaderPtr reader, allowed_x *allowed)
2001 {
2002         xmlTextReaderRead(reader);
2003         if (xmlTextReaderValue(reader))
2004                 allowed->text = ASCII(xmlTextReaderValue(reader));
2005         return 0;
2006 }
2007
2008 static int __ps_process_operation(xmlTextReaderPtr reader, operation_x *operation)
2009 {
2010         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2011                 operation->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2012 /* Text does not exist. Only attribute exists
2013         xmlTextReaderRead(reader);
2014         if (xmlTextReaderValue(reader))
2015                 operation->text = ASCII(xmlTextReaderValue(reader));
2016 */
2017         return 0;
2018 }
2019
2020 static int __ps_process_uri(xmlTextReaderPtr reader, uri_x *uri)
2021 {
2022         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2023                 uri->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2024 /* Text does not exist. Only attribute exists
2025         xmlTextReaderRead(reader);
2026         if (xmlTextReaderValue(reader))
2027                 uri->text = ASCII(xmlTextReaderValue(reader));
2028 */
2029         return 0;
2030 }
2031
2032 static int __ps_process_mime(xmlTextReaderPtr reader, mime_x *mime)
2033 {
2034         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2035                 mime->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2036 /* Text does not exist. Only attribute exists
2037         xmlTextReaderRead(reader);
2038         if (xmlTextReaderValue(reader))
2039                 mime->text = ASCII(xmlTextReaderValue(reader));
2040 */
2041         return 0;
2042 }
2043
2044 static int __ps_process_subapp(xmlTextReaderPtr reader, subapp_x *subapp)
2045 {
2046         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2047                 subapp->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2048 /* Text does not exist. Only attribute exists
2049         xmlTextReaderRead(reader);
2050         if (xmlTextReaderValue(reader))
2051                 mime->text = ASCII(xmlTextReaderValue(reader));
2052 */
2053         return 0;
2054 }
2055
2056 static int __ps_process_condition(xmlTextReaderPtr reader, condition_x *condition)
2057 {
2058         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2059                 condition->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2060         xmlTextReaderRead(reader);
2061         if (xmlTextReaderValue(reader))
2062                 condition->text = ASCII(xmlTextReaderValue(reader));
2063         return 0;
2064 }
2065
2066 static int __ps_process_notification(xmlTextReaderPtr reader, notification_x *notification)
2067 {
2068         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2069                 notification->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2070         xmlTextReaderRead(reader);
2071         if (xmlTextReaderValue(reader))
2072                 notification->text = ASCII(xmlTextReaderValue(reader));
2073         return 0;
2074 }
2075
2076 static int __ps_process_category(xmlTextReaderPtr reader, category_x *category)
2077 {
2078         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2079                 category->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2080         return 0;
2081 }
2082
2083 static int __ps_process_privilege(xmlTextReaderPtr reader, privilege_x *privilege)
2084 {
2085         xmlTextReaderRead(reader);
2086         if (xmlTextReaderValue(reader)) {
2087                 privilege->text = ASCII(xmlTextReaderValue(reader));
2088         }
2089         return 0;
2090 }
2091
2092 static int __ps_process_metadata(xmlTextReaderPtr reader, metadata_x *metadata)
2093 {
2094         if (xmlTextReaderGetAttribute(reader, XMLCHAR("key")))
2095                 metadata->key = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("key")));
2096         if (xmlTextReaderGetAttribute(reader, XMLCHAR("value")))
2097                 metadata->value = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("value")));
2098         return 0;
2099 }
2100
2101 static int __ps_process_permission(xmlTextReaderPtr reader, permission_x *permission)
2102 {
2103         if (xmlTextReaderGetAttribute(reader, XMLCHAR("type")))
2104                 permission->type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("type")));
2105
2106         xmlTextReaderRead(reader);
2107         if (xmlTextReaderValue(reader))
2108                 permission->value = ASCII(xmlTextReaderValue(reader));
2109         return 0;
2110 }
2111
2112 static int __ps_process_compatibility(xmlTextReaderPtr reader, compatibility_x *compatibility)
2113 {
2114         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2115                 compatibility->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2116         xmlTextReaderRead(reader);
2117         if (xmlTextReaderValue(reader))
2118                 compatibility->text = ASCII(xmlTextReaderValue(reader));
2119         return 0;
2120 }
2121
2122 static int __ps_process_resolution(xmlTextReaderPtr reader, resolution_x *resolution)
2123 {
2124         if (xmlTextReaderGetAttribute(reader, XMLCHAR("mime-type")))
2125                 resolution->mimetype = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("mime-type")));
2126         if (xmlTextReaderGetAttribute(reader, XMLCHAR("uri-scheme")))
2127                 resolution->urischeme = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("uri-scheme")));
2128         return 0;
2129 }
2130
2131 static int __ps_process_request(xmlTextReaderPtr reader, request_x *request)
2132 {
2133         xmlTextReaderRead(reader);
2134         if (xmlTextReaderValue(reader))
2135                 request->text = ASCII(xmlTextReaderValue(reader));
2136         return 0;
2137 }
2138
2139 static int __ps_process_define(xmlTextReaderPtr reader, define_x *define)
2140 {
2141         const xmlChar *node;
2142         int ret = -1;
2143         int depth = -1;
2144         allowed_x *tmp1 = NULL;
2145         request_x *tmp2 = NULL;
2146
2147         if (xmlTextReaderGetAttribute(reader, XMLCHAR("path")))
2148                 define->path = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("path")));
2149
2150         depth = xmlTextReaderDepth(reader);
2151         while ((ret = __next_child_element(reader, depth))) {
2152                 node = xmlTextReaderConstName(reader);
2153                 if (!node) {
2154                         DBG("xmlTextReaderConstName value is NULL\n");
2155                         return -1;
2156                 }
2157
2158                 if (!strcmp(ASCII(node), "allowed")) {
2159                         allowed_x *allowed= malloc(sizeof(allowed_x));
2160                         if (allowed == NULL) {
2161                                 DBG("Malloc Failed\n");
2162                                 return -1;
2163                         }
2164                         memset(allowed, '\0', sizeof(allowed_x));
2165                         LISTADD(define->allowed, allowed);
2166                         ret = __ps_process_allowed(reader, allowed);
2167                 } else if (!strcmp(ASCII(node), "request")) {
2168                         request_x *request = malloc(sizeof(request_x));
2169                         if (request == NULL) {
2170                                 DBG("Malloc Failed\n");
2171                                 return -1;
2172                         }
2173                         memset(request, '\0', sizeof(request_x));
2174                         LISTADD(define->request, request);
2175                         ret = __ps_process_request(reader, request);
2176                 } else
2177                         return -1;
2178                 if (ret < 0) {
2179                         DBG("Processing define failed\n");
2180                         return ret;
2181                 }
2182         }
2183         if (define->allowed) {
2184                 LISTHEAD(define->allowed, tmp1);
2185                 define->allowed = tmp1;
2186         }
2187         if (define->request) {
2188                 LISTHEAD(define->request, tmp2);
2189                 define->request = tmp2;
2190         }
2191         return ret;
2192 }
2193
2194 static int __ps_process_appcontrol(xmlTextReaderPtr reader, appcontrol_x *appcontrol)
2195 {
2196         const xmlChar *node;
2197         int ret = -1;
2198         int depth = -1;
2199         operation_x *tmp1 = NULL;
2200         uri_x *tmp2 = NULL;
2201         mime_x *tmp3 = NULL;
2202         subapp_x *tmp4 = NULL;
2203
2204         depth = xmlTextReaderDepth(reader);
2205         while ((ret = __next_child_element(reader, depth))) {
2206                 node = xmlTextReaderConstName(reader);
2207                 if (!node) {
2208                         DBG("xmlTextReaderConstName value is NULL\n");
2209                         return -1;
2210                 }
2211
2212                 if (!strcmp(ASCII(node), "operation")) {
2213                         operation_x *operation = malloc(sizeof(operation_x));
2214                         if (operation == NULL) {
2215                                 DBG("Malloc Failed\n");
2216                                 return -1;
2217                         }
2218                         memset(operation, '\0', sizeof(operation_x));
2219                         LISTADD(appcontrol->operation, operation);
2220                         ret = __ps_process_operation(reader, operation);
2221                         DBG("operation processing\n");
2222                 } else if (!strcmp(ASCII(node), "uri")) {
2223                         uri_x *uri= malloc(sizeof(uri_x));
2224                         if (uri == NULL) {
2225                                 DBG("Malloc Failed\n");
2226                                 return -1;
2227                         }
2228                         memset(uri, '\0', sizeof(uri_x));
2229                         LISTADD(appcontrol->uri, uri);
2230                         ret = __ps_process_uri(reader, uri);
2231                         DBG("uri processing\n");
2232                 } else if (!strcmp(ASCII(node), "mime")) {
2233                         mime_x *mime = malloc(sizeof(mime_x));
2234                         if (mime == NULL) {
2235                                 DBG("Malloc Failed\n");
2236                                 return -1;
2237                         }
2238                         memset(mime, '\0', sizeof(mime_x));
2239                         LISTADD(appcontrol->mime, mime);
2240                         ret = __ps_process_mime(reader, mime);
2241                         DBG("mime processing\n");
2242                 } else if (!strcmp(ASCII(node), "subapp")) {
2243                         subapp_x *subapp = malloc(sizeof(subapp_x));
2244                         if (subapp == NULL) {
2245                                 DBG("Malloc Failed\n");
2246                                 return -1;
2247                         }
2248                         memset(subapp, '\0', sizeof(subapp_x));
2249                         LISTADD(appcontrol->subapp, subapp);
2250                         ret = __ps_process_subapp(reader, subapp);
2251                         DBG("subapp processing\n");
2252                 } else
2253                         return -1;
2254                 if (ret < 0) {
2255                         DBG("Processing appcontrol failed\n");
2256                         return ret;
2257                 }
2258         }
2259         if (appcontrol->operation) {
2260                 LISTHEAD(appcontrol->operation, tmp1);
2261                 appcontrol->operation = tmp1;
2262         }
2263         if (appcontrol->uri) {
2264                 LISTHEAD(appcontrol->uri, tmp2);
2265                 appcontrol->uri = tmp2;
2266         }
2267         if (appcontrol->mime) {
2268                 LISTHEAD(appcontrol->mime, tmp3);
2269                 appcontrol->mime = tmp3;
2270         }
2271         if (appcontrol->subapp) {
2272                 LISTHEAD(appcontrol->subapp, tmp4);
2273                 appcontrol->subapp = tmp4;
2274         }
2275
2276         xmlTextReaderRead(reader);
2277         if (xmlTextReaderValue(reader))
2278                 appcontrol->text = ASCII(xmlTextReaderValue(reader));
2279
2280         return ret;
2281 }
2282
2283 static int __ps_process_appsvc(xmlTextReaderPtr reader, appsvc_x *appsvc)
2284 {
2285         const xmlChar *node;
2286         int ret = -1;
2287         int depth = -1;
2288         operation_x *tmp1 = NULL;
2289         uri_x *tmp2 = NULL;
2290         mime_x *tmp3 = NULL;
2291         subapp_x *tmp4 = NULL;
2292
2293         depth = xmlTextReaderDepth(reader);
2294         while ((ret = __next_child_element(reader, depth))) {
2295                 node = xmlTextReaderConstName(reader);
2296                 if (!node) {
2297                         DBG("xmlTextReaderConstName value is NULL\n");
2298                         return -1;
2299                 }
2300
2301                 if (!strcmp(ASCII(node), "operation")) {
2302                         operation_x *operation = malloc(sizeof(operation_x));
2303                         if (operation == NULL) {
2304                                 DBG("Malloc Failed\n");
2305                                 return -1;
2306                         }
2307                         memset(operation, '\0', sizeof(operation_x));
2308                         LISTADD(appsvc->operation, operation);
2309                         ret = __ps_process_operation(reader, operation);
2310                         DBG("operation processing\n");
2311                 } else if (!strcmp(ASCII(node), "uri")) {
2312                         uri_x *uri= malloc(sizeof(uri_x));
2313                         if (uri == NULL) {
2314                                 DBG("Malloc Failed\n");
2315                                 return -1;
2316                         }
2317                         memset(uri, '\0', sizeof(uri_x));
2318                         LISTADD(appsvc->uri, uri);
2319                         ret = __ps_process_uri(reader, uri);
2320                         DBG("uri processing\n");
2321                 } else if (!strcmp(ASCII(node), "mime")) {
2322                         mime_x *mime = malloc(sizeof(mime_x));
2323                         if (mime == NULL) {
2324                                 DBG("Malloc Failed\n");
2325                                 return -1;
2326                         }
2327                         memset(mime, '\0', sizeof(mime_x));
2328                         LISTADD(appsvc->mime, mime);
2329                         ret = __ps_process_mime(reader, mime);
2330                         DBG("mime processing\n");
2331                 } else if (!strcmp(ASCII(node), "subapp")) {
2332                         subapp_x *subapp = malloc(sizeof(subapp_x));
2333                         if (subapp == NULL) {
2334                                 DBG("Malloc Failed\n");
2335                                 return -1;
2336                         }
2337                         memset(subapp, '\0', sizeof(subapp_x));
2338                         LISTADD(appsvc->subapp, subapp);
2339                         ret = __ps_process_subapp(reader, subapp);
2340                         DBG("subapp processing\n");
2341                 } else
2342                         return -1;
2343                 if (ret < 0) {
2344                         DBG("Processing appsvc failed\n");
2345                         return ret;
2346                 }
2347         }
2348         if (appsvc->operation) {
2349                 LISTHEAD(appsvc->operation, tmp1);
2350                 appsvc->operation = tmp1;
2351         }
2352         if (appsvc->uri) {
2353                 LISTHEAD(appsvc->uri, tmp2);
2354                 appsvc->uri = tmp2;
2355         }
2356         if (appsvc->mime) {
2357                 LISTHEAD(appsvc->mime, tmp3);
2358                 appsvc->mime = tmp3;
2359         }
2360         if (appsvc->subapp) {
2361                 LISTHEAD(appsvc->subapp, tmp4);
2362                 appsvc->subapp = tmp4;
2363         }
2364
2365         xmlTextReaderRead(reader);
2366         if (xmlTextReaderValue(reader))
2367                 appsvc->text = ASCII(xmlTextReaderValue(reader));
2368
2369         return ret;
2370 }
2371
2372
2373 static int __ps_process_privileges(xmlTextReaderPtr reader, privileges_x *privileges)
2374 {
2375         const xmlChar *node;
2376         int ret = -1;
2377         int depth = -1;
2378         privilege_x *tmp1 = NULL;
2379
2380         depth = xmlTextReaderDepth(reader);
2381         while ((ret = __next_child_element(reader, depth))) {
2382                 node = xmlTextReaderConstName(reader);
2383                 if (!node) {
2384                         DBG("xmlTextReaderConstName value is NULL\n");
2385                         return -1;
2386                 }
2387
2388                 if (strcmp(ASCII(node), "privilege") == 0) {
2389                         privilege_x *privilege = malloc(sizeof(privilege_x));
2390                         if (privilege == NULL) {
2391                                 DBG("Malloc Failed\n");
2392                                 return -1;
2393                         }
2394                         memset(privilege, '\0', sizeof(privilege_x));
2395                         LISTADD(privileges->privilege, privilege);
2396                         ret = __ps_process_privilege(reader, privilege);
2397                 } else
2398                         return -1;
2399                 if (ret < 0) {
2400                         DBG("Processing privileges failed\n");
2401                         return ret;
2402                 }
2403         }
2404         if (privileges->privilege) {
2405                 LISTHEAD(privileges->privilege, tmp1);
2406                 privileges->privilege = tmp1;
2407         }
2408         return ret;
2409 }
2410
2411 static int __ps_process_launchconditions(xmlTextReaderPtr reader, launchconditions_x *launchconditions)
2412 {
2413         const xmlChar *node;
2414         int ret = -1;
2415         int depth = -1;
2416         condition_x *tmp1 = NULL;
2417
2418         depth = xmlTextReaderDepth(reader);
2419         while ((ret = __next_child_element(reader, depth))) {
2420                 node = xmlTextReaderConstName(reader);
2421                 if (!node) {
2422                         DBG("xmlTextReaderConstName value is NULL\n");
2423                         return -1;
2424                 }
2425
2426                 if (strcmp(ASCII(node), "condition") == 0) {
2427                         condition_x *condition = malloc(sizeof(condition_x));
2428                         if (condition == NULL) {
2429                                 DBG("Malloc Failed\n");
2430                                 return -1;
2431                         }
2432                         memset(condition, '\0', sizeof(condition_x));
2433                         LISTADD(launchconditions->condition, condition);
2434                         ret = __ps_process_condition(reader, condition);
2435                 } else
2436                         return -1;
2437                 if (ret < 0) {
2438                         DBG("Processing launchconditions failed\n");
2439                         return ret;
2440                 }
2441         }
2442         if (launchconditions->condition) {
2443                 LISTHEAD(launchconditions->condition, tmp1);
2444                 launchconditions->condition = tmp1;
2445         }
2446
2447         xmlTextReaderRead(reader);
2448         if (xmlTextReaderValue(reader))
2449                 launchconditions->text = ASCII(xmlTextReaderValue(reader));
2450
2451         return ret;
2452 }
2453
2454 static int __ps_process_datashare(xmlTextReaderPtr reader, datashare_x *datashare)
2455 {
2456         const xmlChar *node;
2457         int ret = -1;
2458         int depth = -1;
2459         define_x *tmp1 = NULL;
2460         request_x *tmp2 = NULL;
2461         depth = xmlTextReaderDepth(reader);
2462         while ((ret = __next_child_element(reader, depth))) {
2463                 node = xmlTextReaderConstName(reader);
2464                 if (!node) {
2465                         DBG("xmlTextReaderConstName value is NULL\n");
2466                         return -1;
2467                 }
2468
2469                 if (!strcmp(ASCII(node), "define")) {
2470                         define_x *define= malloc(sizeof(define_x));
2471                         if (define == NULL) {
2472                                 DBG("Malloc Failed\n");
2473                                 return -1;
2474                         }
2475                         memset(define, '\0', sizeof(define_x));
2476                         LISTADD(datashare->define, define);
2477                         ret = __ps_process_define(reader, define);
2478                 } else if (!strcmp(ASCII(node), "request")) {
2479                         request_x *request= malloc(sizeof(request_x));
2480                         if (request == NULL) {
2481                                 DBG("Malloc Failed\n");
2482                                 return -1;
2483                         }
2484                         memset(request, '\0', sizeof(request_x));
2485                         LISTADD(datashare->request, request);
2486                         ret = __ps_process_request(reader, request);
2487                 } else
2488                         return -1;
2489                 if (ret < 0) {
2490                         DBG("Processing data-share failed\n");
2491                         return ret;
2492                 }
2493         }
2494         if (datashare->define) {
2495                 LISTHEAD(datashare->define, tmp1);
2496                 datashare->define = tmp1;
2497         }
2498         if (datashare->request) {
2499                 LISTHEAD(datashare->request, tmp2);
2500                 datashare->request = tmp2;
2501         }
2502         return ret;
2503 }
2504
2505 static char*
2506 __get_icon_with_path(const char* icon)
2507 {
2508         if (!icon)
2509                 return NULL;
2510
2511         if (index(icon, '/') == NULL) {
2512                 char* theme = NULL;
2513                 char* icon_with_path = NULL;
2514                 int len;
2515
2516                 if (!package)
2517                         return NULL;
2518
2519                 theme = vconf_get_str("db/setting/theme");
2520                 if (!theme) {
2521                         theme = strdup("default");
2522                         if(!theme) {
2523                                 return NULL;
2524                         }
2525                 }
2526
2527                 len = (0x01 << 7) + strlen(icon) + strlen(package) + strlen(theme);
2528                 icon_with_path = malloc(len);
2529                 if(icon_with_path == NULL) {
2530                         DBG("(icon_with_path == NULL) return\n");
2531                         free(theme);
2532                         return NULL;
2533                 }
2534
2535                 memset(icon_with_path, 0, len);
2536
2537                 snprintf(icon_with_path, len, "/opt/share/icons/%s/small/%s", theme, icon);
2538                 do {
2539                         if (access(icon_with_path, R_OK) == 0) break;
2540                         snprintf(icon_with_path, len, "/usr/share/icons/%s/small/%s", theme, icon);
2541                         if (access(icon_with_path, R_OK) == 0) break;
2542                         DBG("cannot find icon %s", icon_with_path);
2543                         snprintf(icon_with_path, len,"/opt/share/icons/default/small/%s", icon);
2544                         if (access(icon_with_path, R_OK) == 0) break;
2545                         snprintf(icon_with_path, len, "/usr/share/icons/default/small/%s", icon);
2546                         if (access(icon_with_path, R_OK) == 0) break;
2547
2548                         /* icon path is going to be moved intto the app directory */
2549                         DBGE("icon file must be moved to %s", icon_with_path);
2550                         snprintf(icon_with_path, len, "/opt/apps/%s/res/icons/%s/small/%s", package, theme, icon);
2551                         if (access(icon_with_path, R_OK) == 0) break;
2552                         snprintf(icon_with_path, len, "/usr/apps/%s/res/icons/%s/small/%s", package, theme, icon);
2553                         if (access(icon_with_path, R_OK) == 0) break;
2554                         DBG("cannot find icon %s", icon_with_path);
2555                         snprintf(icon_with_path, len, "/opt/apps/%s/res/icons/default/small/%s", package, icon);
2556                         if (access(icon_with_path, R_OK) == 0) break;
2557                         snprintf(icon_with_path, len, "/usr/apps/%s/res/icons/default/small/%s", package, icon);
2558                         if (access(icon_with_path, R_OK) == 0) break;
2559                         snprintf(icon_with_path, len, "/usr/ug/res/images/%s/%s", package, icon);
2560                         if (access(icon_with_path, R_OK) == 0) break;
2561                 } while (0);
2562
2563                 free(theme);
2564
2565                 DBG("Icon path : %s ---> %s", icon, icon_with_path);
2566
2567                 return icon_with_path;
2568         } else {
2569                 char* confirmed_icon = NULL;
2570
2571                 confirmed_icon = strdup(icon);
2572                 if (!confirmed_icon)
2573                         return NULL;
2574                 return confirmed_icon;
2575         }
2576 }
2577
2578 static void __ps_process_tag(manifest_x * mfx, char *const tagv[])
2579 {
2580         int i = 0;
2581         char delims[] = "=";
2582         char *ret_result = NULL;
2583         char *tag = NULL;
2584
2585         if (tagv == NULL)
2586                 return;
2587
2588         for (tag = strdup(tagv[0]); tag != NULL; ) {
2589                 ret_result = strtok(tag, delims);
2590
2591                 /*check tag :  preload */
2592                 if (strcmp(ret_result, "preload") == 0) {
2593                         ret_result = strtok(NULL, delims);
2594                         if (strcmp(ret_result, "true") == 0) {
2595                                 free((void *)mfx->preload);
2596                                 mfx->preload = strdup("true");
2597                         } else if (strcmp(ret_result, "false") == 0) {
2598                                 free((void *)mfx->preload);
2599                                 mfx->preload = strdup("false");
2600                         }
2601                 /*check tag :  removable*/
2602                 } else if (strcmp(ret_result, "removable") == 0) {
2603                         ret_result = strtok(NULL, delims);
2604                         if (strcmp(ret_result, "true") == 0){
2605                                 free((void *)mfx->removable);
2606                                 mfx->removable = strdup("true");
2607                         } else if (strcmp(ret_result, "false") == 0) {
2608                                 free((void *)mfx->removable);
2609                                 mfx->removable = strdup("false");
2610                         }
2611                 /*check tag :  not matched*/
2612                 } else
2613                         DBG("tag process [%s]is not defined\n", ret_result);
2614
2615                 free(tag);
2616
2617                 /*check next value*/
2618                 if (tagv[++i] != NULL)
2619                         tag = strdup(tagv[i]);
2620                 else {
2621                         DBG("tag process success...\n");
2622                         return;
2623                 }
2624         }
2625 }
2626
2627 static int __ps_process_icon(xmlTextReaderPtr reader, icon_x *icon)
2628 {
2629         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2630                 icon->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2631         if (xmlTextReaderConstXmlLang(reader)) {
2632                 icon->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2633                 if (icon->lang == NULL)
2634                         icon->lang = strdup(DEFAULT_LOCALE);
2635         } else {
2636                 icon->lang = strdup(DEFAULT_LOCALE);
2637         }
2638         if (xmlTextReaderGetAttribute(reader, XMLCHAR("section")))
2639                 icon->section = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("section")));
2640         if (xmlTextReaderGetAttribute(reader, XMLCHAR("size")))
2641                 icon->size = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("size")));
2642         if (xmlTextReaderGetAttribute(reader, XMLCHAR("resolution")))
2643                 icon->resolution = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("resolution")));
2644         xmlTextReaderRead(reader);
2645         if (xmlTextReaderValue(reader)) {
2646                 const char *text  = ASCII(xmlTextReaderValue(reader));
2647                 if(text) {
2648                         icon->text = (const char *)__get_icon_with_path(text);
2649                         free((void *)text);
2650                 }
2651         }
2652
2653         return 0;
2654 }
2655
2656 static int __ps_process_image(xmlTextReaderPtr reader, image_x *image)
2657 {
2658         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2659                 image->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2660         if (xmlTextReaderConstXmlLang(reader)) {
2661                 image->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2662                 if (image->lang == NULL)
2663                         image->lang = strdup(DEFAULT_LOCALE);
2664         } else {
2665                 image->lang = strdup(DEFAULT_LOCALE);
2666         }
2667         if (xmlTextReaderGetAttribute(reader, XMLCHAR("section")))
2668                 image->section = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("section")));
2669         xmlTextReaderRead(reader);
2670         if (xmlTextReaderValue(reader))
2671                 image->text = ASCII(xmlTextReaderValue(reader));
2672
2673         return 0;
2674 }
2675
2676 static int __ps_process_label(xmlTextReaderPtr reader, label_x *label)
2677 {
2678         if (xmlTextReaderGetAttribute(reader, XMLCHAR("name")))
2679                 label->name = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("name")));
2680         if (xmlTextReaderConstXmlLang(reader)) {
2681                 label->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2682                 if (label->lang == NULL)
2683                         label->lang = strdup(DEFAULT_LOCALE);
2684         } else {
2685                 label->lang = strdup(DEFAULT_LOCALE);
2686         }
2687         xmlTextReaderRead(reader);
2688         if (xmlTextReaderValue(reader))
2689                 label->text = ASCII(xmlTextReaderValue(reader));
2690
2691 /*      DBG("lable name %s\n", label->name);
2692         DBG("lable lang %s\n", label->lang);
2693         DBG("lable text %s\n", label->text);
2694 */
2695         return 0;
2696
2697 }
2698
2699 static int __ps_process_author(xmlTextReaderPtr reader, author_x *author)
2700 {
2701         if (xmlTextReaderGetAttribute(reader, XMLCHAR("email")))
2702                 author->email = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("email")));
2703         if (xmlTextReaderGetAttribute(reader, XMLCHAR("href")))
2704                 author->href = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("href")));
2705         if (xmlTextReaderConstXmlLang(reader)) {
2706                 author->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2707                 if (author->lang == NULL)
2708                         author->lang = strdup(DEFAULT_LOCALE);
2709         } else {
2710                 author->lang = strdup(DEFAULT_LOCALE);
2711         }
2712         xmlTextReaderRead(reader);
2713         if (xmlTextReaderValue(reader))
2714                 author->text = ASCII(xmlTextReaderValue(reader));
2715         return 0;
2716 }
2717
2718 static int __ps_process_description(xmlTextReaderPtr reader, description_x *description)
2719 {
2720         if (xmlTextReaderConstXmlLang(reader)) {
2721                 description->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2722                 if (description->lang == NULL)
2723                         description->lang = strdup(DEFAULT_LOCALE);
2724         } else {
2725                 description->lang = strdup(DEFAULT_LOCALE);
2726         }
2727         xmlTextReaderRead(reader);
2728         if (xmlTextReaderValue(reader))
2729                 description->text = ASCII(xmlTextReaderValue(reader));
2730         return 0;
2731 }
2732
2733 static int __ps_process_license(xmlTextReaderPtr reader, license_x *license)
2734 {
2735         if (xmlTextReaderConstXmlLang(reader)) {
2736                 license->lang = strdup(ASCII(xmlTextReaderConstXmlLang(reader)));
2737                 if (license->lang == NULL)
2738                         license->lang = strdup(DEFAULT_LOCALE);
2739         } else {
2740                 license->lang = strdup(DEFAULT_LOCALE);
2741         }
2742         xmlTextReaderRead(reader);
2743         if (xmlTextReaderValue(reader))
2744                 license->text = ASCII(xmlTextReaderValue(reader));
2745         return 0;
2746 }
2747
2748 static int __ps_process_capability(xmlTextReaderPtr reader, capability_x *capability)
2749 {
2750         const xmlChar *node;
2751         int ret = -1;
2752         int depth = -1;
2753         resolution_x *tmp1 = NULL;
2754
2755         if (xmlTextReaderGetAttribute(reader, XMLCHAR("operation-id")))
2756                 capability->operationid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("operation-id")));
2757
2758         depth = xmlTextReaderDepth(reader);
2759         while ((ret = __next_child_element(reader, depth))) {
2760                 node = xmlTextReaderConstName(reader);
2761                 if (!node) {
2762                         DBG("xmlTextReaderConstName value is NULL\n");
2763                         return -1;
2764                 }
2765
2766                 if (!strcmp(ASCII(node), "resolution")) {
2767                         resolution_x *resolution = malloc(sizeof(resolution_x));
2768                         if (resolution == NULL) {
2769                                 DBG("Malloc Failed\n");
2770                                 return -1;
2771                         }
2772                         memset(resolution, '\0', sizeof(resolution_x));
2773                         LISTADD(capability->resolution, resolution);
2774                         ret = __ps_process_resolution(reader, resolution);
2775                 } else
2776                         return -1;
2777                 if (ret < 0) {
2778                         DBG("Processing capability failed\n");
2779                         return ret;
2780                 }
2781         }
2782
2783         if (capability->resolution) {
2784                 LISTHEAD(capability->resolution, tmp1);
2785                 capability->resolution = tmp1;
2786         }
2787
2788         return ret;
2789 }
2790
2791 static int __ps_process_datacontrol(xmlTextReaderPtr reader, datacontrol_x *datacontrol)
2792 {
2793         const xmlChar *node;
2794         int ret = -1;
2795         int depth = -1;
2796         capability_x *tmp1 = NULL;
2797
2798         if (xmlTextReaderGetAttribute(reader, XMLCHAR("provider-id")))
2799                 datacontrol->providerid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("provider-id")));
2800
2801         depth = xmlTextReaderDepth(reader);
2802         while ((ret = __next_child_element(reader, depth))) {
2803                 node = xmlTextReaderConstName(reader);
2804                 if (!node) {
2805                         DBG("xmlTextReaderConstName value is NULL\n");
2806                         return -1;
2807                 }
2808
2809                 if (!strcmp(ASCII(node), "capability")) {
2810                         capability_x *capability = malloc(sizeof(capability_x));
2811                         if (capability == NULL) {
2812                                 DBG("Malloc Failed\n");
2813                                 return -1;
2814                         }
2815                         memset(capability, '\0', sizeof(capability_x));
2816                         LISTADD(datacontrol->capability, capability);
2817                         ret = __ps_process_capability(reader, capability);
2818                 } else
2819                         return -1;
2820                 if (ret < 0) {
2821                         DBG("Processing datacontrol failed\n");
2822                         return ret;
2823                 }
2824         }
2825
2826         if (datacontrol->capability) {
2827                 LISTHEAD(datacontrol->capability, tmp1);
2828                 datacontrol->capability = tmp1;
2829         }
2830
2831         return ret;
2832 }
2833
2834 static int __ps_process_uiapplication(xmlTextReaderPtr reader, uiapplication_x *uiapplication)
2835 {
2836         const xmlChar *node;
2837         int ret = -1;
2838         int depth = -1;
2839         char *newappid = NULL;
2840         label_x *tmp1 = NULL;
2841         icon_x *tmp2 = NULL;
2842         appsvc_x *tmp3 = NULL;
2843         appcontrol_x *tmp4 = NULL;
2844         launchconditions_x *tmp5 = NULL;
2845         notification_x *tmp6 = NULL;
2846         datashare_x *tmp7 = NULL;
2847         category_x *tmp8 = NULL;
2848         metadata_x *tmp9 = NULL;
2849         image_x *tmp10 = NULL;
2850         permission_x *tmp11 = NULL;
2851
2852         if (xmlTextReaderGetAttribute(reader, XMLCHAR("appid"))) {
2853                 uiapplication->appid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("appid")));
2854                 if (uiapplication->appid == NULL) {
2855                         DBG("appid cant be NULL\n");
2856                         return -1;
2857                 }
2858         } else {
2859                 DBG("appid is mandatory\n");
2860                 return -1;
2861         }
2862         /*check appid*/
2863         ret = __validate_appid(package, uiapplication->appid, &newappid);
2864         if (ret == -1) {
2865                 DBG("appid is not proper\n");
2866                 return -1;
2867         } else {
2868                 if (newappid) {
2869                         if (uiapplication->appid)
2870                                 free((void *)uiapplication->appid);
2871                         uiapplication->appid = newappid;
2872                 }
2873                 uiapplication->package= strdup(package);
2874         }
2875         if (xmlTextReaderGetAttribute(reader, XMLCHAR("exec")))
2876                 uiapplication->exec = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("exec")));
2877         if (xmlTextReaderGetAttribute(reader, XMLCHAR("nodisplay"))) {
2878                 uiapplication->nodisplay = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("nodisplay")));
2879                 if (uiapplication->nodisplay == NULL)
2880                         uiapplication->nodisplay = strdup("false");
2881         } else {
2882                 uiapplication->nodisplay = strdup("false");
2883         }
2884         if (xmlTextReaderGetAttribute(reader, XMLCHAR("multiple"))) {
2885                 uiapplication->multiple = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("multiple")));
2886                 if (uiapplication->multiple == NULL)
2887                         uiapplication->multiple = strdup("false");
2888         } else {
2889                 uiapplication->multiple = strdup("false");
2890         }
2891         if (xmlTextReaderGetAttribute(reader, XMLCHAR("type")))
2892                 uiapplication->type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("type")));
2893         if (xmlTextReaderGetAttribute(reader, XMLCHAR("categories")))
2894                 uiapplication->categories = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("categories")));
2895         if (xmlTextReaderGetAttribute(reader, XMLCHAR("extraid")))
2896                 uiapplication->extraid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("extraid")));
2897         if (xmlTextReaderGetAttribute(reader, XMLCHAR("taskmanage"))) {
2898                 uiapplication->taskmanage = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("taskmanage")));
2899                 if (uiapplication->taskmanage == NULL)
2900                         uiapplication->taskmanage = strdup("true");
2901         } else {
2902                 uiapplication->taskmanage = strdup("true");
2903         }
2904         if (xmlTextReaderGetAttribute(reader, XMLCHAR("enabled"))) {
2905                 uiapplication->enabled = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("enabled")));
2906                 if (uiapplication->enabled == NULL)
2907                         uiapplication->enabled = strdup("true");
2908         } else {
2909                 uiapplication->enabled = strdup("true");
2910         }
2911         if (xmlTextReaderGetAttribute(reader, XMLCHAR("hw-acceleration"))) {
2912                 uiapplication->hwacceleration = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("hw-acceleration")));
2913                 if (uiapplication->hwacceleration == NULL)
2914                         uiapplication->hwacceleration = strdup("use-system-setting");
2915         } else {
2916                 uiapplication->hwacceleration = strdup("use-system-setting");
2917         }
2918         if (xmlTextReaderGetAttribute(reader, XMLCHAR("recentimage")))
2919                 uiapplication->recentimage = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("recentimage")));
2920         if (xmlTextReaderGetAttribute(reader, XMLCHAR("mainapp"))) {
2921                 uiapplication->mainapp = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("mainapp")));
2922                 if (uiapplication->mainapp == NULL)
2923                         uiapplication->mainapp = strdup("false");
2924         } else {
2925                 uiapplication->mainapp = strdup("false");
2926         }
2927         if (xmlTextReaderGetAttribute(reader, XMLCHAR("launchcondition"))) {
2928                 uiapplication->launchcondition = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("launchcondition")));
2929                 if (uiapplication->launchcondition == NULL)
2930                         uiapplication->launchcondition = strdup("false");
2931         } else {
2932                 uiapplication->launchcondition = strdup("false");
2933         }
2934
2935         if (xmlTextReaderGetAttribute(reader, XMLCHAR("indicatordisplay"))) {
2936                 uiapplication->indicatordisplay = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("indicatordisplay")));
2937                 if (uiapplication->indicatordisplay == NULL)
2938                         uiapplication->indicatordisplay = strdup("true");
2939         } else {
2940                 uiapplication->indicatordisplay = strdup("true");
2941         }
2942         if (xmlTextReaderGetAttribute(reader, XMLCHAR("portrait-effectimage")))
2943                 uiapplication->portraitimg = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("portrait-effectimage")));
2944         else
2945                 uiapplication->portraitimg = NULL;
2946         if (xmlTextReaderGetAttribute(reader, XMLCHAR("landscape-effectimage")))
2947                 uiapplication->landscapeimg = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("landscape-effectimage")));
2948         else
2949                 uiapplication->landscapeimg = NULL;
2950         if (xmlTextReaderGetAttribute(reader, XMLCHAR("guestmode-visibility"))) {
2951                 uiapplication->guestmode_visibility = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("guestmode-visibility")));
2952                 if (uiapplication->guestmode_visibility == NULL)
2953                         uiapplication->guestmode_visibility = strdup("true");
2954         } else {
2955                 uiapplication->guestmode_visibility = strdup("true");
2956         }
2957         if (xmlTextReaderGetAttribute(reader, XMLCHAR("permission-type"))) {
2958                 uiapplication->permission_type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("permission-type")));
2959                 if (uiapplication->permission_type == NULL)
2960                         uiapplication->permission_type = strdup("normal");
2961         } else {
2962                 uiapplication->permission_type = strdup("normal");
2963         }
2964         if (xmlTextReaderGetAttribute(reader, XMLCHAR("component-type"))) {
2965                 uiapplication->component_type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("component-type")));
2966                 if (uiapplication->component_type == NULL)
2967                         uiapplication->component_type = strdup("uiapp");
2968         } else {
2969                 uiapplication->component_type = strdup("uiapp");
2970         }
2971         if (xmlTextReaderGetAttribute(reader, XMLCHAR("submode"))) {
2972                 uiapplication->submode = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("submode")));
2973                 if (uiapplication->submode == NULL)
2974                         uiapplication->submode = strdup("false");
2975         } else {
2976                 uiapplication->submode = strdup("false");
2977         }
2978         if (xmlTextReaderGetAttribute(reader, XMLCHAR("submode-mainid")))
2979                 uiapplication->submode_mainid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("submode-mainid")));
2980
2981         depth = xmlTextReaderDepth(reader);
2982         while ((ret = __next_child_element(reader, depth))) {
2983                 node = xmlTextReaderConstName(reader);
2984                 if (!node) {
2985                         DBG("xmlTextReaderConstName value is NULL\n");
2986                         return -1;
2987                 }
2988                 if (!strcmp(ASCII(node), "label")) {
2989                         label_x *label = malloc(sizeof(label_x));
2990                         if (label == NULL) {
2991                                 DBG("Malloc Failed\n");
2992                                 return -1;
2993                         }
2994                         memset(label, '\0', sizeof(label_x));
2995                         LISTADD(uiapplication->label, label);
2996                         ret = __ps_process_label(reader, label);
2997                 } else if (!strcmp(ASCII(node), "icon")) {
2998                         icon_x *icon = malloc(sizeof(icon_x));
2999                         if (icon == NULL) {
3000                                 DBG("Malloc Failed\n");
3001                                 return -1;
3002                         }
3003                         memset(icon, '\0', sizeof(icon_x));
3004                         LISTADD(uiapplication->icon, icon);
3005                         ret = __ps_process_icon(reader, icon);
3006                 } else if (!strcmp(ASCII(node), "image")) {
3007                         image_x *image = malloc(sizeof(image_x));
3008                         if (image == NULL) {
3009                                 DBG("Malloc Failed\n");
3010                                 return -1;
3011                         }
3012                         memset(image, '\0', sizeof(image_x));
3013                         LISTADD(uiapplication->image, image);
3014                         ret = __ps_process_image(reader, image);
3015                 } else if (!strcmp(ASCII(node), "category")) {
3016                         category_x *category = malloc(sizeof(category_x));
3017                         if (category == NULL) {
3018                                 DBG("Malloc Failed\n");
3019                                 return -1;
3020                         }
3021                         memset(category, '\0', sizeof(category_x));
3022                         LISTADD(uiapplication->category, category);
3023                         ret = __ps_process_category(reader, category);
3024                 } else if (!strcmp(ASCII(node), "metadata")) {
3025                         metadata_x *metadata = malloc(sizeof(metadata_x));
3026                         if (metadata == NULL) {
3027                                 DBG("Malloc Failed\n");
3028                                 return -1;
3029                         }
3030                         memset(metadata, '\0', sizeof(metadata_x));
3031                         LISTADD(uiapplication->metadata, metadata);
3032                         ret = __ps_process_metadata(reader, metadata);
3033                 } else if (!strcmp(ASCII(node), "permission")) {
3034                         permission_x *permission = malloc(sizeof(permission_x));
3035                         if (permission == NULL) {
3036                                 DBG("Malloc Failed\n");
3037                                 return -1;
3038                         }
3039                         memset(permission, '\0', sizeof(permission_x));
3040                         LISTADD(uiapplication->permission, permission);
3041                         ret = __ps_process_permission(reader, permission);
3042                 } else if (!strcmp(ASCII(node), "app-control")) {
3043                         appcontrol_x *appcontrol = malloc(sizeof(appcontrol_x));
3044                         if (appcontrol == NULL) {
3045                                 DBG("Malloc Failed\n");
3046                                 return -1;
3047                         }
3048                         memset(appcontrol, '\0', sizeof(appcontrol_x));
3049                         LISTADD(uiapplication->appcontrol, appcontrol);
3050                         ret = __ps_process_appcontrol(reader, appcontrol);
3051                 } else if (!strcmp(ASCII(node), "application-service")) {
3052                         appsvc_x *appsvc = malloc(sizeof(appsvc_x));
3053                         if (appsvc == NULL) {
3054                                 DBG("Malloc Failed\n");
3055                                 return -1;
3056                         }
3057                         memset(appsvc, '\0', sizeof(appsvc_x));
3058                         LISTADD(uiapplication->appsvc, appsvc);
3059                         ret = __ps_process_appsvc(reader, appsvc);
3060                 } else if (!strcmp(ASCII(node), "data-share")) {
3061                         datashare_x *datashare = malloc(sizeof(datashare_x));
3062                         if (datashare == NULL) {
3063                                 DBG("Malloc Failed\n");
3064                                 return -1;
3065                         }
3066                         memset(datashare, '\0', sizeof(datashare_x));
3067                         LISTADD(uiapplication->datashare, datashare);
3068                         ret = __ps_process_datashare(reader, datashare);
3069                 } else if (!strcmp(ASCII(node), "launch-conditions")) {
3070                         launchconditions_x *launchconditions = malloc(sizeof(launchconditions_x));
3071                         if (launchconditions == NULL) {
3072                                 DBG("Malloc Failed\n");
3073                                 return -1;
3074                         }
3075                         memset(launchconditions, '\0', sizeof(launchconditions_x));
3076                         LISTADD(uiapplication->launchconditions, launchconditions);
3077                         ret = __ps_process_launchconditions(reader, launchconditions);
3078                 } else if (!strcmp(ASCII(node), "notification")) {
3079                         notification_x *notification = malloc(sizeof(notification_x));
3080                         if (notification == NULL) {
3081                                 DBG("Malloc Failed\n");
3082                                 return -1;
3083                         }
3084                         memset(notification, '\0', sizeof(notification_x));
3085                         LISTADD(uiapplication->notification, notification);
3086                         ret = __ps_process_notification(reader, notification);
3087                 } else
3088                         return -1;
3089                 if (ret < 0) {
3090                         DBG("Processing uiapplication failed\n");
3091                         return ret;
3092                 }
3093         }
3094
3095         if (uiapplication->label) {
3096                 LISTHEAD(uiapplication->label, tmp1);
3097                 uiapplication->label = tmp1;
3098         }
3099         if (uiapplication->icon) {
3100                 LISTHEAD(uiapplication->icon, tmp2);
3101                 uiapplication->icon = tmp2;
3102         }
3103         if (uiapplication->appsvc) {
3104                 LISTHEAD(uiapplication->appsvc, tmp3);
3105                 uiapplication->appsvc = tmp3;
3106         }
3107         if (uiapplication->appcontrol) {
3108                 LISTHEAD(uiapplication->appcontrol, tmp4);
3109                 uiapplication->appcontrol = tmp4;
3110         }
3111         if (uiapplication->launchconditions) {
3112                 LISTHEAD(uiapplication->launchconditions, tmp5);
3113                 uiapplication->launchconditions = tmp5;
3114         }
3115         if (uiapplication->notification) {
3116                 LISTHEAD(uiapplication->notification, tmp6);
3117                 uiapplication->notification = tmp6;
3118         }
3119         if (uiapplication->datashare) {
3120                 LISTHEAD(uiapplication->datashare, tmp7);
3121                 uiapplication->datashare = tmp7;
3122         }
3123         if (uiapplication->category) {
3124                 LISTHEAD(uiapplication->category, tmp8);
3125                 uiapplication->category = tmp8;
3126         }
3127         if (uiapplication->metadata) {
3128                 LISTHEAD(uiapplication->metadata, tmp9);
3129                 uiapplication->metadata = tmp9;
3130         }
3131         if (uiapplication->image) {
3132                 LISTHEAD(uiapplication->image, tmp10);
3133                 uiapplication->image = tmp10;
3134         }
3135         if (uiapplication->permission) {
3136                 LISTHEAD(uiapplication->permission, tmp11);
3137                 uiapplication->permission = tmp11;
3138         }
3139
3140         return ret;
3141 }
3142
3143 static int __ps_process_serviceapplication(xmlTextReaderPtr reader, serviceapplication_x *serviceapplication)
3144 {
3145         const xmlChar *node;
3146         int ret = -1;
3147         int depth = -1;
3148         char *newappid = NULL;
3149         label_x *tmp1 = NULL;
3150         icon_x *tmp2 = NULL;
3151         appsvc_x *tmp3 = NULL;
3152         appcontrol_x *tmp4 = NULL;
3153         datacontrol_x *tmp5 = NULL;
3154         launchconditions_x *tmp6 = NULL;
3155         notification_x *tmp7 = NULL;
3156         datashare_x *tmp8 = NULL;
3157         category_x *tmp9 = NULL;
3158         metadata_x *tmp10 = NULL;
3159         permission_x *tmp11 = NULL;
3160
3161         if (xmlTextReaderGetAttribute(reader, XMLCHAR("appid"))) {
3162                 serviceapplication->appid = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("appid")));
3163                 if (serviceapplication->appid == NULL) {
3164                         DBG("appid cant be NULL\n");
3165                         return -1;
3166                 }
3167         } else {
3168                 DBG("appid is mandatory\n");
3169                 return -1;
3170         }
3171         /*check appid*/
3172         ret = __validate_appid(package, serviceapplication->appid, &newappid);
3173         if (ret == -1) {
3174                 DBG("appid is not proper\n");
3175                 return -1;
3176         } else {
3177                 if (newappid) {
3178                         if (serviceapplication->appid)
3179                                 free((void *)serviceapplication->appid);
3180                         serviceapplication->appid = newappid;
3181                 }
3182         }
3183         if (xmlTextReaderGetAttribute(reader, XMLCHAR("exec")))
3184                 serviceapplication->exec = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("exec")));
3185         if (xmlTextReaderGetAttribute(reader, XMLCHAR("type")))
3186                 serviceapplication->type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("type")));
3187         if (xmlTextReaderGetAttribute(reader, XMLCHAR("on-boot"))) {
3188                 serviceapplication->onboot = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("on-boot")));
3189                 if (serviceapplication->onboot == NULL)
3190                         serviceapplication->onboot = strdup("false");
3191         } else {
3192                 serviceapplication->onboot = strdup("false");
3193         }
3194         if (xmlTextReaderGetAttribute(reader, XMLCHAR("auto-restart"))) {
3195                 serviceapplication->autorestart = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("auto-restart")));
3196                 if (serviceapplication->autorestart == NULL)
3197                         serviceapplication->autorestart = strdup("false");
3198         } else {
3199                 serviceapplication->autorestart = strdup("false");
3200         }
3201         if (xmlTextReaderGetAttribute(reader, XMLCHAR("permission-type"))) {
3202                 serviceapplication->permission_type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("permission-type")));
3203                 if (serviceapplication->permission_type == NULL)
3204                         serviceapplication->permission_type = strdup("normal");
3205         } else {
3206                 serviceapplication->permission_type = strdup("normal");
3207         }
3208
3209         depth = xmlTextReaderDepth(reader);
3210         while ((ret = __next_child_element(reader, depth))) {
3211                 node = xmlTextReaderConstName(reader);
3212                 if (!node) {
3213                         DBG("xmlTextReaderConstName value is NULL\n");
3214                         return -1;
3215                 }
3216
3217                 if (!strcmp(ASCII(node), "label")) {
3218                         label_x *label = malloc(sizeof(label_x));
3219                         if (label == NULL) {
3220                                 DBG("Malloc Failed\n");
3221                                 return -1;
3222                         }
3223                         memset(label, '\0', sizeof(label_x));
3224                         LISTADD(serviceapplication->label, label);
3225                         ret = __ps_process_label(reader, label);
3226                 } else if (!strcmp(ASCII(node), "icon")) {
3227                         icon_x *icon = malloc(sizeof(icon_x));
3228                         if (icon == NULL) {
3229                                 DBG("Malloc Failed\n");
3230                                 return -1;
3231                         }
3232                         memset(icon, '\0', sizeof(icon_x));
3233                         LISTADD(serviceapplication->icon, icon);
3234                         ret = __ps_process_icon(reader, icon);
3235                 } else if (!strcmp(ASCII(node), "category")) {
3236                         category_x *category = malloc(sizeof(category_x));
3237                         if (category == NULL) {
3238                                 DBG("Malloc Failed\n");
3239                                 return -1;
3240                         }
3241                         memset(category, '\0', sizeof(category_x));
3242                         LISTADD(serviceapplication->category, category);
3243                         ret = __ps_process_category(reader, category);
3244                 } else if (!strcmp(ASCII(node), "metadata")) {
3245                         metadata_x *metadata = malloc(sizeof(metadata_x));
3246                         if (metadata == NULL) {
3247                                 DBG("Malloc Failed\n");
3248                                 return -1;
3249                         }
3250                         memset(metadata, '\0', sizeof(metadata_x));
3251                         LISTADD(serviceapplication->metadata, metadata);
3252                         ret = __ps_process_metadata(reader, metadata);
3253                 } else if (!strcmp(ASCII(node), "permission")) {
3254                         permission_x *permission = malloc(sizeof(permission_x));
3255                         if (permission == NULL) {
3256                                 DBG("Malloc Failed\n");
3257                                 return -1;
3258                         }
3259                         memset(permission, '\0', sizeof(permission_x));
3260                         LISTADD(serviceapplication->permission, permission);
3261                         ret = __ps_process_permission(reader, permission);
3262                 } else if (!strcmp(ASCII(node), "app-control")) {
3263                         appcontrol_x *appcontrol = malloc(sizeof(appcontrol_x));
3264                         if (appcontrol == NULL) {
3265                                 DBG("Malloc Failed\n");
3266                                 return -1;
3267                         }
3268                         memset(appcontrol, '\0', sizeof(appcontrol_x));
3269                         LISTADD(serviceapplication->appcontrol, appcontrol);
3270                         ret = __ps_process_appcontrol(reader, appcontrol);
3271                 } else if (!strcmp(ASCII(node), "application-service")) {
3272                         appsvc_x *appsvc = malloc(sizeof(appsvc_x));
3273                         if (appsvc == NULL) {
3274                                 DBG("Malloc Failed\n");
3275                                 return -1;
3276                         }
3277                         memset(appsvc, '\0', sizeof(appsvc_x));
3278                         LISTADD(serviceapplication->appsvc, appsvc);
3279                         ret = __ps_process_appsvc(reader, appsvc);
3280                 } else if (!strcmp(ASCII(node), "data-share")) {
3281                         datashare_x *datashare = malloc(sizeof(datashare_x));
3282                         if (datashare == NULL) {
3283                                 DBG("Malloc Failed\n");
3284                                 return -1;
3285                         }
3286                         memset(datashare, '\0', sizeof(datashare_x));
3287                         LISTADD(serviceapplication->datashare, datashare);
3288                         ret = __ps_process_datashare(reader, datashare);
3289                 } else if (!strcmp(ASCII(node), "launch-conditions")) {
3290                         launchconditions_x *launchconditions = malloc(sizeof(launchconditions_x));
3291                         if (launchconditions == NULL) {
3292                                 DBG("Malloc Failed\n");
3293                                 return -1;
3294                         }
3295                         memset(launchconditions, '\0', sizeof(launchconditions_x));
3296                         LISTADD(serviceapplication->launchconditions, launchconditions);
3297                         ret = __ps_process_launchconditions(reader, launchconditions);
3298                 } else if (!strcmp(ASCII(node), "notification")) {
3299                         notification_x *notification = malloc(sizeof(notification_x));
3300                         if (notification == NULL) {
3301                                 DBG("Malloc Failed\n");
3302                                 return -1;
3303                         }
3304                         memset(notification, '\0', sizeof(notification_x));
3305                         LISTADD(serviceapplication->notification, notification);
3306                         ret = __ps_process_notification(reader, notification);
3307                 } else if (!strcmp(ASCII(node), "data-control")) {
3308                         datacontrol_x *datacontrol = malloc(sizeof(datacontrol_x));
3309                         if (datacontrol == NULL) {
3310                                 DBG("Malloc Failed\n");
3311                                 return -1;
3312                         }
3313                         memset(datacontrol, '\0', sizeof(datacontrol_x));
3314                         LISTADD(serviceapplication->datacontrol, datacontrol);
3315                         ret = __ps_process_datacontrol(reader, datacontrol);
3316                 } else
3317                         return -1;
3318                 if (ret < 0) {
3319                         DBG("Processing serviceapplication failed\n");
3320                         return ret;
3321                 }
3322         }
3323
3324         if (serviceapplication->label) {
3325                 LISTHEAD(serviceapplication->label, tmp1);
3326                 serviceapplication->label = tmp1;
3327         }
3328         if (serviceapplication->icon) {
3329                 LISTHEAD(serviceapplication->icon, tmp2);
3330                 serviceapplication->icon = tmp2;
3331         }
3332         if (serviceapplication->appsvc) {
3333                 LISTHEAD(serviceapplication->appsvc, tmp3);
3334                 serviceapplication->appsvc = tmp3;
3335         }
3336         if (serviceapplication->appcontrol) {
3337                 LISTHEAD(serviceapplication->appcontrol, tmp4);
3338                 serviceapplication->appcontrol = tmp4;
3339         }
3340         if (serviceapplication->datacontrol) {
3341                 LISTHEAD(serviceapplication->datacontrol, tmp5);
3342                 serviceapplication->datacontrol = tmp5;
3343         }
3344         if (serviceapplication->launchconditions) {
3345                 LISTHEAD(serviceapplication->launchconditions, tmp6);
3346                 serviceapplication->launchconditions = tmp6;
3347         }
3348         if (serviceapplication->notification) {
3349                 LISTHEAD(serviceapplication->notification, tmp7);
3350                 serviceapplication->notification = tmp7;
3351         }
3352         if (serviceapplication->datashare) {
3353                 LISTHEAD(serviceapplication->datashare, tmp8);
3354                 serviceapplication->datashare = tmp8;
3355         }
3356         if (serviceapplication->category) {
3357                 LISTHEAD(serviceapplication->category, tmp9);
3358                 serviceapplication->category = tmp9;
3359         }
3360         if (serviceapplication->metadata) {
3361                 LISTHEAD(serviceapplication->metadata, tmp10);
3362                 serviceapplication->metadata = tmp10;
3363         }
3364         if (serviceapplication->permission) {
3365                 LISTHEAD(serviceapplication->permission, tmp11);
3366                 serviceapplication->permission = tmp11;
3367         }
3368
3369         return ret;
3370 }
3371
3372 static int __ps_process_deviceprofile(xmlTextReaderPtr reader, deviceprofile_x *deviceprofile)
3373 {
3374         /*TODO: once policy is set*/
3375         return 0;
3376 }
3377
3378 static int __ps_process_font(xmlTextReaderPtr reader, font_x *font)
3379 {
3380         /*TODO: once policy is set*/
3381         return 0;
3382 }
3383
3384 static int __ps_process_theme(xmlTextReaderPtr reader, theme_x *theme)
3385 {
3386         /*TODO: once policy is set*/
3387         return 0;
3388 }
3389
3390 static int __ps_process_daemon(xmlTextReaderPtr reader, daemon_x *daemon)
3391 {
3392         /*TODO: once policy is set*/
3393         return 0;
3394 }
3395
3396 static int __ps_process_ime(xmlTextReaderPtr reader, ime_x *ime)
3397 {
3398         /*TODO: once policy is set*/
3399         return 0;
3400 }
3401
3402 static int __start_process(xmlTextReaderPtr reader, manifest_x * mfx)
3403 {
3404         DBG("__start_process\n");
3405         const xmlChar *node;
3406         int ret = -1;
3407         int depth = -1;
3408         label_x *tmp1 = NULL;
3409         author_x *tmp2 = NULL;
3410         description_x *tmp3 = NULL;
3411         license_x *tmp4 = NULL;
3412         uiapplication_x *tmp5 = NULL;
3413         serviceapplication_x *tmp6 = NULL;
3414         daemon_x *tmp7 = NULL;
3415         theme_x *tmp8 = NULL;
3416         font_x *tmp9 = NULL;
3417         ime_x *tmp10 = NULL;
3418         icon_x *tmp11 = NULL;
3419         compatibility_x *tmp12 = NULL;
3420         deviceprofile_x *tmp13 = NULL;
3421         privileges_x *tmp14 = NULL;
3422
3423         depth = xmlTextReaderDepth(reader);
3424         while ((ret = __next_child_element(reader, depth))) {
3425                 node = xmlTextReaderConstName(reader);
3426                 if (!node) {
3427                         DBG("xmlTextReaderConstName value is NULL\n");
3428                         return -1;
3429                 }
3430
3431                 if (!strcmp(ASCII(node), "label")) {
3432                         label_x *label = malloc(sizeof(label_x));
3433                         if (label == NULL) {
3434                                 DBG("Malloc Failed\n");
3435                                 return -1;
3436                         }
3437                         memset(label, '\0', sizeof(label_x));
3438                         LISTADD(mfx->label, label);
3439                         ret = __ps_process_label(reader, label);
3440                 } else if (!strcmp(ASCII(node), "author")) {
3441                         author_x *author = malloc(sizeof(author_x));
3442                         if (author == NULL) {
3443                                 DBG("Malloc Failed\n");
3444                                 return -1;
3445                         }
3446                         memset(author, '\0', sizeof(author_x));
3447                         LISTADD(mfx->author, author);
3448                         ret = __ps_process_author(reader, author);
3449                 } else if (!strcmp(ASCII(node), "description")) {
3450                         description_x *description = malloc(sizeof(description_x));
3451                         if (description == NULL) {
3452                                 DBG("Malloc Failed\n");
3453                                 return -1;
3454                         }
3455                         memset(description, '\0', sizeof(description_x));
3456                         LISTADD(mfx->description, description);
3457                         ret = __ps_process_description(reader, description);
3458                 } else if (!strcmp(ASCII(node), "license")) {
3459                         license_x *license = malloc(sizeof(license_x));
3460                         if (license == NULL) {
3461                                 DBG("Malloc Failed\n");
3462                                 return -1;
3463                         }
3464                         memset(license, '\0', sizeof(license_x));
3465                         LISTADD(mfx->license, license);
3466                         ret = __ps_process_license(reader, license);
3467                 } else if (!strcmp(ASCII(node), "privileges")) {
3468                         privileges_x *privileges = malloc(sizeof(privileges_x));
3469                         if (privileges == NULL) {
3470                                 DBG("Malloc Failed\n");
3471                                 return -1;
3472                         }
3473                         memset(privileges, '\0', sizeof(privileges_x));
3474                         LISTADD(mfx->privileges, privileges);
3475                         ret = __ps_process_privileges(reader, privileges);
3476                 } else if (!strcmp(ASCII(node), "ui-application")) {
3477                         uiapplication_x *uiapplication = malloc(sizeof(uiapplication_x));
3478                         if (uiapplication == NULL) {
3479                                 DBG("Malloc Failed\n");
3480                                 return -1;
3481                         }
3482                         memset(uiapplication, '\0', sizeof(uiapplication_x));
3483                         LISTADD(mfx->uiapplication, uiapplication);
3484                         ret = __ps_process_uiapplication(reader, uiapplication);
3485                 } else if (!strcmp(ASCII(node), "service-application")) {
3486                         serviceapplication_x *serviceapplication = malloc(sizeof(serviceapplication_x));
3487                         if (serviceapplication == NULL) {
3488                                 DBG("Malloc Failed\n");
3489                                 return -1;
3490                         }
3491                         memset(serviceapplication, '\0', sizeof(serviceapplication_x));
3492                         LISTADD(mfx->serviceapplication, serviceapplication);
3493                         ret = __ps_process_serviceapplication(reader, serviceapplication);
3494                 } else if (!strcmp(ASCII(node), "daemon")) {
3495                         daemon_x *daemon = malloc(sizeof(daemon_x));
3496                         if (daemon == NULL) {
3497                                 DBG("Malloc Failed\n");
3498                                 return -1;
3499                         }
3500                         memset(daemon, '\0', sizeof(daemon_x));
3501                         LISTADD(mfx->daemon, daemon);
3502                         ret = __ps_process_daemon(reader, daemon);
3503                 } else if (!strcmp(ASCII(node), "theme")) {
3504                         theme_x *theme = malloc(sizeof(theme_x));
3505                         if (theme == NULL) {
3506                                 DBG("Malloc Failed\n");
3507                                 return -1;
3508                         }
3509                         memset(theme, '\0', sizeof(theme_x));
3510                         LISTADD(mfx->theme, theme);
3511                         ret = __ps_process_theme(reader, theme);
3512                 } else if (!strcmp(ASCII(node), "font")) {
3513                         font_x *font = malloc(sizeof(font_x));
3514                         if (font == NULL) {
3515                                 DBG("Malloc Failed\n");
3516                                 return -1;
3517                         }
3518                         memset(font, '\0', sizeof(font_x));
3519                         LISTADD(mfx->font, font);
3520                         ret = __ps_process_font(reader, font);
3521                 } else if (!strcmp(ASCII(node), "ime")) {
3522                         ime_x *ime = malloc(sizeof(ime_x));
3523                         if (ime == NULL) {
3524                                 DBG("Malloc Failed\n");
3525                                 return -1;
3526                         }
3527                         memset(ime, '\0', sizeof(ime_x));
3528                         LISTADD(mfx->ime, ime);
3529                         ret = __ps_process_ime(reader, ime);
3530                 } else if (!strcmp(ASCII(node), "icon")) {
3531                         icon_x *icon = malloc(sizeof(icon_x));
3532                         if (icon == NULL) {
3533                                 DBG("Malloc Failed\n");
3534                                 return -1;
3535                         }
3536                         memset(icon, '\0', sizeof(icon_x));
3537                         LISTADD(mfx->icon, icon);
3538                         ret = __ps_process_icon(reader, icon);
3539                 } else if (!strcmp(ASCII(node), "device-profile")) {
3540                         deviceprofile_x *deviceprofile = malloc(sizeof(deviceprofile_x));
3541                         if (deviceprofile == NULL) {
3542                                 DBG("Malloc Failed\n");
3543                                 return -1;
3544                         }
3545                         memset(deviceprofile, '\0', sizeof(deviceprofile_x));
3546                         LISTADD(mfx->deviceprofile, deviceprofile);
3547                         ret = __ps_process_deviceprofile(reader, deviceprofile);
3548                 } else if (!strcmp(ASCII(node), "compatibility")) {
3549                         compatibility_x *compatibility = malloc(sizeof(compatibility_x));
3550                         if (compatibility == NULL) {
3551                                 DBG("Malloc Failed\n");
3552                                 return -1;
3553                         }
3554                         memset(compatibility, '\0', sizeof(compatibility_x));
3555                         LISTADD(mfx->compatibility, compatibility);
3556                         ret = __ps_process_compatibility(reader, compatibility);
3557                 } else if (!strcmp(ASCII(node), "shortcut-list")) {
3558                         continue;
3559                 } else if (!strcmp(ASCII(node), "livebox")) {
3560                         continue;
3561                 } else if (!strcmp(ASCII(node), "account")) {
3562                         continue;
3563                 } else if (!strcmp(ASCII(node), "notifications")) {
3564                         continue;
3565                 } else if (!strcmp(ASCII(node), "ime")) {
3566                         continue;
3567                 } else
3568                         return -1;
3569
3570                 if (ret < 0) {
3571                         DBG("Processing manifest failed\n");
3572                         return ret;
3573                 }
3574         }
3575         if (mfx->label) {
3576                 LISTHEAD(mfx->label, tmp1);
3577                 mfx->label = tmp1;
3578         }
3579         if (mfx->author) {
3580                 LISTHEAD(mfx->author, tmp2);
3581                 mfx->author = tmp2;
3582         }
3583         if (mfx->description) {
3584                 LISTHEAD(mfx->description, tmp3);
3585                 mfx->description= tmp3;
3586         }
3587         if (mfx->license) {
3588                 LISTHEAD(mfx->license, tmp4);
3589                 mfx->license= tmp4;
3590         }
3591         if (mfx->uiapplication) {
3592                 LISTHEAD(mfx->uiapplication, tmp5);
3593                 mfx->uiapplication = tmp5;
3594         }
3595         if (mfx->serviceapplication) {
3596                 LISTHEAD(mfx->serviceapplication, tmp6);
3597                 mfx->serviceapplication = tmp6;
3598         }
3599         if (mfx->daemon) {
3600                 LISTHEAD(mfx->daemon, tmp7);
3601                 mfx->daemon= tmp7;
3602         }
3603         if (mfx->theme) {
3604                 LISTHEAD(mfx->theme, tmp8);
3605                 mfx->theme= tmp8;
3606         }
3607         if (mfx->font) {
3608                 LISTHEAD(mfx->font, tmp9);
3609                 mfx->font= tmp9;
3610         }
3611         if (mfx->ime) {
3612                 LISTHEAD(mfx->ime, tmp10);
3613                 mfx->ime= tmp10;
3614         }
3615         if (mfx->icon) {
3616                 LISTHEAD(mfx->icon, tmp11);
3617                 mfx->icon= tmp11;
3618         }
3619         if (mfx->compatibility) {
3620                 LISTHEAD(mfx->compatibility, tmp12);
3621                 mfx->compatibility= tmp12;
3622         }
3623         if (mfx->deviceprofile) {
3624                 LISTHEAD(mfx->deviceprofile, tmp13);
3625                 mfx->deviceprofile= tmp13;
3626         }
3627         if (mfx->privileges) {
3628                 LISTHEAD(mfx->privileges, tmp14);
3629                 mfx->privileges = tmp14;
3630         }
3631         return ret;
3632 }
3633
3634 static int __process_manifest(xmlTextReaderPtr reader, manifest_x * mfx)
3635 {
3636         const xmlChar *node;
3637         int ret = -1;
3638
3639         if ((ret = __next_child_element(reader, -1))) {
3640                 node = xmlTextReaderConstName(reader);
3641                 if (!node) {
3642                         DBG("xmlTextReaderConstName value is NULL\n");
3643                         return -1;
3644                 }
3645
3646                 if (!strcmp(ASCII(node), "manifest")) {
3647                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("xmlns")))
3648                                 mfx->ns = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("xmlns")));
3649                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("package"))) {
3650                                 mfx->package= ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("package")));
3651                                 if (mfx->package == NULL) {
3652                                         DBG("package cant be NULL\n");
3653                                         return -1;
3654                                 }
3655                         } else {
3656                                 DBG("package field is mandatory\n");
3657                                 return -1;
3658                         }
3659                         package = mfx->package;
3660                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("version")))
3661                                 mfx->version= ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("version")));
3662                         /*app2ext needs package size for external installation*/
3663                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("size")))
3664                                 mfx->package_size = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("size")));
3665                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("install-location")))
3666                                 mfx->installlocation = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("install-location")));
3667                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("type")))
3668                                 mfx->type = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("type")));
3669                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("root_path")))
3670                                 mfx->root_path = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("root_path")));
3671                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("csc_path")))
3672                                 mfx->csc_path = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("csc_path")));
3673                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("appsetting"))) {
3674                                 mfx->appsetting = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("appsetting")));
3675                                 if (mfx->appsetting == NULL)
3676                                         mfx->appsetting = strdup("false");
3677                         } else {
3678                                 mfx->appsetting = strdup("false");
3679                         }
3680                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("storeclient-id")))
3681                                 mfx->storeclient_id= ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("storeclient-id")));
3682                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("nodisplay-setting"))) {
3683                                 mfx->nodisplay_setting = ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("nodisplay-setting")));
3684                                 if (mfx->nodisplay_setting == NULL)
3685                                         mfx->nodisplay_setting = strdup("false");
3686                         } else {
3687                                 mfx->nodisplay_setting = strdup("false");
3688                         }
3689                         if (xmlTextReaderGetAttribute(reader, XMLCHAR("url")))
3690                                 mfx->package_url= ASCII(xmlTextReaderGetAttribute(reader, XMLCHAR("url")));
3691
3692                         /*Assign default values. If required it will be overwritten in __add_preload_info()*/
3693                         mfx->preload = strdup("False");
3694                         mfx->removable = strdup("True");
3695                         mfx->readonly = strdup("False");
3696                         mfx->update = strdup("False");
3697                         char buf[PKG_STRING_LEN_MAX] = {'\0'};
3698                         char *val = NULL;
3699                         time_t current_time;
3700                         time(&current_time);
3701                         snprintf(buf, PKG_STRING_LEN_MAX - 1, "%d", current_time);
3702                         val = strndup(buf, PKG_STRING_LEN_MAX - 1);
3703                         mfx->installed_time = val;
3704
3705                         mfx->installed_storage= strdup("installed_internal");
3706
3707                         ret = __start_process(reader, mfx);
3708                 } else {
3709                         DBG("No Manifest element found\n");
3710                         return -1;
3711                 }
3712         }
3713         return ret;
3714 }
3715
3716 static char* __convert_to_system_locale(const char *mlocale)
3717 {
3718         if (mlocale == NULL)
3719                 return NULL;
3720         char *locale = NULL;
3721         locale = (char *)calloc(1, 6);
3722         if (!locale) {
3723                 DBGE("Malloc Failed\n");
3724                 return NULL;
3725         }
3726
3727         strncpy(locale, mlocale, 2);
3728         strncat(locale, "_", 1);
3729         locale[3] = toupper(mlocale[3]);
3730         locale[4] = toupper(mlocale[4]);
3731         return locale;
3732 }
3733
3734 static int __ail_change_info(int op, const char *appid)
3735 {
3736         void *lib_handle = NULL;
3737         int (*ail_desktop_operation) (const char *);
3738         char *aop = NULL;
3739         int ret = 0;
3740
3741         if ((lib_handle = dlopen(LIBAIL_PATH, RTLD_LAZY)) == NULL) {
3742                 DBGE("dlopen is failed LIBAIL_PATH[%s]\n", LIBAIL_PATH);
3743                 goto END;
3744         }
3745
3746
3747         switch (op) {
3748                 case 0:
3749                         aop  = "ail_desktop_add";
3750                         break;
3751                 case 1:
3752                         aop  = "ail_desktop_update";
3753                         break;
3754                 case 2:
3755                         aop  = "ail_desktop_remove";
3756                         break;
3757                 case 3:
3758                         aop  = "ail_desktop_clean";
3759                         break;
3760                 default:
3761                         goto END;
3762                         break;
3763         }
3764
3765         if ((ail_desktop_operation =
3766              dlsym(lib_handle, aop)) == NULL || dlerror() != NULL) {
3767                 DBGE("can not find symbol \n");
3768                 goto END;
3769         }
3770
3771         ret = ail_desktop_operation(appid);
3772
3773 END:
3774         if (lib_handle)
3775                 dlclose(lib_handle);
3776
3777         return ret;
3778 }
3779
3780
3781 /* desktop shoud be generated automatically based on manifest */
3782 /* Currently removable, taskmanage, etc fields are not considerd. it will be decided soon.*/
3783 static int __ps_make_nativeapp_desktop(manifest_x * mfx, const char *manifest, bool is_update)
3784 {
3785         FILE* file = NULL;
3786         int fd = 0;
3787         char filepath[PKG_STRING_LEN_MAX] = "";
3788         char *buf = NULL;
3789         char *buftemp = NULL;
3790         char *locale = NULL;
3791
3792         buf = (char *)calloc(1, BUFMAX);
3793         if (!buf) {
3794                 DBGE("Malloc Failed\n");
3795                 return -1;
3796         }
3797
3798         buftemp = (char *)calloc(1, BUFMAX);
3799         if (!buftemp) {
3800                 DBGE("Malloc Failed\n");
3801                 free(buf);
3802                 return -1;
3803         }
3804
3805         if (is_update)
3806                 __ail_change_info(AIL_CLEAN, mfx->package);
3807
3808         for(; mfx->uiapplication; mfx->uiapplication=mfx->uiapplication->next) {
3809
3810                 if (manifest != NULL) {
3811                         /* skip making a deskfile and update ail, if preload app is updated */
3812                         if(strstr(manifest, MANIFEST_RO_PREFIX)) {
3813                                 __ail_change_info(AIL_INSTALL, mfx->uiapplication->appid);
3814                     DBGE("preload app is update : skip and update ail : %s", manifest);
3815                                 continue;
3816                         }
3817                 }
3818
3819                 if(mfx->readonly && !strcasecmp(mfx->readonly, "True"))
3820                         snprintf(filepath, sizeof(filepath),"%s%s.desktop", DESKTOP_RO_PATH, mfx->uiapplication->appid);
3821                 else
3822                         snprintf(filepath, sizeof(filepath),"%s%s.desktop", DESKTOP_RW_PATH, mfx->uiapplication->appid);
3823
3824                 /* skip if desktop exists
3825                 if (access(filepath, R_OK) == 0)
3826                         continue;
3827                 */
3828
3829                 file = fopen(filepath, "w");
3830                 if(file == NULL)
3831                 {
3832                     DBGE("Can't open %s", filepath);
3833                     free(buf);
3834                     free(buftemp);
3835                     return -1;
3836                 }
3837
3838                 snprintf(buf, BUFMAX, "[Desktop Entry]\n");
3839                 fwrite(buf, 1, strlen(buf), file);
3840
3841                 for( ; mfx->uiapplication->label ; mfx->uiapplication->label = mfx->uiapplication->label->next) {
3842                         if(!strcmp(mfx->uiapplication->label->lang, DEFAULT_LOCALE)) {
3843                                 snprintf(buf, BUFMAX, "Name=%s\n",      mfx->uiapplication->label->text);
3844                         } else {
3845                                 locale = __convert_to_system_locale(mfx->uiapplication->label->lang);
3846                                 snprintf(buf, BUFMAX, "Name[%s]=%s\n", locale,
3847                                         mfx->uiapplication->label->text);
3848                                 free(locale);
3849                         }
3850                         fwrite(buf, 1, strlen(buf), file);
3851                 }
3852
3853                 if(mfx->uiapplication->label && mfx->uiapplication->label->text) {
3854                         snprintf(buf, BUFMAX, "Name=%s\n", mfx->uiapplication->label->text);
3855                         fwrite(buf, 1, strlen(buf), file);
3856                 }
3857 /*
3858                 else if(mfx->label && mfx->label->text) {
3859                         snprintf(buf, BUFMAX, "Name=%s\n", mfx->label->text);
3860                         fwrite(buf, 1, strlen(buf), file);
3861                 } else {
3862                         snprintf(buf, BUFMAX, "Name=%s\n", mfx->package);
3863                         fwrite(buf, 1, strlen(buf), file);
3864                 }
3865 */
3866
3867
3868                 snprintf(buf, BUFMAX, "Type=Application\n");
3869                 fwrite(buf, 1, strlen(buf), file);
3870
3871                 if(mfx->uiapplication->exec) {
3872                         snprintf(buf, BUFMAX, "Exec=%s\n", mfx->uiapplication->exec);
3873                         fwrite(buf, 1, strlen(buf), file);
3874                 }
3875
3876                 if(mfx->uiapplication->icon && mfx->uiapplication->icon->text) {
3877                         snprintf(buf, BUFMAX, "Icon=%s\n", mfx->uiapplication->icon->text);
3878                         fwrite(buf, 1, strlen(buf), file);
3879                 } else if(mfx->icon && mfx->icon->text) {
3880                         snprintf(buf, BUFMAX, "Icon=%s\n", mfx->icon->text);
3881                         fwrite(buf, 1, strlen(buf), file);
3882                 }
3883
3884                 // MIME types
3885                 if(mfx->uiapplication && mfx->uiapplication->appsvc) {
3886                         appsvc_x *asvc = mfx->uiapplication->appsvc;
3887                         mime_x *mi = NULL;
3888                         const char *mime = NULL;
3889                         const char *mime_delim = "; ";
3890                         int mime_count = 0;
3891
3892                         strncpy(buf, "MimeType=", BUFMAX-1);
3893                         while (asvc) {
3894                                 mi = asvc->mime;
3895                                 while (mi) {
3896                                         mime_count++;
3897                                         mime = mi->name;
3898                                         DBG("MIME type: %s\n", mime);
3899                                         strncat(buf, mime, BUFMAX-strlen(buf)-1);
3900                                         if(mi->next) {
3901                                                 strncat(buf, mime_delim, BUFMAX-strlen(buf)-1);
3902                                         }
3903
3904                                         mi = mi->next;
3905                                         mime = NULL;
3906                                 }
3907                                 asvc = asvc->next;
3908                         }
3909                         DBG("MIME types: buf[%s]\n", buf);
3910                         DBG("MIME count: %d\n", mime_count);
3911                         if(mime_count)
3912                                 fwrite(buf, 1, strlen(buf), file);
3913                 }
3914
3915                 if(mfx->version) {
3916                         snprintf(buf, BUFMAX, "Version=%s\n", mfx->version);
3917                         fwrite(buf, 1, strlen(buf), file);
3918                 }
3919
3920                 if(mfx->uiapplication->nodisplay) {
3921                         snprintf(buf, BUFMAX, "NoDisplay=%s\n", mfx->uiapplication->nodisplay);
3922                         fwrite(buf, 1, strlen(buf), file);
3923                 }
3924
3925                 if(mfx->uiapplication->categories) {
3926                         snprintf(buf, BUFMAX, "Categories=%s\n", mfx->uiapplication->categories);
3927                         fwrite(buf, 1, strlen(buf), file);
3928                 }
3929
3930                 if(mfx->uiapplication->taskmanage && !strcasecmp(mfx->uiapplication->taskmanage, "False")) {
3931                         snprintf(buf, BUFMAX, "X-TIZEN-TaskManage=False\n");
3932                         fwrite(buf, 1, strlen(buf), file);
3933                 }
3934
3935                 if(mfx->uiapplication->enabled && !strcasecmp(mfx->uiapplication->enabled, "False")) {
3936                         snprintf(buf, BUFMAX, "X-TIZEN-Enabled=False\n");
3937                         fwrite(buf, 1, strlen(buf), file);
3938                 }
3939
3940                 if(mfx->uiapplication->hwacceleration) {
3941                         snprintf(buf, BUFMAX, "Hw-Acceleration=%s\n", mfx->uiapplication->hwacceleration);
3942                         fwrite(buf, 1, strlen(buf), file);
3943                 }
3944
3945                 if(mfx->uiapplication->multiple && !strcasecmp(mfx->uiapplication->multiple, "True")) {
3946                         snprintf(buf, BUFMAX, "X-TIZEN-Multiple=True\n");
3947                         fwrite(buf, 1, strlen(buf), file);
3948                 }
3949
3950                 if(mfx->uiapplication->extraid) {
3951                         snprintf(buf, BUFMAX, "X-TIZEN-PackageID=%s\n", mfx->uiapplication->extraid);
3952                         fwrite(buf, 1, strlen(buf), file);
3953                 }
3954
3955                 if(mfx->removable && !strcasecmp(mfx->removable, "False")) {
3956                         snprintf(buf, BUFMAX, "X-TIZEN-Removable=False\n");
3957                         fwrite(buf, 1, strlen(buf), file);
3958                 }
3959
3960                 if(mfx->type) {
3961                         snprintf(buf, BUFMAX, "X-TIZEN-PackageType=%s\n", mfx->type);
3962                         fwrite(buf, 1, strlen(buf), file);
3963                 }
3964
3965                 snprintf(buf, BUFMAX, "X-TIZEN-PkgID=%s\n", mfx->package);
3966                 fwrite(buf, 1, strlen(buf), file);
3967
3968
3969 //              snprintf(buf, BUFMAX, "X-TIZEN-PackageType=rpm\n");
3970 //              fwrite(buf, 1, strlen(buf), file);
3971
3972
3973                 if(mfx->uiapplication->appsvc) {
3974                         snprintf(buf, BUFMAX, "X-TIZEN-Svc=");
3975                         DBG("buf[%s]\n", buf);
3976
3977
3978                         uiapplication_x *up = mfx->uiapplication;
3979                         appsvc_x *asvc = NULL;
3980                         operation_x *op = NULL;
3981                         mime_x *mi = NULL;
3982                         uri_x *ui = NULL;
3983                         subapp_x *sub = NULL;
3984                         const char *operation = NULL;
3985                         const char *mime = NULL;
3986                         const char *uri = NULL;
3987                         const char *subapp = NULL;
3988                         int i = 0;
3989
3990
3991                         asvc = up->appsvc;
3992                         while(asvc != NULL) {
3993                                 op = asvc->operation;
3994                                 while(op != NULL) {
3995                                         if (op)
3996                                                 operation = op->name;
3997                                         mi = asvc->mime;
3998
3999                                         do
4000                                         {
4001                                                 if (mi)
4002                                                         mime = mi->name;
4003                                                 sub = asvc->subapp;
4004                                                 do
4005                                                 {
4006                                                         if (sub)
4007                                                                 subapp = sub->name;
4008                                                         ui = asvc->uri;
4009                                                         do
4010                                                         {
4011                                                                 if (ui)
4012                                                                         uri = ui->name;
4013
4014                                                                 if(i++ > 0) {
4015                                                                         strncpy(buftemp, buf, BUFMAX);
4016                                                                         snprintf(buf, BUFMAX, "%s;", buftemp);
4017                                                                 }
4018
4019
4020                                                                 strncpy(buftemp, buf, BUFMAX);
4021                                                                 snprintf(buf, BUFMAX, "%s%s|%s|%s|%s", buftemp, operation?operation:"NULL", uri?uri:"NULL", mime?mime:"NULL", subapp?subapp:"NULL");
4022                                                                 DBG("buf[%s]\n", buf);
4023
4024                                                                 if (ui)
4025                                                                         ui = ui->next;
4026                                                                 uri = NULL;
4027                                                         } while(ui != NULL);
4028                                                 if (sub)
4029                                                                 sub = sub->next;
4030                                                         subapp = NULL;
4031                                                 }while(sub != NULL);
4032                                                 if (mi)
4033                                                         mi = mi->next;
4034                                                 mime = NULL;
4035                                         }while(mi != NULL);
4036                                         if (op)
4037                                                 op = op->next;
4038                                         operation = NULL;
4039                                 }
4040                                 asvc = asvc->next;
4041                         }
4042
4043
4044                         fwrite(buf, 1, strlen(buf), file);
4045
4046 //                      strncpy(buftemp, buf, BUFMAX);
4047 //                      snprintf(buf, BUFMAX, "%s\n", buftemp);
4048 //                      fwrite(buf, 1, strlen(buf), file);
4049                 }
4050
4051                 if(mfx->uiapplication->appcontrol) {
4052                         snprintf(buf, BUFMAX, "X-TIZEN-Svc=");
4053                         DBG("buf[%s]\n", buf);
4054
4055                         uiapplication_x *up = mfx->uiapplication;
4056                         appcontrol_x *acontrol = NULL;
4057                         operation_x *op = NULL;
4058                         mime_x *mi = NULL;
4059                         uri_x *ui = NULL;
4060                         subapp_x *sub = NULL;
4061                         const char *operation = NULL;
4062                         const char *mime = NULL;
4063                         const char *uri = NULL;
4064                         const char *subapp = NULL;
4065                         int i = 0;
4066
4067                         acontrol = up->appcontrol;
4068                         while(acontrol != NULL) {
4069                                 op = acontrol->operation;
4070                                 while(op != NULL) {
4071                                         if (op)
4072                                                 operation = op->name;
4073                                         mi = acontrol->mime;
4074
4075                                         do
4076                                         {
4077                                                 if (mi)
4078                                                         mime = mi->name;
4079                                                 sub = acontrol->subapp;
4080                                                 do
4081                                                 {
4082                                                         if (sub)
4083                                                                 subapp = sub->name;
4084                                                         ui = acontrol->uri;
4085                                                         do
4086                                                         {
4087                                                                 if (ui)
4088                                                                         uri = ui->name;
4089
4090                                                                 if(i++ > 0) {
4091                                                                         strncpy(buftemp, buf, BUFMAX);
4092                                                                         snprintf(buf, BUFMAX, "%s;", buftemp);
4093                                                                 }
4094
4095                                                                 strncpy(buftemp, buf, BUFMAX);
4096                                                                 snprintf(buf, BUFMAX, "%s%s|%s|%s|%s", buftemp, operation?operation:"NULL", uri?uri:"NULL", mime?mime:"NULL", subapp?subapp:"NULL");
4097                                                                 DBG("buf[%s]\n", buf);
4098
4099                                                                 if (ui)
4100                                                                         ui = ui->next;
4101                                                                 uri = NULL;
4102                                                         } while(ui != NULL);
4103                                                 if (sub)
4104                                                                 sub = sub->next;
4105                                                         subapp = NULL;
4106                                                 }while(sub != NULL);
4107                                                 if (mi)
4108                                                         mi = mi->next;
4109                                                 mime = NULL;
4110                                         }while(mi != NULL);
4111                                         if (op)
4112                                                 op = op->next;
4113                                         operation = NULL;
4114                                 }
4115                                 acontrol = acontrol->next;
4116                         }
4117
4118
4119                         fwrite(buf, 1, strlen(buf), file);
4120
4121 //                      strncpy(buftemp, buf, BUFMAX);
4122 //                      snprintf(buf, BUFMAX, "%s\n", buftemp);
4123 //                      fwrite(buf, 1, strlen(buf), file);
4124                 }
4125
4126                 fflush(file);
4127                 fd = fileno(file);
4128                 fsync(fd);
4129                 fclose(file);
4130
4131                 __ail_change_info(AIL_INSTALL, mfx->uiapplication->appid);
4132         }
4133
4134         free(buf);
4135         free(buftemp);
4136
4137         return 0;
4138 }
4139
4140 static int __ps_remove_nativeapp_desktop(manifest_x *mfx)
4141 {
4142         char filepath[PKG_STRING_LEN_MAX] = "";
4143         int ret = 0;
4144         uiapplication_x *uiapplication = mfx->uiapplication;
4145
4146         for(; uiapplication; uiapplication=uiapplication->next) {
4147                 snprintf(filepath, sizeof(filepath),"%s%s.desktop", DESKTOP_RW_PATH, uiapplication->appid);
4148
4149                 __ail_change_info(AIL_REMOVE, uiapplication->appid);
4150
4151                 ret = remove(filepath);
4152                 if (ret <0)
4153                         return -1;
4154         }
4155
4156         return 0;
4157 }
4158
4159 static int __ps_remove_appsvc_db(manifest_x *mfx)
4160 {
4161         void *lib_handle = NULL;
4162         int (*appsvc_operation) (const char *);
4163         int ret = 0;
4164         uiapplication_x *uiapplication = mfx->uiapplication;
4165
4166         if ((lib_handle = dlopen(LIBAPPSVC_PATH, RTLD_LAZY)) == NULL) {
4167                 DBGE("dlopen is failed LIBAIL_PATH[%s]\n", LIBAPPSVC_PATH);
4168                 goto END;
4169         }
4170
4171         if ((appsvc_operation =
4172                  dlsym(lib_handle, "appsvc_unset_defapp")) == NULL || dlerror() != NULL) {
4173                 DBGE("can not find symbol \n");
4174                 goto END;
4175         }
4176
4177         for(; uiapplication; uiapplication=uiapplication->next) {
4178                 ret = appsvc_operation(uiapplication->appid);
4179                 if (ret <0)
4180                         DBGE("can not operation  symbol \n");
4181         }
4182
4183 END:
4184         if (lib_handle)
4185                 dlclose(lib_handle);
4186
4187         return ret;
4188 }
4189
4190 static int __add_preload_info(manifest_x * mfx, const char *manifest)
4191 {
4192         FILE *fp = NULL;
4193         char buffer[1024] = { 0 };
4194         int state = 0;
4195
4196         if(strstr(manifest, MANIFEST_RO_PREFIX)) {
4197                 free((void *)mfx->readonly);
4198                 mfx->readonly = strdup("True");
4199
4200                 free((void *)mfx->preload);
4201                 mfx->preload = strdup("True");
4202
4203                 free((void *)mfx->removable);
4204                 mfx->removable = strdup("False");
4205
4206                 return 0;
4207         }
4208
4209         fp = fopen(PRELOAD_PACKAGE_LIST, "r");
4210         if (fp == NULL) {
4211                 DBGE("no preload list\n");
4212                 return -1;
4213         }
4214
4215         while (fgets(buffer, sizeof(buffer), fp) != NULL) {
4216                 if (buffer[0] == '#') {
4217                         if(strcasestr(buffer, "RW_NORM"))
4218                                 state = 2;
4219                         else if(strcasestr(buffer, "RW_RM"))
4220                                 state = 3;
4221                         else
4222                                 continue;
4223                 }
4224
4225                 __str_trim(buffer);
4226
4227                 if(!strcmp(mfx->package, buffer)) {
4228                         free((void *)mfx->preload);
4229                         mfx->preload = strdup("True");
4230                         if(state == 2){
4231                                 free((void *)mfx->readonly);
4232                                 mfx->readonly = strdup("False");
4233                                 free((void *)mfx->removable);
4234                                 mfx->removable = strdup("False");
4235                         } else if(state == 3){
4236                                 free((void *)mfx->readonly);
4237                                 mfx->readonly = strdup("False");
4238                                 free((void *)mfx->removable);
4239                                 mfx->removable = strdup("True");
4240                         }
4241                 }
4242
4243                 memset(buffer, 0x00, sizeof(buffer));
4244         }
4245
4246         if (fp != NULL)
4247                 fclose(fp);
4248
4249         return 0;
4250 }
4251
4252 static int __check_preload_updated(manifest_x * mfx, const char *manifest)
4253 {
4254         char filepath[PKG_STRING_LEN_MAX] = "";
4255         int ret = 0;
4256         uiapplication_x *uiapplication = mfx->uiapplication;
4257
4258         if(strstr(manifest, MANIFEST_RO_PREFIX)) {
4259                 /* if preload app is updated, then remove previous desktop file on RW*/
4260                 for(; uiapplication; uiapplication=uiapplication->next) {
4261                                 snprintf(filepath, sizeof(filepath),"%s%s.desktop", DESKTOP_RW_PATH, uiapplication->appid);
4262                         ret = remove(filepath);
4263                         if (ret <0)
4264                                 return -1;
4265                 }
4266         } else {
4267                 /* if downloaded app is updated, then update tag set true*/
4268                 free((void *)mfx->update);
4269                 mfx->update = strdup("true");
4270         }
4271
4272         return 0;
4273 }
4274
4275
4276 API int pkgmgr_parser_create_desktop_file(manifest_x *mfx)
4277 {
4278         int ret = 0;
4279         if (mfx == NULL) {
4280                 DBG("Manifest pointer is NULL\n");
4281                 return -1;
4282         }
4283         ret = __ps_make_nativeapp_desktop(mfx, NULL, 0);
4284         if (ret == -1)
4285                 DBG("Creating desktop file failed\n");
4286         else
4287                 DBG("Creating desktop file Success\n");
4288         return ret;
4289 }
4290
4291 API void pkgmgr_parser_free_manifest_xml(manifest_x *mfx)
4292 {
4293         if (mfx == NULL)
4294                 return;
4295         if (mfx->ns) {
4296                 free((void *)mfx->ns);
4297                 mfx->ns = NULL;
4298         }
4299         if (mfx->package) {
4300                 free((void *)mfx->package);
4301                 mfx->package = NULL;
4302         }
4303         if (mfx->version) {
4304                 free((void *)mfx->version);
4305                 mfx->version = NULL;
4306         }
4307         if (mfx->installlocation) {
4308                 free((void *)mfx->installlocation);
4309                 mfx->installlocation = NULL;
4310         }
4311         if (mfx->preload) {
4312                 free((void *)mfx->preload);
4313                 mfx->preload = NULL;
4314         }
4315         if (mfx->readonly) {
4316                 free((void *)mfx->readonly);
4317                 mfx->readonly = NULL;
4318         }
4319         if (mfx->removable) {
4320                 free((void *)mfx->removable);
4321                 mfx->removable = NULL;
4322         }
4323         if (mfx->update) {
4324                 free((void *)mfx->update);
4325                 mfx->update = NULL;
4326         }
4327         if (mfx->type) {
4328                 free((void *)mfx->type);
4329                 mfx->type = NULL;
4330         }
4331         if (mfx->package_size) {
4332                 free((void *)mfx->package_size);
4333                 mfx->package_size = NULL;
4334         }
4335         if (mfx->installed_time) {
4336                 free((void *)mfx->installed_time);
4337                 mfx->installed_time = NULL;
4338         }
4339         if (mfx->installed_storage) {
4340                 free((void *)mfx->installed_storage);
4341                 mfx->installed_storage = NULL;
4342         }
4343         if (mfx->storeclient_id) {
4344                 free((void *)mfx->storeclient_id);
4345                 mfx->storeclient_id = NULL;
4346         }
4347         if (mfx->mainapp_id) {
4348                 free((void *)mfx->mainapp_id);
4349                 mfx->mainapp_id = NULL;
4350         }
4351         if (mfx->package_url) {
4352                 free((void *)mfx->package_url);
4353                 mfx->package_url = NULL;
4354         }
4355         if (mfx->root_path) {
4356                 free((void *)mfx->root_path);
4357                 mfx->root_path = NULL;
4358         }
4359         if (mfx->csc_path) {
4360                 free((void *)mfx->csc_path);
4361                 mfx->csc_path = NULL;
4362         }
4363         if (mfx->appsetting) {
4364                 free((void *)mfx->appsetting);
4365                 mfx->appsetting = NULL;
4366         }
4367         if (mfx->nodisplay_setting) {
4368                 free((void *)mfx->nodisplay_setting);
4369                 mfx->nodisplay_setting = NULL;
4370         }
4371
4372         /*Free Icon*/
4373         if (mfx->icon) {
4374                 icon_x *icon = mfx->icon;
4375                 icon_x *tmp = NULL;
4376                 while(icon != NULL) {
4377                         tmp = icon->next;
4378                         __ps_free_icon(icon);
4379                         icon = tmp;
4380                 }
4381         }
4382         /*Free Label*/
4383         if (mfx->label) {
4384                 label_x *label = mfx->label;
4385                 label_x *tmp = NULL;
4386                 while(label != NULL) {
4387                         tmp = label->next;
4388                         __ps_free_label(label);
4389                         label = tmp;
4390                 }
4391         }
4392         /*Free Author*/
4393         if (mfx->author) {
4394                 author_x *author = mfx->author;
4395                 author_x *tmp = NULL;
4396                 while(author != NULL) {
4397                         tmp = author->next;
4398                         __ps_free_author(author);
4399                         author = tmp;
4400                 }
4401         }
4402         /*Free Description*/
4403         if (mfx->description) {
4404                 description_x *description = mfx->description;
4405                 description_x *tmp = NULL;
4406                 while(description != NULL) {
4407                         tmp = description->next;
4408                         __ps_free_description(description);
4409                         description = tmp;
4410                 }
4411         }
4412         /*Free License*/
4413         if (mfx->license) {
4414                 license_x *license = mfx->license;
4415                 license_x *tmp = NULL;
4416                 while(license != NULL) {
4417                         tmp = license->next;
4418                         __ps_free_license(license);
4419                         license = tmp;
4420                 }
4421         }
4422         /*Free Privileges*/
4423         if (mfx->privileges) {
4424                 privileges_x *privileges = mfx->privileges;
4425                 privileges_x *tmp = NULL;
4426                 while(privileges != NULL) {
4427                         tmp = privileges->next;
4428                         __ps_free_privileges(privileges);
4429                         privileges = tmp;
4430                 }
4431         }
4432         /*Free UiApplication*/
4433         if (mfx->uiapplication) {
4434                 uiapplication_x *uiapplication = mfx->uiapplication;
4435                 uiapplication_x *tmp = NULL;
4436                 while(uiapplication != NULL) {
4437                         tmp = uiapplication->next;
4438                         __ps_free_uiapplication(uiapplication);
4439                         uiapplication = tmp;
4440                 }
4441         }
4442         /*Free ServiceApplication*/
4443         if (mfx->serviceapplication) {
4444                 serviceapplication_x *serviceapplication = mfx->serviceapplication;
4445                 serviceapplication_x *tmp = NULL;
4446                 while(serviceapplication != NULL) {
4447                         tmp = serviceapplication->next;
4448                         __ps_free_serviceapplication(serviceapplication);
4449                         serviceapplication = tmp;
4450                 }
4451         }
4452         /*Free Daemon*/
4453         if (mfx->daemon) {
4454                 daemon_x *daemon = mfx->daemon;
4455                 daemon_x *tmp = NULL;
4456                 while(daemon != NULL) {
4457                         tmp = daemon->next;
4458                         __ps_free_daemon(daemon);
4459                         daemon = tmp;
4460                 }
4461         }
4462         /*Free Theme*/
4463         if (mfx->theme) {
4464                 theme_x *theme = mfx->theme;
4465                 theme_x *tmp = NULL;
4466                 while(theme != NULL) {
4467                         tmp = theme->next;
4468                         __ps_free_theme(theme);
4469                         theme = tmp;
4470                 }
4471         }
4472         /*Free Font*/
4473         if (mfx->font) {
4474                 font_x *font = mfx->font;
4475                 font_x *tmp = NULL;
4476                 while(font != NULL) {
4477                         tmp = font->next;
4478                         __ps_free_font(font);
4479                         font = tmp;
4480                 }
4481         }
4482         /*Free Ime*/
4483         if (mfx->ime) {
4484                 ime_x *ime = mfx->ime;
4485                 ime_x *tmp = NULL;
4486                 while(ime != NULL) {
4487                         tmp = ime->next;
4488                         __ps_free_ime(ime);
4489                         ime = tmp;
4490                 }
4491         }
4492         /*Free Compatibility*/
4493         if (mfx->compatibility) {
4494                 compatibility_x *compatibility = mfx->compatibility;
4495                 compatibility_x *tmp = NULL;
4496                 while(compatibility != NULL) {
4497                         tmp = compatibility->next;
4498                         __ps_free_compatibility(compatibility);
4499                         compatibility = tmp;
4500                 }
4501         }
4502         /*Free DeviceProfile*/
4503         if (mfx->deviceprofile) {
4504                 deviceprofile_x *deviceprofile = mfx->deviceprofile;
4505                 deviceprofile_x *tmp = NULL;
4506                 while(deviceprofile != NULL) {
4507                         tmp = deviceprofile->next;
4508                         __ps_free_deviceprofile(deviceprofile);
4509                         deviceprofile = tmp;
4510                 }
4511         }
4512         free((void*)mfx);
4513         mfx = NULL;
4514         return;
4515 }
4516
4517 API manifest_x *pkgmgr_parser_process_manifest_xml(const char *manifest)
4518 {
4519         DBG("parsing start\n");
4520         xmlTextReaderPtr reader;
4521         manifest_x *mfx = NULL;
4522
4523         reader = xmlReaderForFile(manifest, NULL, 0);
4524         if (reader) {
4525                 mfx = malloc(sizeof(manifest_x));
4526                 if (mfx) {
4527                         memset(mfx, '\0', sizeof(manifest_x));
4528                         if (__process_manifest(reader, mfx) < 0) {
4529                                 DBG("Parsing Failed\n");
4530                                 pkgmgr_parser_free_manifest_xml(mfx);
4531                                 mfx = NULL;
4532                         } else
4533                                 DBG("Parsing Success\n");
4534                 } else {
4535                         DBG("Memory allocation error\n");
4536                 }
4537                 xmlFreeTextReader(reader);
4538         } else {
4539                 DBG("Unable to create xml reader\n");
4540         }
4541         return mfx;
4542 }
4543
4544 /* These APIs are intended to call parser directly */
4545
4546 API int pkgmgr_parser_parse_manifest_for_installation(const char *manifest, char *const tagv[])
4547 {
4548         char *temp[] = {"shortcut-list", "livebox", "account", "notifications", "privileges", "ime", "font", NULL};
4549         if (manifest == NULL) {
4550                 DBG("argument supplied is NULL\n");
4551                 return PMINFO_R_EINVAL;
4552         }
4553         DBG("parsing manifest for installation: %s\n", manifest);
4554         manifest_x *mfx = NULL;
4555         int ret = -1;
4556         char roxml_check[PKG_STRING_LEN_MAX] = {'\0'};
4557
4558         xmlInitParser();
4559         mfx = pkgmgr_parser_process_manifest_xml(manifest);
4560         DBG("Parsing Finished\n");
4561         if (mfx == NULL)
4562                 return PMINFO_R_ERROR;
4563
4564         __streamFile(manifest, ACTION_INSTALL, temp, mfx->package);
4565         __add_preload_info(mfx, manifest);
4566         DBG("Added preload infomation\n");
4567
4568         __ps_process_tag(mfx, tagv);
4569
4570         ret = pkgmgr_parser_insert_manifest_info_in_db(mfx);
4571         if (ret == -1)
4572                 DBG("DB Insert failed\n");
4573         else
4574                 DBG("DB Insert Success\n");
4575
4576         ret = __ps_process_mdparser(mfx, ACTION_INSTALL);
4577         if (ret == -1)
4578                 DBG("Creating metadata parser failed\n");
4579
4580         ret = __ps_make_nativeapp_desktop(mfx, NULL, 0);
4581         if (ret == -1)
4582                 DBG("Creating desktop file failed\n");
4583         else
4584                 DBG("Creating desktop file Success\n");
4585
4586         __ps_apply_shared_privileges(mfx, manifest);
4587
4588         pkgmgr_parser_free_manifest_xml(mfx);
4589         DBG("Free Done\n");
4590         xmlCleanupParser();
4591
4592         return PMINFO_R_OK;
4593 }
4594
4595 API int pkgmgr_parser_parse_manifest_for_upgrade(const char *manifest, char *const tagv[])
4596 {
4597         char *temp[] = {"shortcut-list", "livebox", "account", "notifications", "privileges", "ime", "font", NULL};
4598         if (manifest == NULL) {
4599                 DBG("argument supplied is NULL\n");
4600                 return PMINFO_R_EINVAL;
4601         }
4602         DBG("parsing manifest for upgradation: %s\n", manifest);
4603         manifest_x *mfx = NULL;
4604         int ret = -1;
4605         bool preload = false;
4606         char *csc_path = NULL;
4607         pkgmgrinfo_pkginfo_h handle = NULL;
4608
4609         xmlInitParser();
4610         mfx = pkgmgr_parser_process_manifest_xml(manifest);
4611         DBG("Parsing Finished\n");
4612         if (mfx == NULL)
4613                 return PMINFO_R_ERROR;
4614         
4615         __streamFile(manifest, ACTION_UPGRADE, temp, mfx->package);
4616         __add_preload_info(mfx, manifest);
4617         DBG("Added preload infomation\n");
4618         __check_preload_updated(mfx, manifest);
4619
4620         ret = pkgmgrinfo_pkginfo_get_pkginfo(mfx->package, &handle);
4621         if (ret != PMINFO_R_OK)
4622                 DBG("pkgmgrinfo_pkginfo_get_pkginfo failed\n");
4623
4624         ret = pkgmgrinfo_pkginfo_is_preload(handle, &preload);
4625         if (ret != PMINFO_R_OK)
4626                 DBG("pkgmgrinfo_pkginfo_is_preload failed\n");
4627
4628         if (preload) {
4629                 free((void *)mfx->preload);
4630                 mfx->preload = strdup("true");
4631         }
4632
4633         ret = pkgmgrinfo_pkginfo_get_csc_path(handle, &csc_path);
4634         if (ret != PMINFO_R_OK)
4635                 DBG("pkgmgrinfo_pkginfo_get_csc_path failed\n");
4636
4637         if (csc_path != NULL) {
4638                 if (mfx->csc_path)
4639                         free((void *)mfx->csc_path);
4640                 mfx->csc_path = strdup(csc_path);
4641         }
4642
4643         ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
4644         if (ret == -1)
4645                 DBG("DB Update failed\n");
4646         else
4647                 DBG("DB Update Success\n");
4648
4649         ret = __ps_process_mdparser(mfx, ACTION_UPGRADE);
4650         if (ret == -1)
4651                 DBG("Upgrade metadata parser failed\n");
4652
4653         ret = __ps_make_nativeapp_desktop(mfx, manifest, 1);
4654         if (ret == -1)
4655                 DBG("Creating desktop file failed\n");
4656         else
4657                 DBG("Creating desktop file Success\n");
4658
4659         __ps_apply_shared_privileges(mfx, manifest);
4660
4661         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
4662         pkgmgr_parser_free_manifest_xml(mfx);
4663         DBG("Free Done\n");
4664         xmlCleanupParser();
4665
4666         return PMINFO_R_OK;
4667 }
4668
4669 API int pkgmgr_parser_parse_manifest_for_uninstallation(const char *manifest, char *const tagv[])
4670 {
4671         char *temp[] = {"shortcut-list", "livebox", "account", "notifications", "privileges", "ime", "font", NULL};
4672         if (manifest == NULL) {
4673                 DBG("argument supplied is NULL\n");
4674                 return PMINFO_R_EINVAL;
4675         }
4676         DBG("parsing manifest for uninstallation: %s\n", manifest);
4677         manifest_x *mfx = NULL;
4678         int ret = -1;
4679         xmlInitParser();
4680         mfx = pkgmgr_parser_process_manifest_xml(manifest);
4681         DBG("Parsing Finished\n");
4682         if (mfx == NULL)
4683                 return PMINFO_R_ERROR;
4684         
4685         __streamFile(manifest, ACTION_UNINSTALL, temp, mfx->package);
4686         __add_preload_info(mfx, manifest);
4687         DBG("Added preload infomation\n");
4688
4689         ret = __ps_process_mdparser(mfx, ACTION_UNINSTALL);
4690         if (ret == -1)
4691                 DBG("Removing metadata parser failed\n");
4692
4693         ret = pkgmgr_parser_delete_manifest_info_from_db(mfx);
4694         if (ret == -1)
4695                 DBG("DB Delete failed\n");
4696         else
4697                 DBG("DB Delete Success\n");
4698
4699         ret = __ps_remove_nativeapp_desktop(mfx);
4700         if (ret == -1)
4701                 DBG("Removing desktop file failed\n");
4702         else
4703                 DBG("Removing desktop file Success\n");
4704
4705         ret = __ps_remove_appsvc_db(mfx);
4706         if (ret == -1)
4707                 DBG("Removing appsvc_db failed\n");
4708         else
4709                 DBG("Removing appsvc_db Success\n");
4710
4711         pkgmgr_parser_free_manifest_xml(mfx);
4712         DBG("Free Done\n");
4713         xmlCleanupParser();
4714
4715         return PMINFO_R_OK;
4716 }
4717
4718 API int pkgmgr_parser_parse_manifest_for_preload()
4719 {
4720         __ps_process_smack();
4721
4722         return pkgmgr_parser_update_preload_info_in_db();
4723 }
4724
4725 API char *pkgmgr_parser_get_manifest_file(const char *pkgid)
4726 {
4727         return __pkgid_to_manifest(pkgid);
4728 }
4729
4730 API int pkgmgr_parser_run_parser_for_installation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
4731 {
4732         return __ps_run_parser(docPtr, tag, ACTION_INSTALL, pkgid);
4733 }
4734
4735 API int pkgmgr_parser_run_parser_for_upgrade(xmlDocPtr docPtr, const char *tag, const char *pkgid)
4736 {
4737         return __ps_run_parser(docPtr, tag, ACTION_UPGRADE, pkgid);
4738 }
4739
4740 API int pkgmgr_parser_run_parser_for_uninstallation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
4741 {
4742         return __ps_run_parser(docPtr, tag, ACTION_UNINSTALL, pkgid);
4743 }
4744
4745 #if 1
4746 API int pkgmgr_parser_check_manifest_validation(const char *manifest)
4747 {
4748         if (manifest == NULL) {
4749                 DBGE("manifest file is NULL\n");
4750                 return PMINFO_R_EINVAL;
4751         }
4752         int ret = -1;
4753         xmlSchemaParserCtxtPtr ctx;
4754         xmlSchemaValidCtxtPtr vctx;
4755         xmlSchemaPtr xschema;
4756         ctx = xmlSchemaNewParserCtxt(SCHEMA_FILE);
4757         if (ctx == NULL) {
4758                 DBGE("xmlSchemaNewParserCtxt() Failed\n");
4759                 return PMINFO_R_ERROR;
4760         }
4761         xschema = xmlSchemaParse(ctx);
4762         if (xschema == NULL) {
4763                 DBGE("xmlSchemaParse() Failed\n");
4764                 return PMINFO_R_ERROR;
4765         }
4766         vctx = xmlSchemaNewValidCtxt(xschema);
4767         if (vctx == NULL) {
4768                 DBGE("xmlSchemaNewValidCtxt() Failed\n");
4769                 return PMINFO_R_ERROR;
4770         }
4771         xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stderr);
4772         ret = xmlSchemaValidateFile(vctx, manifest, 0);
4773         if (ret == -1) {
4774                 DBGE("xmlSchemaValidateFile() failed\n");
4775                 return PMINFO_R_ERROR;
4776         } else if (ret == 0) {
4777                 DBGE("Manifest is Valid\n");
4778                 return PMINFO_R_OK;
4779         } else {
4780                 DBGE("Manifest Validation Failed with error code %d\n", ret);
4781                 return PMINFO_R_ERROR;
4782         }
4783         return PMINFO_R_OK;
4784 }
4785
4786 #else
4787 API int pkgmgr_parser_check_manifest_validation(const char *manifest)
4788 {
4789         int err = 0;
4790         int status = 0;
4791         pid_t pid;
4792
4793         pid = fork();
4794
4795         switch (pid) {
4796         case -1:
4797                 DBGE("fork failed\n");
4798                 return -1;
4799         case 0:
4800                 /* child */
4801                 {
4802                         int dev_null_fd = open ("/dev/null", O_RDWR);
4803                         if (dev_null_fd >= 0)
4804                         {
4805                                 dup2 (dev_null_fd, 0);/*stdin*/
4806                                 dup2 (dev_null_fd, 1);/*stdout*/
4807                                 dup2 (dev_null_fd, 2);/*stderr*/
4808                         }
4809
4810                         if (execl("/usr/bin/xmllint", "xmllint", manifest, "--schema",
4811                                 SCHEMA_FILE, NULL) < 0) {
4812                                 DBGE("execl error\n");
4813                         }
4814
4815                         _exit(100);
4816                 }
4817         default:
4818                 /* parent */
4819                 break;
4820         }
4821
4822         while ((err = waitpid(pid, &status, WNOHANG)) != pid) {
4823                 if (err < 0) {
4824                         if (errno == EINTR)
4825                                 continue;
4826                         DBGE("waitpid failed\n");
4827                         return -1;
4828                 }
4829         }
4830
4831
4832         if(WIFEXITED(status) && !WEXITSTATUS(status))
4833                 return 0;
4834         else
4835                 return -1;
4836 }
4837 #endif