4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
7 * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
31 #include <libxml/parser.h>
32 #include <libxml/xmlreader.h>
33 #include <libxml/xmlschemas.h>
38 #include "pkgmgr-info.h"
39 #include "pkgmgrinfo_basic.h"
40 #include "pkgmgrinfo_debug.h"
42 #include "pkgmgr_parser.h"
43 #include "pkgmgr_parser_internal.h"
44 #include "pkgmgr_parser_db.h"
45 #include "pkgmgr_parser_signature.h"
50 #define LOG_TAG "PKGMGR_PARSER"
52 #define ASCII(s) (const char *)s
53 #define XMLCHAR(s) (const xmlChar *)s
55 //#define METADATA_PARSER_LIST SYSCONFDIR "/package-manager/parserlib/metadata/metadata_parser_list.txt"
56 #define METADATA_PARSER_LIST SYSCONFDIR "/package-manager/parserlib/metadata/mdparser_list.txt"
57 #define METADATA_PARSER_NAME "metadataparser:"
59 #define CATEGORY_PARSER_LIST SYSCONFDIR "/package-manager/parserlib/category/category_parser_list.txt"
60 #define CATEGORY_PARSER_NAME "categoryparser:"
62 #define TAG_PARSER_LIST SYSCONFDIR "/package-manager/parserlib/tag_parser_list.txt"
63 #define TAG_PARSER_NAME "parserlib:"
65 #define PKG_TAG_LEN_MAX 128
68 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
79 /* plugin process_type */
81 PLUGIN_PRE_PROCESS = 0,
83 } PLUGIN_PROCESS_TYPE;
96 static int __ps_process_label(xmlTextReaderPtr reader, label_x *label);
97 static int __ps_process_privilege(xmlTextReaderPtr reader, privilege_x *privilege);
98 static int __ps_process_privileges(xmlTextReaderPtr reader, privileges_x *privileges);
99 static int __ps_process_deviceprofile(xmlTextReaderPtr reader, deviceprofile_x *deviceprofile);
100 static int __ps_process_allowed(xmlTextReaderPtr reader, allowed_x *allowed);
101 static int __ps_process_operation(xmlTextReaderPtr reader, operation_x *operation);
102 static int __ps_process_uri(xmlTextReaderPtr reader, uri_x *uri);
103 static int __ps_process_mime(xmlTextReaderPtr reader, mime_x *mime);
104 static int __ps_process_subapp(xmlTextReaderPtr reader, subapp_x *subapp);
105 static int __ps_process_condition(xmlTextReaderPtr reader, condition_x *condition);
106 static int __ps_process_notification(xmlTextReaderPtr reader, notification_x *notifiation);
107 static int __ps_process_category(xmlTextReaderPtr reader, category_x *category);
108 static int __ps_process_metadata(xmlTextReaderPtr reader, metadata_x *metadata);
109 static int __ps_process_permission(xmlTextReaderPtr reader, permission_x *permission);
110 static int __ps_process_compatibility(xmlTextReaderPtr reader, compatibility_x *compatibility);
111 static int __ps_process_request(xmlTextReaderPtr reader, request_x *request);
112 static int __ps_process_define(xmlTextReaderPtr reader, define_x *define);
113 static int __ps_process_appsvc(xmlTextReaderPtr reader, appsvc_x *appsvc);
114 static int __ps_process_launchconditions(xmlTextReaderPtr reader, launchconditions_x *launchconditions);
115 static int __ps_process_datashare(xmlTextReaderPtr reader, datashare_x *datashare);
116 static int __ps_process_icon(xmlTextReaderPtr reader, icon_x *icon, uid_t uid);
117 static int __ps_process_author(xmlTextReaderPtr reader, author_x *author);
118 static int __ps_process_description(xmlTextReaderPtr reader, description_x *description);
119 static int __ps_process_license(xmlTextReaderPtr reader, license_x *license);
120 static int __ps_process_appcontrol(xmlTextReaderPtr reader, appcontrol_x *appcontrol);
121 static int __ps_process_datacontrol(xmlTextReaderPtr reader, datacontrol_x *datacontrol);
122 static int __ps_process_uiapplication(xmlTextReaderPtr reader, uiapplication_x *uiapplication, uid_t uid);
123 static int __ps_process_serviceapplication(xmlTextReaderPtr reader, serviceapplication_x *serviceapplication, uid_t uid);
124 static int __ps_process_font(xmlTextReaderPtr reader, font_x *font);
125 static int __ps_process_theme(xmlTextReaderPtr reader, theme_x *theme);
126 static int __ps_process_daemon(xmlTextReaderPtr reader, daemon_x *daemon);
127 static int __ps_process_ime(xmlTextReaderPtr reader, ime_x *ime);
128 static char *__pkgid_to_manifest(const char *pkgid, uid_t uid);
129 static int __next_child_element(xmlTextReaderPtr reader, int depth);
130 static int __start_process(xmlTextReaderPtr reader, manifest_x * mfx, uid_t uid);
131 static int __process_manifest(xmlTextReaderPtr reader, manifest_x * mfx, uid_t uid);
132 static void __str_trim(char *input);
133 static char *__get_parser_plugin(const char *type);
134 static int __ps_run_parser(xmlDocPtr docPtr, const char *tag, ACTION_TYPE action, const char *pkgid);
135 API int __is_admin();
137 static void __save_xml_attribute(xmlTextReaderPtr reader, char *attribute, const char **xml_attribute, char *default_value)
139 xmlChar *attrib_val = xmlTextReaderGetAttribute(reader, XMLCHAR(attribute));
141 *xml_attribute = strdup((const char *)attrib_val);
144 if (default_value != NULL) {
145 *xml_attribute = strdup(default_value);
150 static void __save_xml_lang(xmlTextReaderPtr reader, const char **xml_attribute)
152 const xmlChar *attrib_val = xmlTextReaderConstXmlLang(reader);
153 if (attrib_val != NULL)
154 *xml_attribute = strdup(ASCII(attrib_val));
156 *xml_attribute = strdup(DEFAULT_LOCALE);
159 static void __save_xml_value(xmlTextReaderPtr reader, const char **xml_attribute)
161 xmlTextReaderRead(reader);
162 const xmlChar *attrib_val = xmlTextReaderConstValue(reader);
165 *xml_attribute = strdup((const char *)attrib_val);
168 static void __save_xml_installed_time(manifest_x *mfx)
170 char buf[PKG_STRING_LEN_MAX] = {'\0'};
174 snprintf(buf, PKG_STRING_LEN_MAX - 1, "%d", (int)current_time);
175 val = strndup(buf, PKG_STRING_LEN_MAX - 1);
176 mfx->installed_time = val;
179 static void __save_xml_root_path(manifest_x *mfx, uid_t uid)
181 char root[PKG_STRING_LEN_MAX] = { '\0' };
187 tzplatform_set_user(uid);
188 path = tzplatform_getenv((uid == OWNER_ROOT || uid == GLOBAL_USER) ? TZ_SYS_RO_APP : TZ_USER_APP);
189 snprintf(root, PKG_STRING_LEN_MAX - 1, "%s/%s", path, mfx->package);
191 mfx->root_path = strdup(root);
193 tzplatform_reset_user();
196 static void __save_xml_default_value(manifest_x * mfx)
198 mfx->preload = strdup("False");
199 mfx->removable = strdup("True");
200 mfx->readonly = strdup("False");
201 mfx->update = strdup("False");
202 mfx->system = strdup("False");
203 mfx->installed_storage= strdup("installed_internal");
204 package = mfx->package;
207 void *__open_lib_handle(char *tag)
209 char *lib_path = NULL;
210 void *lib_handle = NULL;
212 lib_path = __get_parser_plugin(tag);
213 retvm_if(!lib_path, NULL, "lib_path get fail");
215 lib_handle = dlopen(lib_path, RTLD_LAZY);
216 retvm_if(lib_handle == NULL, NULL, "dlopen is failed lib_path[%s]", lib_path);
221 void __close_lib_handle(void *lib_handle)
226 static void __str_trim(char *input)
228 char *trim_str = input;
233 while (*input != 0) {
234 if (!isspace(*input)) {
247 uid_t uid = getuid();
248 if ((uid_t) 0 == uid )
256 static char * __get_tag_by_key(char *md_key)
260 if (md_key == NULL) {
261 _LOGD("md_key is NULL\n");
265 md_tag = strrchr(md_key, 47) + 1;
268 return strdup(md_tag);
271 static char *__get_metadata_parser_plugin(const char *type)
274 char buffer[1024] = { 0 };
275 char temp_path[1024] = { 0 };
279 _LOGE("invalid argument\n");
283 fp = fopen(PKG_PARSER_CONF_PATH, "r");
285 _LOGE("no matching metadata parser\n");
289 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
290 if (buffer[0] == '#')
295 if ((path = strstr(buffer, METADATA_PARSER_NAME)) != NULL) {
296 path = path + strlen(METADATA_PARSER_NAME);
301 memset(buffer, 0x00, 1024);
308 _LOGE("no matching [%s] [%s]\n", METADATA_PARSER_NAME,type);
312 snprintf(temp_path, sizeof(temp_path) - 1, "%slib%s.so", path, type);
314 return strdup(temp_path);
317 static char *__get_category_parser_plugin(const char *type)
320 char buffer[1024] = { 0 };
321 char temp_path[1024] = { 0 };
325 _LOGE("invalid argument\n");
329 fp = fopen(PKG_PARSER_CONF_PATH, "r");
331 _LOGE("no matching metadata parser\n");
335 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
336 if (buffer[0] == '#')
341 if ((path = strstr(buffer, CATEGORY_PARSER_NAME)) != NULL) {
342 path = path + strlen(CATEGORY_PARSER_NAME);
347 memset(buffer, 0x00, 1024);
354 _LOGE("no matching [%s] [%s]\n", CATEGORY_PARSER_NAME,type);
358 snprintf(temp_path, sizeof(temp_path) - 1, "%slib%s.so", path, type);
360 return strdup(temp_path);
363 static char *__get_parser_plugin(const char *type)
366 char buffer[1024] = { 0 };
367 char temp_path[1024] = { 0 };
371 _LOGE("invalid argument\n");
375 fp = fopen(PKG_PARSER_CONF_PATH, "r");
377 _LOGE("no matching backendlib\n");
381 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
382 if (buffer[0] == '#')
387 if ((path = strstr(buffer, PKG_PARSERLIB)) != NULL) {
388 path = path + strlen(PKG_PARSERLIB);
392 memset(buffer, 0x00, 1024);
399 _LOGE("no matching backendlib\n");
403 snprintf(temp_path, sizeof(temp_path) - 1, "%slib%s.so", path, type);
405 return strdup(temp_path);
408 static int __ps_run_tag_parser(void *lib_handle, xmlDocPtr docPtr, const char *tag,
409 ACTION_TYPE action, const char *pkgid)
411 int (*plugin_install) (xmlDocPtr, const char *);
417 ac = "PKGMGR_PARSER_PLUGIN_INSTALL";
420 ac = "PKGMGR_PARSER_PLUGIN_UPGRADE";
422 case ACTION_UNINSTALL:
423 ac = "PKGMGR_PARSER_PLUGIN_UNINSTALL";
429 if ((plugin_install =
430 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
431 _LOGE("can not find symbol[%s] \n", ac);
435 ret = plugin_install(docPtr, pkgid);
436 _LOGD("tag parser[%s, %s] ACTION_TYPE[%d] result[%d]\n", pkgid, tag, action, ret);
442 static int __ps_run_metadata_parser(GList *md_list, const char *tag,
443 ACTION_TYPE action, const char *pkgid, const char *appid)
445 char *lib_path = NULL;
446 void *lib_handle = NULL;
447 int (*metadata_parser_plugin) (const char *, const char *, GList *);
453 ac = "PKGMGR_MDPARSER_PLUGIN_INSTALL";
456 ac = "PKGMGR_MDPARSER_PLUGIN_UPGRADE";
458 case ACTION_UNINSTALL:
459 ac = "PKGMGR_MDPARSER_PLUGIN_UNINSTALL";
465 lib_path = __get_metadata_parser_plugin(tag);
467 _LOGE("get %s parser fail\n", tag);
471 if ((lib_handle = dlopen(lib_path, RTLD_LAZY)) == NULL) {
472 _LOGE("dlopen is failed lib_path[%s]\n", lib_path);
476 if ((metadata_parser_plugin =
477 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
478 _LOGE("can not find symbol[%s] \n",ac);
482 ret = metadata_parser_plugin(pkgid, appid, md_list);
484 _LOGD("[appid = %s, libpath = %s plugin fail\n", appid, lib_path);
486 _LOGD("[appid = %s, libpath = %s plugin success\n", appid, lib_path);
496 static int __ps_run_category_parser(GList *category_list, const char *tag,
497 ACTION_TYPE action, const char *pkgid, const char *appid)
499 char *lib_path = NULL;
500 void *lib_handle = NULL;
501 int (*category_parser_plugin) (const char *, const char *, GList *);
507 ac = "PKGMGR_CATEGORY_PARSER_PLUGIN_INSTALL";
510 ac = "PKGMGR_CATEGORY_PARSER_PLUGIN_UPGRADE";
512 case ACTION_UNINSTALL:
513 ac = "PKGMGR_CATEGORY_PARSER_PLUGIN_UNINSTALL";
519 lib_path = __get_category_parser_plugin(tag);
521 _LOGE("get %s parser fail\n", tag);
525 if ((lib_handle = dlopen(lib_path, RTLD_LAZY)) == NULL) {
526 _LOGE("dlopen is failed lib_path[%s]\n", lib_path);
530 if ((category_parser_plugin =
531 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
532 _LOGE("can not find symbol[%s] \n",ac);
536 ret = category_parser_plugin(pkgid, appid, category_list);
538 _LOGD("[appid = %s, libpath = %s plugin fail\n", appid, lib_path);
540 _LOGD("[appid = %s, libpath = %s plugin success\n", appid, lib_path);
550 static int __ps_run_parser(xmlDocPtr docPtr, const char *tag,
551 ACTION_TYPE action, const char *pkgid)
553 char *lib_path = NULL;
554 void *lib_handle = NULL;
555 int (*plugin_install) (xmlDocPtr, const char *);
561 ac = "PKGMGR_PARSER_PLUGIN_INSTALL";
564 ac = "PKGMGR_PARSER_PLUGIN_UPGRADE";
566 case ACTION_UNINSTALL:
567 ac = "PKGMGR_PARSER_PLUGIN_UNINSTALL";
573 lib_path = __get_parser_plugin(tag);
578 if ((lib_handle = dlopen(lib_path, RTLD_LAZY)) == NULL) {
579 _LOGE("dlopen is failed lib_path[%s]\n", lib_path);
582 if ((plugin_install =
583 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
584 _LOGE("can not find symbol[%s] \n", ac);
588 ret = plugin_install(docPtr, pkgid);
590 _LOGD("[pkgid = %s, libpath = %s plugin fail\n", pkgid, lib_path);
592 _LOGD("[pkgid = %s, libpath = %s plugin success\n", pkgid, lib_path);
602 static char *__pkgid_to_manifest(const char *pkgid, uid_t uid)
608 _LOGE("pkgid is NULL");
612 size = strlen(getUserManifestPath(uid)) + strlen(pkgid) + 10;
613 manifest = malloc(size);
614 if (manifest == NULL) {
618 memset(manifest, '\0', size);
619 snprintf(manifest, size, "%s%s.xml", getUserManifestPath(uid), pkgid);
621 if (access(manifest, F_OK)) {
622 snprintf(manifest, size, "%s%s.xml", getUserManifestPath(uid), pkgid);
628 static void __metadata_parser_clear_dir_list(GList* dir_list)
631 __metadata_t* detail = NULL;
634 list = g_list_first(dir_list);
636 detail = (__metadata_t *)list->data;
639 free((void *)detail->key);
641 free((void *)detail->value);
644 list = g_list_next(list);
646 g_list_free(dir_list);
650 static void __category_parser_clear_dir_list(GList* dir_list)
653 __category_t* detail = NULL;
656 list = g_list_first(dir_list);
658 detail = (__category_t *)list->data;
661 free((void *)detail->name);
665 list = g_list_next(list);
667 g_list_free(dir_list);
671 static int __run_tag_parser_prestep(void *lib_handle, xmlTextReaderPtr reader, ACTION_TYPE action, const char *pkgid)
676 if (xmlTextReaderDepth(reader) != 1) {
677 _LOGE("Node depth is not 1");
681 if (xmlTextReaderNodeType(reader) != 1) {
682 _LOGE("Node type is not 1");
686 const xmlChar *value;
687 name = xmlTextReaderConstName(reader);
689 _LOGE("TEST TEST TES\n");
690 name = BAD_CAST "--";
693 value = xmlTextReaderConstValue(reader);
695 if (xmlStrlen(value) > 40) {
696 _LOGD(" %.40s...", value);
702 name = xmlTextReaderConstName(reader);
704 _LOGE("TEST TEST TES\n");
705 name = BAD_CAST "--";
708 xmlDocPtr docPtr = xmlTextReaderCurrentDoc(reader);
709 xmlDocPtr copyDocPtr = xmlCopyDoc(docPtr, 1);
710 if (copyDocPtr == NULL)
712 xmlNode *rootElement = xmlDocGetRootElement(copyDocPtr);
713 if (rootElement == NULL)
715 xmlNode *cur_node = xmlFirstElementChild(rootElement);
716 if (cur_node == NULL)
718 xmlNode *temp = xmlTextReaderExpand(reader);
721 xmlNode *next_node = NULL;
722 while(cur_node != NULL) {
723 if ( (strcmp(ASCII(temp->name), ASCII(cur_node->name)) == 0) &&
724 (temp->line == cur_node->line) ) {
728 next_node = xmlNextElementSibling(cur_node);
729 xmlUnlinkNode(cur_node);
730 xmlFreeNode(cur_node);
731 cur_node = next_node;
734 if (cur_node == NULL)
736 next_node = xmlNextElementSibling(cur_node);
738 cur_node->next = NULL;
739 next_node->prev = NULL;
740 xmlFreeNodeList(next_node);
741 xmlSetTreeDoc(cur_node, copyDocPtr);
743 xmlSetTreeDoc(cur_node, copyDocPtr);
746 ret = __ps_run_tag_parser(lib_handle, copyDocPtr, ASCII(name), action, pkgid);
752 static int __run_metadata_parser_prestep (manifest_x *mfx, char *md_key, ACTION_TYPE action)
756 char buffer[1024] = { 0, };
757 uiapplication_x *up = mfx->uiapplication;
758 metadata_x *md = NULL;
761 GList *md_list = NULL;
762 __metadata_t *md_detail = NULL;
764 md_tag = __get_tag_by_key(md_key);
765 if (md_tag == NULL) {
766 _LOGD("md_tag is NULL\n");
773 //get glist of metadata key and value combination
774 memset(buffer, 0x00, 1024);
775 snprintf(buffer, 1024, "%s/", md_key);
776 if ((md->key && md->value) && (strncmp(md->key, md_key, strlen(md_key)) == 0) && (strncmp(buffer, md->key, strlen(buffer)) == 0)) {
777 md_detail = (__metadata_t*) calloc(1, sizeof(__metadata_t));
778 if (md_detail == NULL) {
779 _LOGD("Memory allocation failed\n");
783 md_detail->key = strdup(md->key);
784 if (md_detail->key == NULL) {
785 _LOGD("Memory allocation failed\n");
790 md_detail->value = strdup(md->value);
791 if (md_detail->value == NULL) {
792 _LOGD("Memory allocation failed\n");
793 free((void *)md_detail->key);
798 md_list = g_list_append(md_list, (gpointer)md_detail);
804 //send glist to parser when tags for metadata plugin parser exist.
806 ret = __ps_run_metadata_parser(md_list, md_tag, action, mfx->package, up->appid);
808 _LOGD("metadata_parser failed[%d] for tag[%s]\n", ret, md_tag);
811 _LOGD("metadata_parser success for tag[%s]\n", md_tag);
814 __metadata_parser_clear_dir_list(md_list);
822 __metadata_parser_clear_dir_list(md_list);
830 static int __run_category_parser_prestep (manifest_x *mfx, char *category_key, ACTION_TYPE action)
834 char buffer[1024] = { 0, };
835 uiapplication_x *up = mfx->uiapplication;
836 category_x *category = NULL;
837 char *category_tag = NULL;
839 GList *category_list = NULL;
840 __category_t *category_detail = NULL;
842 category_tag = __get_tag_by_key(category_key);
843 if (category_tag == NULL) {
844 _LOGD("md_tag is NULL\n");
849 category = up->category;
850 while (category != NULL) {
851 //get glist of category key and value combination
852 memset(buffer, 0x00, 1024);
853 snprintf(buffer, 1024, "%s/", category_key);
854 if ((category->name) && (strncmp(category->name, category_key, strlen(category_key)) == 0)) {
855 category_detail = (__category_t*) calloc(1, sizeof(__category_t));
856 if (category_detail == NULL) {
857 _LOGD("Memory allocation failed\n");
861 category_detail->name = strdup(category->name);
862 if (category_detail->name == NULL) {
863 _LOGD("Memory allocation failed\n");
864 free(category_detail);
868 category_list = g_list_append(category_list, (gpointer)category_detail);
871 category = category->next;
874 //send glist to parser when tags for metadata plugin parser exist.
876 ret = __ps_run_category_parser(category_list, category_tag, action, mfx->package, up->appid);
878 _LOGD("category_parser failed[%d] for tag[%s]\n", ret, category_tag);
880 _LOGD("category_parser success for tag[%s]\n", category_tag);
882 __category_parser_clear_dir_list(category_list);
883 category_list = NULL;
890 __category_parser_clear_dir_list(category_list);
898 static void __process_tag(void *lib_handle, xmlTextReaderPtr reader, ACTION_TYPE action, char *tag, const char *pkgid)
900 switch (xmlTextReaderNodeType(reader)) {
901 case XML_READER_TYPE_END_ELEMENT:
905 case XML_READER_TYPE_ELEMENT:
907 // Elements without closing tag don't receive
908 const xmlChar *elementName =
909 xmlTextReaderLocalName(reader);
910 if (elementName == NULL) {
914 if (strcmp(tag, ASCII(elementName)) == 0) {
915 _LOGD("find : tag[%s] ACTION_TYPE[%d] pkg[%s]\n", tag, action, pkgid);
916 __run_tag_parser_prestep(lib_handle, reader, action, pkgid);
927 static int __parser_send_tag(void *lib_handle, ACTION_TYPE action, PLUGIN_PROCESS_TYPE process, const char *pkgid)
929 int (*plugin_install) (const char *);
933 if (process == PLUGIN_PRE_PROCESS) {
936 ac = "PKGMGR_PARSER_PLUGIN_PRE_INSTALL";
939 ac = "PKGMGR_PARSER_PLUGIN_PRE_UPGRADE";
941 case ACTION_UNINSTALL:
942 ac = "PKGMGR_PARSER_PLUGIN_PRE_UNINSTALL";
947 } else if (process == PLUGIN_POST_PROCESS) {
950 ac = "PKGMGR_PARSER_PLUGIN_POST_INSTALL";
953 ac = "PKGMGR_PARSER_PLUGIN_POST_UPGRADE";
955 case ACTION_UNINSTALL:
956 ac = "PKGMGR_PARSER_PLUGIN_POST_UNINSTALL";
964 if ((plugin_install =
965 dlsym(lib_handle, ac)) == NULL || dlerror() != NULL) {
969 ret = plugin_install(pkgid);
973 static int __next_child_element(xmlTextReaderPtr reader, int depth)
975 int ret = xmlTextReaderRead(reader);
976 int cur = xmlTextReaderDepth(reader);
979 switch (xmlTextReaderNodeType(reader)) {
980 case XML_READER_TYPE_ELEMENT:
981 if (cur == depth + 1)
984 case XML_READER_TYPE_TEXT:
985 /*text is handled by each function separately*/
986 if (cur == depth + 1)
989 case XML_READER_TYPE_END_ELEMENT:
998 ret = xmlTextReaderRead(reader);
999 cur = xmlTextReaderDepth(reader);
1003 int __ps_process_tag_parser(manifest_x *mfx, const char *filename, ACTION_TYPE action)
1005 xmlTextReaderPtr reader;
1009 void *lib_handle = NULL;
1010 char tag[PKG_STRING_LEN_MAX] = { 0 };
1012 fp = fopen(TAG_PARSER_LIST, "r");
1013 retvm_if(fp == NULL, PMINFO_R_ERROR, "no preload list");
1015 while (fgets(tag, sizeof(tag), fp) != NULL) {
1018 lib_handle = __open_lib_handle(tag);
1019 if (lib_handle == NULL)
1022 ret = __parser_send_tag(lib_handle, action, PLUGIN_PRE_PROCESS, mfx->package);
1023 _LOGD("PLUGIN_PRE_PROCESS[%s, %s] ACTION_TYPE[%d] result[%d]\n", mfx->package, tag, action, ret);
1025 docPtr = xmlReadFile(filename, NULL, 0);
1026 reader = xmlReaderWalker(docPtr);
1027 if (reader != NULL) {
1028 ret = xmlTextReaderRead(reader);
1030 __process_tag(lib_handle, reader, action, tag, mfx->package);
1031 ret = xmlTextReaderRead(reader);
1033 xmlFreeTextReader(reader);
1036 _LOGD("%s : failed to parse", filename);
1039 _LOGD("Unable to open %s", filename);
1042 ret = __parser_send_tag(lib_handle, action, PLUGIN_POST_PROCESS, mfx->package);
1043 _LOGD("PLUGIN_POST_PROCESS[%s, %s] ACTION_TYPE[%d] result[%d]\n", mfx->package, tag, action, ret);
1045 __close_lib_handle(lib_handle);
1047 memset(tag, 0x00, sizeof(tag));
1056 int __ps_process_metadata_parser(manifest_x *mfx, ACTION_TYPE action)
1058 fprintf(stdout,"__ps_process_metadata_parser\n");
1061 char md_key[PKG_STRING_LEN_MAX] = { 0 };
1063 fp = fopen(METADATA_PARSER_LIST, "r");
1065 _LOGD("no preload list\n");
1069 while (fgets(md_key, sizeof(md_key), fp) != NULL) {
1071 ret = __run_metadata_parser_prestep(mfx, md_key, action);
1082 int __ps_process_category_parser(manifest_x *mfx, ACTION_TYPE action)
1086 char category_key[PKG_STRING_LEN_MAX] = { 0 };
1088 fp = fopen(CATEGORY_PARSER_LIST, "r");
1090 _LOGD("no category parser list\n");
1094 while (fgets(category_key, sizeof(category_key), fp) != NULL) {
1095 __str_trim(category_key);
1096 ret = __run_category_parser_prestep(mfx, category_key, action);
1107 static int __ps_process_allowed(xmlTextReaderPtr reader, allowed_x *allowed)
1109 __save_xml_value(reader, &allowed->text);
1113 static int __ps_process_operation(xmlTextReaderPtr reader, operation_x *operation)
1115 __save_xml_attribute(reader, "name", &operation->name, NULL);
1119 static int __ps_process_uri(xmlTextReaderPtr reader, uri_x *uri)
1121 __save_xml_attribute(reader, "name", &uri->name, NULL);
1125 static int __ps_process_mime(xmlTextReaderPtr reader, mime_x *mime)
1127 __save_xml_attribute(reader, "name", &mime->name, NULL);
1131 static int __ps_process_subapp(xmlTextReaderPtr reader, subapp_x *subapp)
1133 __save_xml_attribute(reader, "name", &subapp->name, NULL);
1137 static int __ps_process_condition(xmlTextReaderPtr reader, condition_x *condition)
1139 __save_xml_attribute(reader, "name", &condition->name, NULL);
1143 static int __ps_process_notification(xmlTextReaderPtr reader, notification_x *notification)
1145 __save_xml_attribute(reader, "name", ¬ification->name, NULL);
1146 __save_xml_value(reader, ¬ification->text);
1150 static int __ps_process_category(xmlTextReaderPtr reader, category_x *category)
1152 __save_xml_attribute(reader, "name", &category->name, NULL);
1156 static int __ps_process_privilege(xmlTextReaderPtr reader, privilege_x *privilege)
1158 __save_xml_value(reader, &privilege->text);
1162 static int __ps_process_metadata(xmlTextReaderPtr reader, metadata_x *metadata)
1164 __save_xml_attribute(reader, "key", &metadata->key, NULL);
1165 __save_xml_attribute(reader, "value", &metadata->value, NULL);
1169 static int __ps_process_permission(xmlTextReaderPtr reader, permission_x *permission)
1171 __save_xml_attribute(reader, "type", &permission->type, NULL);
1172 __save_xml_value(reader, &permission->value);
1176 static int __ps_process_compatibility(xmlTextReaderPtr reader, compatibility_x *compatibility)
1178 __save_xml_attribute(reader, "name", &compatibility->name, NULL);
1179 __save_xml_value(reader, &compatibility->text);
1183 static int __ps_process_request(xmlTextReaderPtr reader, request_x *request)
1185 __save_xml_value(reader, &request->text);
1189 static int __ps_process_define(xmlTextReaderPtr reader, define_x *define)
1191 const xmlChar *node;
1194 allowed_x *tmp1 = NULL;
1195 request_x *tmp2 = NULL;
1197 __save_xml_attribute(reader, "path", &define->path, NULL);
1199 depth = xmlTextReaderDepth(reader);
1200 while ((ret = __next_child_element(reader, depth))) {
1201 node = xmlTextReaderConstName(reader);
1203 _LOGD("xmlTextReaderConstName value is NULL\n");
1207 if (!strcmp(ASCII(node), "allowed")) {
1208 allowed_x *allowed= malloc(sizeof(allowed_x));
1209 if (allowed == NULL) {
1210 _LOGD("Malloc Failed\n");
1213 memset(allowed, '\0', sizeof(allowed_x));
1214 LISTADD(define->allowed, allowed);
1215 ret = __ps_process_allowed(reader, allowed);
1216 } else if (!strcmp(ASCII(node), "request")) {
1217 request_x *request = malloc(sizeof(request_x));
1218 if (request == NULL) {
1219 _LOGD("Malloc Failed\n");
1222 memset(request, '\0', sizeof(request_x));
1223 LISTADD(define->request, request);
1224 ret = __ps_process_request(reader, request);
1228 _LOGD("Processing define failed\n");
1232 if (define->allowed) {
1233 LISTHEAD(define->allowed, tmp1);
1234 define->allowed = tmp1;
1236 if (define->request) {
1237 LISTHEAD(define->request, tmp2);
1238 define->request = tmp2;
1243 static int __ps_process_appcontrol(xmlTextReaderPtr reader, appcontrol_x *appcontrol)
1245 const xmlChar *node;
1249 depth = xmlTextReaderDepth(reader);
1250 while ((ret = __next_child_element(reader, depth))) {
1251 node = xmlTextReaderConstName(reader);
1253 _LOGD("xmlTextReaderConstName value is NULL\n");
1257 if (!strcmp(ASCII(node), "operation")) {
1258 __save_xml_attribute(reader, "name", &appcontrol->operation, NULL);
1259 _LOGD("operation processing\n");
1260 } else if (!strcmp(ASCII(node), "uri")) {
1261 __save_xml_attribute(reader, "name", &appcontrol->uri, NULL);
1262 _LOGD("uri processing\n");
1263 } else if (!strcmp(ASCII(node), "mime")) {
1264 __save_xml_attribute(reader, "name", &appcontrol->mime, NULL);
1265 _LOGD("mime processing\n");
1269 _LOGD("Processing appcontrol failed\n");
1277 static int __ps_process_appsvc(xmlTextReaderPtr reader, appsvc_x *appsvc)
1279 const xmlChar *node;
1282 operation_x *tmp1 = NULL;
1284 mime_x *tmp3 = NULL;
1285 subapp_x *tmp4 = NULL;
1287 depth = xmlTextReaderDepth(reader);
1288 while ((ret = __next_child_element(reader, depth))) {
1289 node = xmlTextReaderConstName(reader);
1291 _LOGD("xmlTextReaderConstName value is NULL\n");
1295 if (!strcmp(ASCII(node), "operation")) {
1296 operation_x *operation = malloc(sizeof(operation_x));
1297 if (operation == NULL) {
1298 _LOGD("Malloc Failed\n");
1301 memset(operation, '\0', sizeof(operation_x));
1302 LISTADD(appsvc->operation, operation);
1303 ret = __ps_process_operation(reader, operation);
1304 _LOGD("operation processing\n");
1305 } else if (!strcmp(ASCII(node), "uri")) {
1306 uri_x *uri= malloc(sizeof(uri_x));
1308 _LOGD("Malloc Failed\n");
1311 memset(uri, '\0', sizeof(uri_x));
1312 LISTADD(appsvc->uri, uri);
1313 ret = __ps_process_uri(reader, uri);
1314 _LOGD("uri processing\n");
1315 } else if (!strcmp(ASCII(node), "mime")) {
1316 mime_x *mime = malloc(sizeof(mime_x));
1318 _LOGD("Malloc Failed\n");
1321 memset(mime, '\0', sizeof(mime_x));
1322 LISTADD(appsvc->mime, mime);
1323 ret = __ps_process_mime(reader, mime);
1324 _LOGD("mime processing\n");
1325 } else if (!strcmp(ASCII(node), "subapp")) {
1326 subapp_x *subapp = malloc(sizeof(subapp_x));
1327 if (subapp == NULL) {
1328 _LOGD("Malloc Failed\n");
1331 memset(subapp, '\0', sizeof(subapp_x));
1332 LISTADD(appsvc->subapp, subapp);
1333 ret = __ps_process_subapp(reader, subapp);
1334 _LOGD("subapp processing\n");
1338 _LOGD("Processing appsvc failed\n");
1342 if (appsvc->operation) {
1343 LISTHEAD(appsvc->operation, tmp1);
1344 appsvc->operation = tmp1;
1347 LISTHEAD(appsvc->uri, tmp2);
1351 LISTHEAD(appsvc->mime, tmp3);
1352 appsvc->mime = tmp3;
1354 if (appsvc->subapp) {
1355 LISTHEAD(appsvc->subapp, tmp4);
1356 appsvc->subapp = tmp4;
1359 xmlTextReaderRead(reader);
1360 if (xmlTextReaderValue(reader))
1361 appsvc->text = ASCII(xmlTextReaderValue(reader));
1367 static int __ps_process_privileges(xmlTextReaderPtr reader, privileges_x *privileges)
1369 const xmlChar *node;
1372 privilege_x *tmp1 = NULL;
1374 depth = xmlTextReaderDepth(reader);
1375 while ((ret = __next_child_element(reader, depth))) {
1376 node = xmlTextReaderConstName(reader);
1378 _LOGD("xmlTextReaderConstName value is NULL\n");
1382 if (strcmp(ASCII(node), "privilege") == 0) {
1383 privilege_x *privilege = malloc(sizeof(privilege_x));
1384 if (privilege == NULL) {
1385 _LOGD("Malloc Failed\n");
1388 memset(privilege, '\0', sizeof(privilege_x));
1389 LISTADD(privileges->privilege, privilege);
1390 ret = __ps_process_privilege(reader, privilege);
1394 _LOGD("Processing privileges failed\n");
1398 if (privileges->privilege) {
1399 LISTHEAD(privileges->privilege, tmp1);
1400 privileges->privilege = tmp1;
1405 static int __ps_process_launchconditions(xmlTextReaderPtr reader, launchconditions_x *launchconditions)
1407 const xmlChar *node;
1410 condition_x *tmp1 = NULL;
1412 depth = xmlTextReaderDepth(reader);
1413 while ((ret = __next_child_element(reader, depth))) {
1414 node = xmlTextReaderConstName(reader);
1416 _LOGD("xmlTextReaderConstName value is NULL\n");
1420 if (strcmp(ASCII(node), "condition") == 0) {
1421 condition_x *condition = malloc(sizeof(condition_x));
1422 if (condition == NULL) {
1423 _LOGD("Malloc Failed\n");
1426 memset(condition, '\0', sizeof(condition_x));
1427 LISTADD(launchconditions->condition, condition);
1428 ret = __ps_process_condition(reader, condition);
1432 _LOGD("Processing launchconditions failed\n");
1436 if (launchconditions->condition) {
1437 LISTHEAD(launchconditions->condition, tmp1);
1438 launchconditions->condition = tmp1;
1441 __save_xml_value(reader, &launchconditions->text);
1446 static int __ps_process_datashare(xmlTextReaderPtr reader, datashare_x *datashare)
1448 const xmlChar *node;
1451 define_x *tmp1 = NULL;
1452 request_x *tmp2 = NULL;
1453 depth = xmlTextReaderDepth(reader);
1454 while ((ret = __next_child_element(reader, depth))) {
1455 node = xmlTextReaderConstName(reader);
1457 _LOGD("xmlTextReaderConstName value is NULL\n");
1461 if (!strcmp(ASCII(node), "define")) {
1462 define_x *define= malloc(sizeof(define_x));
1463 if (define == NULL) {
1464 _LOGD("Malloc Failed\n");
1467 memset(define, '\0', sizeof(define_x));
1468 LISTADD(datashare->define, define);
1469 ret = __ps_process_define(reader, define);
1470 } else if (!strcmp(ASCII(node), "request")) {
1471 request_x *request= malloc(sizeof(request_x));
1472 if (request == NULL) {
1473 _LOGD("Malloc Failed\n");
1476 memset(request, '\0', sizeof(request_x));
1477 LISTADD(datashare->request, request);
1478 ret = __ps_process_request(reader, request);
1482 _LOGD("Processing data-share failed\n");
1486 if (datashare->define) {
1487 LISTHEAD(datashare->define, tmp1);
1488 datashare->define = tmp1;
1490 if (datashare->request) {
1491 LISTHEAD(datashare->request, tmp2);
1492 datashare->request = tmp2;
1497 static char *__get_icon_with_path(const char *icon, uid_t uid)
1499 char icon_with_path[BUFSIZE];
1500 const char *app_path;
1502 if (!icon || !package)
1505 /* just use absolute path */
1506 if (index(icon, '/'))
1507 return strdup(icon);
1510 snprintf(icon_with_path, sizeof(icon_with_path), "%s%s",
1511 getIconPath(uid), icon);
1512 if (access(icon_with_path, F_OK) == 0)
1515 /* for backward compatibility (.../default/small/...)
1516 * this should be removed
1518 snprintf(icon_with_path, sizeof(icon_with_path),
1519 "%sdefault/small/%s",
1520 getIconPath(uid), icon);
1521 if (access(icon_with_path, F_OK) == 0)
1524 if (uid == GLOBAL_USER || uid == OWNER_ROOT) {
1525 app_path = tzplatform_getenv(TZ_SYS_RW_APP);
1527 tzplatform_set_user(uid);
1528 app_path = tzplatform_getenv(TZ_USER_APP);
1529 tzplatform_reset_user();
1532 /* If doesn't exist in case of Global app,
1533 * try to get icon directly into app's directory
1535 snprintf(icon_with_path, sizeof(icon_with_path),
1536 "%s/%s/%s", app_path, package, icon);
1537 if (access(icon_with_path, F_OK) == 0)
1540 /* some preload package has icons at below path */
1541 snprintf(icon_with_path, sizeof(icon_with_path),
1542 "%s/%s/res/icons/%s", app_path, package, icon);
1543 if (access(icon_with_path, F_OK) == 0)
1546 /* since 2.3 tpk package */
1547 snprintf(icon_with_path, sizeof(icon_with_path),
1548 "%s/%s/shared/res/%s", app_path, package, icon);
1549 if (access(icon_with_path, F_OK) == 0)
1552 _LOGE("cannot find icon path for [%s]", icon);
1556 _LOGD("Icon path : %s ---> %s", icon, icon_with_path);
1558 return strdup(icon_with_path);
1561 static void __ps_process_tag(manifest_x * mfx, char *const tagv[])
1564 char delims[] = "=";
1565 char *ret_result = NULL;
1571 for (tag = strdup(tagv[0]); tag != NULL; ) {
1572 ret_result = strtok(tag, delims);
1574 /*check tag : preload */
1575 if (strcmp(ret_result, "preload") == 0) {
1576 ret_result = strtok(NULL, delims);
1577 if (strcmp(ret_result, "true") == 0) {
1578 free((void *)mfx->preload);
1579 mfx->preload = strdup("true");
1580 } else if (strcmp(ret_result, "false") == 0) {
1581 free((void *)mfx->preload);
1582 mfx->preload = strdup("false");
1584 /*check tag : removable*/
1585 } else if (strcmp(ret_result, "removable") == 0) {
1586 ret_result = strtok(NULL, delims);
1587 if (strcmp(ret_result, "true") == 0){
1588 free((void *)mfx->removable);
1589 mfx->removable = strdup("true");
1590 } else if (strcmp(ret_result, "false") == 0) {
1591 free((void *)mfx->removable);
1592 mfx->removable = strdup("false");
1594 /*check tag : not matched*/
1596 _LOGD("tag process [%s]is not defined\n", ret_result);
1600 /*check next value*/
1601 if (tagv[++i] != NULL)
1602 tag = strdup(tagv[i]);
1604 _LOGD("tag process success...\n");
1610 static int __ps_process_icon(xmlTextReaderPtr reader, icon_x *icon, uid_t uid)
1612 __save_xml_attribute(reader, "name", &icon->name, NULL);
1613 __save_xml_attribute(reader, "section", &icon->section, NULL);
1614 __save_xml_attribute(reader, "size", &icon->size, NULL);
1615 __save_xml_attribute(reader, "resolution", &icon->resolution, NULL);
1616 __save_xml_lang(reader, &icon->lang);
1618 xmlTextReaderRead(reader);
1619 const char *text = ASCII(xmlTextReaderValue(reader));
1621 icon->text = (const char *)__get_icon_with_path(text, uid);
1628 static int __ps_process_image(xmlTextReaderPtr reader, image_x *image)
1630 __save_xml_attribute(reader, "name", &image->name, NULL);
1631 __save_xml_attribute(reader, "section", &image->section, NULL);
1632 __save_xml_lang(reader, &image->lang);
1633 __save_xml_value(reader, &image->text);
1637 static int __ps_process_label(xmlTextReaderPtr reader, label_x *label)
1639 __save_xml_attribute(reader, "name", &label->name, NULL);
1640 __save_xml_lang(reader, &label->lang);
1641 __save_xml_value(reader, &label->text);
1646 static int __ps_process_author(xmlTextReaderPtr reader, author_x *author)
1648 __save_xml_attribute(reader, "email", &author->email, NULL);
1649 __save_xml_attribute(reader, "href", &author->href, NULL);
1650 __save_xml_lang(reader, &author->lang);
1651 __save_xml_value(reader, &author->text);
1655 static int __ps_process_description(xmlTextReaderPtr reader, description_x *description)
1657 __save_xml_lang(reader, &description->lang);
1658 __save_xml_value(reader, &description->text);
1662 static int __ps_process_license(xmlTextReaderPtr reader, license_x *license)
1664 __save_xml_lang(reader, &license->lang);
1665 __save_xml_value(reader, &license->text);
1669 static int __ps_process_datacontrol(xmlTextReaderPtr reader, datacontrol_x *datacontrol)
1671 __save_xml_attribute(reader, "providerid", &datacontrol->providerid, NULL);
1672 __save_xml_attribute(reader, "access", &datacontrol->access, NULL);
1673 __save_xml_attribute(reader, "type", &datacontrol->type, NULL);
1677 static int __ps_process_uiapplication(xmlTextReaderPtr reader, uiapplication_x *uiapplication, uid_t uid)
1679 const xmlChar *node;
1682 label_x *tmp1 = NULL;
1683 icon_x *tmp2 = NULL;
1684 appsvc_x *tmp3 = NULL;
1685 appcontrol_x *tmp4 = NULL;
1686 launchconditions_x *tmp5 = NULL;
1687 notification_x *tmp6 = NULL;
1688 datashare_x *tmp7 = NULL;
1689 category_x *tmp8 = NULL;
1690 metadata_x *tmp9 = NULL;
1691 image_x *tmp10 = NULL;
1692 permission_x *tmp11 = NULL;
1693 datacontrol_x *tmp12 = NULL;
1695 __save_xml_attribute(reader, "appid", &uiapplication->appid, NULL);
1696 retvm_if(uiapplication->appid == NULL, PM_PARSER_R_ERROR, "appid cant be NULL, appid field is mandatory\n");
1697 __save_xml_attribute(reader, "exec", &uiapplication->exec, NULL);
1698 __save_xml_attribute(reader, "nodisplay", &uiapplication->nodisplay, "false");
1699 __save_xml_attribute(reader, "multiple", &uiapplication->multiple, "false");
1700 __save_xml_attribute(reader, "type", &uiapplication->type, NULL);
1701 __save_xml_attribute(reader, "categories", &uiapplication->categories, NULL);
1702 __save_xml_attribute(reader, "extraid", &uiapplication->extraid, NULL);
1703 __save_xml_attribute(reader, "taskmanage", &uiapplication->taskmanage, "true");
1704 __save_xml_attribute(reader, "enabled", &uiapplication->enabled, "true");
1705 __save_xml_attribute(reader, "hw-acceleration", &uiapplication->hwacceleration, "default");
1706 __save_xml_attribute(reader, "screen-reader", &uiapplication->screenreader, "use-system-setting");
1707 __save_xml_attribute(reader, "mainapp", &uiapplication->mainapp, "false");
1708 __save_xml_attribute(reader, "recentimage", &uiapplication->recentimage, "false");
1709 __save_xml_attribute(reader, "launchcondition", &uiapplication->launchcondition, "false");
1710 __save_xml_attribute(reader, "indicatordisplay", &uiapplication->indicatordisplay, "true");
1711 __save_xml_attribute(reader, "portrait-effectimage", &uiapplication->portraitimg, NULL);
1712 __save_xml_attribute(reader, "landscape-effectimage", &uiapplication->landscapeimg, NULL);
1713 __save_xml_attribute(reader, "guestmode-visibility", &uiapplication->guestmode_visibility, "true");
1714 __save_xml_attribute(reader, "permission-type", &uiapplication->permission_type, "normal");
1715 __save_xml_attribute(reader, "component-type", &uiapplication->component_type, "uiapp");
1716 /*component_type has "svcapp" or "uiapp", if it is not, parsing manifest is fail*/
1717 retvm_if(((strcmp(uiapplication->component_type, "svcapp") != 0) && (strcmp(uiapplication->component_type, "uiapp") != 0) && (strcmp(uiapplication->component_type, "widgetapp") != 0)), PM_PARSER_R_ERROR, "invalid component_type[%s]\n", uiapplication->component_type);
1718 __save_xml_attribute(reader, "submode", &uiapplication->submode, "false");
1719 __save_xml_attribute(reader, "submode-mainid", &uiapplication->submode_mainid, NULL);
1720 __save_xml_attribute(reader, "launch_mode", &uiapplication->launch_mode, "caller");
1721 __save_xml_attribute(reader, "ui-gadget", &uiapplication->ui_gadget, "false");
1723 uiapplication->package= strdup(package);
1725 depth = xmlTextReaderDepth(reader);
1726 while ((ret = __next_child_element(reader, depth))) {
1727 node = xmlTextReaderConstName(reader);
1729 _LOGD("xmlTextReaderConstName value is NULL\n");
1732 if (!strcmp(ASCII(node), "label")) {
1733 label_x *label = malloc(sizeof(label_x));
1734 if (label == NULL) {
1735 _LOGD("Malloc Failed\n");
1738 memset(label, '\0', sizeof(label_x));
1739 LISTADD(uiapplication->label, label);
1740 ret = __ps_process_label(reader, label);
1741 } else if (!strcmp(ASCII(node), "icon")) {
1742 icon_x *icon = malloc(sizeof(icon_x));
1744 _LOGD("Malloc Failed\n");
1747 memset(icon, '\0', sizeof(icon_x));
1748 LISTADD(uiapplication->icon, icon);
1749 ret = __ps_process_icon(reader, icon, uid);
1750 } else if (!strcmp(ASCII(node), "image")) {
1751 image_x *image = malloc(sizeof(image_x));
1752 if (image == NULL) {
1753 _LOGD("Malloc Failed\n");
1756 memset(image, '\0', sizeof(image_x));
1757 LISTADD(uiapplication->image, image);
1758 ret = __ps_process_image(reader, image);
1759 } else if (!strcmp(ASCII(node), "category")) {
1760 category_x *category = malloc(sizeof(category_x));
1761 if (category == NULL) {
1762 _LOGD("Malloc Failed\n");
1765 memset(category, '\0', sizeof(category_x));
1766 LISTADD(uiapplication->category, category);
1767 ret = __ps_process_category(reader, category);
1768 } else if (!strcmp(ASCII(node), "metadata")) {
1769 metadata_x *metadata = malloc(sizeof(metadata_x));
1770 if (metadata == NULL) {
1771 _LOGD("Malloc Failed\n");
1774 memset(metadata, '\0', sizeof(metadata_x));
1775 LISTADD(uiapplication->metadata, metadata);
1776 ret = __ps_process_metadata(reader, metadata);
1777 } else if (!strcmp(ASCII(node), "permission")) {
1778 permission_x *permission = malloc(sizeof(permission_x));
1779 if (permission == NULL) {
1780 _LOGD("Malloc Failed\n");
1783 memset(permission, '\0', sizeof(permission_x));
1784 LISTADD(uiapplication->permission, permission);
1785 ret = __ps_process_permission(reader, permission);
1786 } else if (!strcmp(ASCII(node), "app-control")) {
1787 appcontrol_x *appcontrol = malloc(sizeof(appcontrol_x));
1788 if (appcontrol == NULL) {
1789 _LOGD("Malloc Failed\n");
1792 memset(appcontrol, '\0', sizeof(appcontrol_x));
1793 LISTADD(uiapplication->appcontrol, appcontrol);
1794 ret = __ps_process_appcontrol(reader, appcontrol);
1795 } else if (!strcmp(ASCII(node), "application-service")) {
1796 appsvc_x *appsvc = malloc(sizeof(appsvc_x));
1797 if (appsvc == NULL) {
1798 _LOGD("Malloc Failed\n");
1801 memset(appsvc, '\0', sizeof(appsvc_x));
1802 LISTADD(uiapplication->appsvc, appsvc);
1803 ret = __ps_process_appsvc(reader, appsvc);
1804 } else if (!strcmp(ASCII(node), "data-share")) {
1805 datashare_x *datashare = malloc(sizeof(datashare_x));
1806 if (datashare == NULL) {
1807 _LOGD("Malloc Failed\n");
1810 memset(datashare, '\0', sizeof(datashare_x));
1811 LISTADD(uiapplication->datashare, datashare);
1812 ret = __ps_process_datashare(reader, datashare);
1813 } else if (!strcmp(ASCII(node), "launch-conditions")) {
1814 launchconditions_x *launchconditions = malloc(sizeof(launchconditions_x));
1815 if (launchconditions == NULL) {
1816 _LOGD("Malloc Failed\n");
1819 memset(launchconditions, '\0', sizeof(launchconditions_x));
1820 LISTADD(uiapplication->launchconditions, launchconditions);
1821 ret = __ps_process_launchconditions(reader, launchconditions);
1822 } else if (!strcmp(ASCII(node), "notification")) {
1823 notification_x *notification = malloc(sizeof(notification_x));
1824 if (notification == NULL) {
1825 _LOGD("Malloc Failed\n");
1828 memset(notification, '\0', sizeof(notification_x));
1829 LISTADD(uiapplication->notification, notification);
1830 ret = __ps_process_notification(reader, notification);
1831 } else if (!strcmp(ASCII(node), "datacontrol")) {
1832 datacontrol_x *datacontrol = malloc(sizeof(datacontrol_x));
1833 if (datacontrol == NULL) {
1834 _LOGD("Malloc Failed\n");
1837 memset(datacontrol, '\0', sizeof(datacontrol_x));
1838 LISTADD(uiapplication->datacontrol, datacontrol);
1839 ret = __ps_process_datacontrol(reader, datacontrol);
1843 _LOGD("Processing uiapplication failed\n");
1848 if (uiapplication->label) {
1849 LISTHEAD(uiapplication->label, tmp1);
1850 uiapplication->label = tmp1;
1852 if (uiapplication->icon) {
1853 LISTHEAD(uiapplication->icon, tmp2);
1854 uiapplication->icon = tmp2;
1856 if (uiapplication->appsvc) {
1857 LISTHEAD(uiapplication->appsvc, tmp3);
1858 uiapplication->appsvc = tmp3;
1860 if (uiapplication->appcontrol) {
1861 LISTHEAD(uiapplication->appcontrol, tmp4);
1862 uiapplication->appcontrol = tmp4;
1864 if (uiapplication->launchconditions) {
1865 LISTHEAD(uiapplication->launchconditions, tmp5);
1866 uiapplication->launchconditions = tmp5;
1868 if (uiapplication->notification) {
1869 LISTHEAD(uiapplication->notification, tmp6);
1870 uiapplication->notification = tmp6;
1872 if (uiapplication->datashare) {
1873 LISTHEAD(uiapplication->datashare, tmp7);
1874 uiapplication->datashare = tmp7;
1876 if (uiapplication->category) {
1877 LISTHEAD(uiapplication->category, tmp8);
1878 uiapplication->category = tmp8;
1880 if (uiapplication->metadata) {
1881 LISTHEAD(uiapplication->metadata, tmp9);
1882 uiapplication->metadata = tmp9;
1884 if (uiapplication->image) {
1885 LISTHEAD(uiapplication->image, tmp10);
1886 uiapplication->image = tmp10;
1888 if (uiapplication->permission) {
1889 LISTHEAD(uiapplication->permission, tmp11);
1890 uiapplication->permission = tmp11;
1892 if (uiapplication->datacontrol) {
1893 LISTHEAD(uiapplication->datacontrol, tmp12);
1894 uiapplication->datacontrol = tmp12;
1900 static int __ps_process_serviceapplication(xmlTextReaderPtr reader, serviceapplication_x *serviceapplication, uid_t uid)
1902 const xmlChar *node;
1905 label_x *tmp1 = NULL;
1906 icon_x *tmp2 = NULL;
1907 appsvc_x *tmp3 = NULL;
1908 appcontrol_x *tmp4 = NULL;
1909 datacontrol_x *tmp5 = NULL;
1910 launchconditions_x *tmp6 = NULL;
1911 notification_x *tmp7 = NULL;
1912 datashare_x *tmp8 = NULL;
1913 category_x *tmp9 = NULL;
1914 metadata_x *tmp10 = NULL;
1915 permission_x *tmp11 = NULL;
1917 __save_xml_attribute(reader, "appid", &serviceapplication->appid, NULL);
1918 retvm_if(serviceapplication->appid == NULL, PM_PARSER_R_ERROR, "appid cant be NULL, appid field is mandatory\n");
1919 __save_xml_attribute(reader, "exec", &serviceapplication->exec, NULL);
1920 __save_xml_attribute(reader, "type", &serviceapplication->type, NULL);
1921 __save_xml_attribute(reader, "enabled", &serviceapplication->enabled, "true");
1922 __save_xml_attribute(reader, "permission-type", &serviceapplication->permission_type, "normal");
1923 __save_xml_attribute(reader, "auto-restart", &serviceapplication->autorestart, "false");
1924 __save_xml_attribute(reader, "on-boot", &serviceapplication->onboot, "false");
1926 serviceapplication->package= strdup(package);
1928 depth = xmlTextReaderDepth(reader);
1929 while ((ret = __next_child_element(reader, depth))) {
1930 node = xmlTextReaderConstName(reader);
1932 _LOGD("xmlTextReaderConstName value is NULL\n");
1936 if (!strcmp(ASCII(node), "label")) {
1937 label_x *label = malloc(sizeof(label_x));
1938 if (label == NULL) {
1939 _LOGD("Malloc Failed\n");
1942 memset(label, '\0', sizeof(label_x));
1943 LISTADD(serviceapplication->label, label);
1944 ret = __ps_process_label(reader, label);
1945 } else if (!strcmp(ASCII(node), "icon")) {
1946 icon_x *icon = malloc(sizeof(icon_x));
1948 _LOGD("Malloc Failed\n");
1951 memset(icon, '\0', sizeof(icon_x));
1952 LISTADD(serviceapplication->icon, icon);
1953 ret = __ps_process_icon(reader, icon, uid);
1954 } else if (!strcmp(ASCII(node), "category")) {
1955 category_x *category = malloc(sizeof(category_x));
1956 if (category == NULL) {
1957 _LOGD("Malloc Failed\n");
1960 memset(category, '\0', sizeof(category_x));
1961 LISTADD(serviceapplication->category, category);
1962 ret = __ps_process_category(reader, category);
1963 } else if (!strcmp(ASCII(node), "metadata")) {
1964 metadata_x *metadata = malloc(sizeof(metadata_x));
1965 if (metadata == NULL) {
1966 _LOGD("Malloc Failed\n");
1969 memset(metadata, '\0', sizeof(metadata_x));
1970 LISTADD(serviceapplication->metadata, metadata);
1971 ret = __ps_process_metadata(reader, metadata);
1972 } else if (!strcmp(ASCII(node), "permission")) {
1973 permission_x *permission = malloc(sizeof(permission_x));
1974 if (permission == NULL) {
1975 _LOGD("Malloc Failed\n");
1978 memset(permission, '\0', sizeof(permission_x));
1979 LISTADD(serviceapplication->permission, permission);
1980 ret = __ps_process_permission(reader, permission);
1981 } else if (!strcmp(ASCII(node), "app-control")) {
1982 appcontrol_x *appcontrol = malloc(sizeof(appcontrol_x));
1983 if (appcontrol == NULL) {
1984 _LOGD("Malloc Failed\n");
1987 memset(appcontrol, '\0', sizeof(appcontrol_x));
1988 LISTADD(serviceapplication->appcontrol, appcontrol);
1989 ret = __ps_process_appcontrol(reader, appcontrol);
1990 } else if (!strcmp(ASCII(node), "application-service")) {
1991 appsvc_x *appsvc = malloc(sizeof(appsvc_x));
1992 if (appsvc == NULL) {
1993 _LOGD("Malloc Failed\n");
1996 memset(appsvc, '\0', sizeof(appsvc_x));
1997 LISTADD(serviceapplication->appsvc, appsvc);
1998 ret = __ps_process_appsvc(reader, appsvc);
1999 } else if (!strcmp(ASCII(node), "data-share")) {
2000 datashare_x *datashare = malloc(sizeof(datashare_x));
2001 if (datashare == NULL) {
2002 _LOGD("Malloc Failed\n");
2005 memset(datashare, '\0', sizeof(datashare_x));
2006 LISTADD(serviceapplication->datashare, datashare);
2007 ret = __ps_process_datashare(reader, datashare);
2008 } else if (!strcmp(ASCII(node), "launch-conditions")) {
2009 launchconditions_x *launchconditions = malloc(sizeof(launchconditions_x));
2010 if (launchconditions == NULL) {
2011 _LOGD("Malloc Failed\n");
2014 memset(launchconditions, '\0', sizeof(launchconditions_x));
2015 LISTADD(serviceapplication->launchconditions, launchconditions);
2016 ret = __ps_process_launchconditions(reader, launchconditions);
2017 } else if (!strcmp(ASCII(node), "notification")) {
2018 notification_x *notification = malloc(sizeof(notification_x));
2019 if (notification == NULL) {
2020 _LOGD("Malloc Failed\n");
2023 memset(notification, '\0', sizeof(notification_x));
2024 LISTADD(serviceapplication->notification, notification);
2025 ret = __ps_process_notification(reader, notification);
2026 } else if (!strcmp(ASCII(node), "datacontrol")) {
2027 datacontrol_x *datacontrol = malloc(sizeof(datacontrol_x));
2028 if (datacontrol == NULL) {
2029 _LOGD("Malloc Failed\n");
2032 memset(datacontrol, '\0', sizeof(datacontrol_x));
2033 LISTADD(serviceapplication->datacontrol, datacontrol);
2034 ret = __ps_process_datacontrol(reader, datacontrol);
2038 _LOGD("Processing serviceapplication failed\n");
2043 if (serviceapplication->label) {
2044 LISTHEAD(serviceapplication->label, tmp1);
2045 serviceapplication->label = tmp1;
2047 if (serviceapplication->icon) {
2048 LISTHEAD(serviceapplication->icon, tmp2);
2049 serviceapplication->icon = tmp2;
2051 if (serviceapplication->appsvc) {
2052 LISTHEAD(serviceapplication->appsvc, tmp3);
2053 serviceapplication->appsvc = tmp3;
2055 if (serviceapplication->appcontrol) {
2056 LISTHEAD(serviceapplication->appcontrol, tmp4);
2057 serviceapplication->appcontrol = tmp4;
2059 if (serviceapplication->datacontrol) {
2060 LISTHEAD(serviceapplication->datacontrol, tmp5);
2061 serviceapplication->datacontrol = tmp5;
2063 if (serviceapplication->launchconditions) {
2064 LISTHEAD(serviceapplication->launchconditions, tmp6);
2065 serviceapplication->launchconditions = tmp6;
2067 if (serviceapplication->notification) {
2068 LISTHEAD(serviceapplication->notification, tmp7);
2069 serviceapplication->notification = tmp7;
2071 if (serviceapplication->datashare) {
2072 LISTHEAD(serviceapplication->datashare, tmp8);
2073 serviceapplication->datashare = tmp8;
2075 if (serviceapplication->category) {
2076 LISTHEAD(serviceapplication->category, tmp9);
2077 serviceapplication->category = tmp9;
2079 if (serviceapplication->metadata) {
2080 LISTHEAD(serviceapplication->metadata, tmp10);
2081 serviceapplication->metadata = tmp10;
2083 if (serviceapplication->permission) {
2084 LISTHEAD(serviceapplication->permission, tmp11);
2085 serviceapplication->permission = tmp11;
2091 static int __ps_process_deviceprofile(xmlTextReaderPtr reader, deviceprofile_x *deviceprofile)
2093 /*TODO: once policy is set*/
2097 static int __ps_process_font(xmlTextReaderPtr reader, font_x *font)
2099 /*TODO: once policy is set*/
2103 static int __ps_process_theme(xmlTextReaderPtr reader, theme_x *theme)
2105 /*TODO: once policy is set*/
2109 static int __ps_process_daemon(xmlTextReaderPtr reader, daemon_x *daemon)
2111 /*TODO: once policy is set*/
2115 static int __ps_process_ime(xmlTextReaderPtr reader, ime_x *ime)
2117 /*TODO: once policy is set*/
2121 static int __start_process(xmlTextReaderPtr reader, manifest_x * mfx, uid_t uid)
2123 _LOGD("__start_process\n");
2124 const xmlChar *node;
2127 label_x *tmp1 = NULL;
2128 author_x *tmp2 = NULL;
2129 description_x *tmp3 = NULL;
2130 license_x *tmp4 = NULL;
2131 uiapplication_x *tmp5 = NULL;
2132 serviceapplication_x *tmp6 = NULL;
2133 daemon_x *tmp7 = NULL;
2134 theme_x *tmp8 = NULL;
2135 font_x *tmp9 = NULL;
2136 ime_x *tmp10 = NULL;
2137 icon_x *tmp11 = NULL;
2138 compatibility_x *tmp12 = NULL;
2139 deviceprofile_x *tmp13 = NULL;
2140 privileges_x *tmp14 = NULL;
2142 depth = xmlTextReaderDepth(reader);
2143 while ((ret = __next_child_element(reader, depth))) {
2144 node = xmlTextReaderConstName(reader);
2146 _LOGD("xmlTextReaderConstName value is NULL\n");
2150 if (!strcmp(ASCII(node), "label")) {
2151 label_x *label = malloc(sizeof(label_x));
2152 if (label == NULL) {
2153 _LOGD("Malloc Failed\n");
2156 memset(label, '\0', sizeof(label_x));
2157 LISTADD(mfx->label, label);
2158 ret = __ps_process_label(reader, label);
2159 } else if (!strcmp(ASCII(node), "author")) {
2160 author_x *author = malloc(sizeof(author_x));
2161 if (author == NULL) {
2162 _LOGD("Malloc Failed\n");
2165 memset(author, '\0', sizeof(author_x));
2166 LISTADD(mfx->author, author);
2167 ret = __ps_process_author(reader, author);
2168 } else if (!strcmp(ASCII(node), "description")) {
2169 description_x *description = malloc(sizeof(description_x));
2170 if (description == NULL) {
2171 _LOGD("Malloc Failed\n");
2174 memset(description, '\0', sizeof(description_x));
2175 LISTADD(mfx->description, description);
2176 ret = __ps_process_description(reader, description);
2177 } else if (!strcmp(ASCII(node), "license")) {
2178 license_x *license = malloc(sizeof(license_x));
2179 if (license == NULL) {
2180 _LOGD("Malloc Failed\n");
2183 memset(license, '\0', sizeof(license_x));
2184 LISTADD(mfx->license, license);
2185 ret = __ps_process_license(reader, license);
2186 } else if (!strcmp(ASCII(node), "privileges")) {
2187 privileges_x *privileges = malloc(sizeof(privileges_x));
2188 if (privileges == NULL) {
2189 _LOGD("Malloc Failed\n");
2192 memset(privileges, '\0', sizeof(privileges_x));
2193 LISTADD(mfx->privileges, privileges);
2194 ret = __ps_process_privileges(reader, privileges);
2195 } else if (!strcmp(ASCII(node), "ui-application")) {
2196 uiapplication_x *uiapplication = malloc(sizeof(uiapplication_x));
2197 if (uiapplication == NULL) {
2198 _LOGD("Malloc Failed\n");
2201 memset(uiapplication, '\0', sizeof(uiapplication_x));
2202 LISTADD(mfx->uiapplication, uiapplication);
2203 ret = __ps_process_uiapplication(reader, uiapplication, uid);
2204 } else if (!strcmp(ASCII(node), "service-application")) {
2205 serviceapplication_x *serviceapplication = malloc(sizeof(serviceapplication_x));
2206 if (serviceapplication == NULL) {
2207 _LOGD("Malloc Failed\n");
2210 memset(serviceapplication, '\0', sizeof(serviceapplication_x));
2211 LISTADD(mfx->serviceapplication, serviceapplication);
2212 ret = __ps_process_serviceapplication(reader, serviceapplication, uid);
2213 } else if (!strcmp(ASCII(node), "daemon")) {
2214 daemon_x *daemon = malloc(sizeof(daemon_x));
2215 if (daemon == NULL) {
2216 _LOGD("Malloc Failed\n");
2219 memset(daemon, '\0', sizeof(daemon_x));
2220 LISTADD(mfx->daemon, daemon);
2221 ret = __ps_process_daemon(reader, daemon);
2222 } else if (!strcmp(ASCII(node), "theme")) {
2223 theme_x *theme = malloc(sizeof(theme_x));
2224 if (theme == NULL) {
2225 _LOGD("Malloc Failed\n");
2228 memset(theme, '\0', sizeof(theme_x));
2229 LISTADD(mfx->theme, theme);
2230 ret = __ps_process_theme(reader, theme);
2231 } else if (!strcmp(ASCII(node), "font")) {
2232 font_x *font = malloc(sizeof(font_x));
2234 _LOGD("Malloc Failed\n");
2237 memset(font, '\0', sizeof(font_x));
2238 LISTADD(mfx->font, font);
2239 ret = __ps_process_font(reader, font);
2240 } else if (!strcmp(ASCII(node), "ime")) {
2241 ime_x *ime = malloc(sizeof(ime_x));
2243 _LOGD("Malloc Failed\n");
2246 memset(ime, '\0', sizeof(ime_x));
2247 LISTADD(mfx->ime, ime);
2248 ret = __ps_process_ime(reader, ime);
2249 } else if (!strcmp(ASCII(node), "icon")) {
2250 icon_x *icon = malloc(sizeof(icon_x));
2252 _LOGD("Malloc Failed\n");
2255 memset(icon, '\0', sizeof(icon_x));
2256 LISTADD(mfx->icon, icon);
2257 ret = __ps_process_icon(reader, icon, uid);
2258 } else if (!strcmp(ASCII(node), "profile")) {
2259 deviceprofile_x *deviceprofile = malloc(sizeof(deviceprofile_x));
2260 if (deviceprofile == NULL) {
2261 _LOGD("Malloc Failed\n");
2264 memset(deviceprofile, '\0', sizeof(deviceprofile_x));
2265 LISTADD(mfx->deviceprofile, deviceprofile);
2266 ret = __ps_process_deviceprofile(reader, deviceprofile);
2267 } else if (!strcmp(ASCII(node), "compatibility")) {
2268 compatibility_x *compatibility = malloc(sizeof(compatibility_x));
2269 if (compatibility == NULL) {
2270 _LOGD("Malloc Failed\n");
2273 memset(compatibility, '\0', sizeof(compatibility_x));
2274 LISTADD(mfx->compatibility, compatibility);
2275 ret = __ps_process_compatibility(reader, compatibility);
2276 } else if (!strcmp(ASCII(node), "shortcut-list")) {
2278 } else if (!strcmp(ASCII(node), "livebox")) {
2280 } else if (!strcmp(ASCII(node), "account")) {
2282 } else if (!strcmp(ASCII(node), "notifications")) {
2284 } else if (!strcmp(ASCII(node), "ime")) {
2286 } else if (!strcmp(ASCII(node), "feature")) {
2289 _LOGE("Unknown element: %s", ASCII(node));
2294 _LOGD("Processing manifest failed\n");
2299 LISTHEAD(mfx->label, tmp1);
2303 LISTHEAD(mfx->author, tmp2);
2306 if (mfx->description) {
2307 LISTHEAD(mfx->description, tmp3);
2308 mfx->description= tmp3;
2311 LISTHEAD(mfx->license, tmp4);
2314 if (mfx->uiapplication) {
2315 LISTHEAD(mfx->uiapplication, tmp5);
2316 mfx->uiapplication = tmp5;
2318 if (mfx->serviceapplication) {
2319 LISTHEAD(mfx->serviceapplication, tmp6);
2320 mfx->serviceapplication = tmp6;
2323 LISTHEAD(mfx->daemon, tmp7);
2327 LISTHEAD(mfx->theme, tmp8);
2331 LISTHEAD(mfx->font, tmp9);
2335 LISTHEAD(mfx->ime, tmp10);
2339 LISTHEAD(mfx->icon, tmp11);
2342 if (mfx->compatibility) {
2343 LISTHEAD(mfx->compatibility, tmp12);
2344 mfx->compatibility= tmp12;
2346 if (mfx->deviceprofile) {
2347 LISTHEAD(mfx->deviceprofile, tmp13);
2348 mfx->deviceprofile= tmp13;
2350 if (mfx->privileges) {
2351 LISTHEAD(mfx->privileges, tmp14);
2352 mfx->privileges = tmp14;
2357 static int __process_manifest(xmlTextReaderPtr reader, manifest_x *mfx, uid_t uid)
2359 const xmlChar *node;
2362 if ((ret = __next_child_element(reader, -1))) {
2363 node = xmlTextReaderConstName(reader);
2365 _LOGD("xmlTextReaderConstName value is NULL\n");
2369 if (!strcmp(ASCII(node), "manifest")) {
2370 __save_xml_attribute(reader, "xmlns", &mfx->ns, NULL);
2371 __save_xml_attribute(reader, "package", &mfx->package, NULL);
2372 retvm_if(mfx->package == NULL, PM_PARSER_R_ERROR, "package cant be NULL, package field is mandatory\n");
2373 __save_xml_attribute(reader, "version", &mfx->version, NULL);
2374 __save_xml_attribute(reader, "size", &mfx->package_size, NULL);
2375 __save_xml_attribute(reader, "install-location", &mfx->installlocation, "internal-only");
2376 __save_xml_attribute(reader, "type", &mfx->type, "rpm");
2377 __save_xml_attribute(reader, "root_path", &mfx->root_path, NULL);
2378 __save_xml_attribute(reader, "csc_path", &mfx->csc_path, NULL);
2379 __save_xml_attribute(reader, "appsetting", &mfx->appsetting, "false");
2380 __save_xml_attribute(reader, "storeclient-id", &mfx->storeclient_id, NULL);
2381 __save_xml_attribute(reader, "nodisplay-setting", &mfx->nodisplay_setting, "false");
2382 __save_xml_attribute(reader, "url", &mfx->package_url, NULL);
2383 __save_xml_attribute(reader, "api-version", &mfx->api_version, NULL);
2385 __save_xml_installed_time(mfx);
2386 __save_xml_root_path(mfx, uid);
2387 /*Assign default values. If required it will be overwritten in __add_preload_info()*/
2388 __save_xml_default_value(mfx);
2390 ret = __start_process(reader, mfx, uid);
2392 _LOGD("No Manifest element found\n");
2399 #define LIBAPPSVC_PATH LIB_PATH "/libappsvc.so.0"
2401 static int __ps_remove_appsvc_db(manifest_x *mfx, uid_t uid)
2403 void *lib_handle = NULL;
2404 int (*appsvc_operation) (const char *, uid_t);
2406 uiapplication_x *uiapplication = mfx->uiapplication;
2408 if ((lib_handle = dlopen(LIBAPPSVC_PATH, RTLD_LAZY)) == NULL) {
2409 _LOGE("dlopen is failed LIBAPPSVC_PATH[%s]\n", LIBAPPSVC_PATH);
2413 if ((appsvc_operation =
2414 dlsym(lib_handle, "appsvc_unset_defapp")) == NULL || dlerror() != NULL) {
2415 _LOGE("can not find symbol \n");
2419 for(; uiapplication; uiapplication=uiapplication->next) {
2420 ret = appsvc_operation(uiapplication->appid, uid);
2422 _LOGE("can not operation symbol \n");
2427 dlclose(lib_handle);
2432 #define PRELOAD_PACKAGE_LIST SYSCONFDIR "/package-manager/preload/preload_list.txt"
2433 static int __add_preload_info(manifest_x * mfx, const char *manifest, uid_t uid)
2436 char buffer[1024] = { 0 };
2439 if(strstr(manifest, getUserManifestPath(uid))) {
2440 free((void *)mfx->readonly);
2441 mfx->readonly = strdup("True");
2443 free((void *)mfx->preload);
2444 mfx->preload = strdup("True");
2446 free((void *)mfx->removable);
2447 mfx->removable = strdup("False");
2449 free((void *)mfx->system);
2450 mfx->system = strdup("True");
2455 fp = fopen(PRELOAD_PACKAGE_LIST, "r");
2457 _LOGE("no preload list\n");
2461 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
2462 if (buffer[0] == '#') {
2463 if(strcasestr(buffer, "RW_NORM"))
2465 else if(strcasestr(buffer, "RW_RM"))
2473 if(!strcmp(mfx->package, buffer)) {
2474 free((void *)mfx->preload);
2475 mfx->preload = strdup("True");
2477 free((void *)mfx->readonly);
2478 mfx->readonly = strdup("False");
2479 free((void *)mfx->removable);
2480 mfx->removable = strdup("False");
2481 } else if(state == 3){
2482 free((void *)mfx->readonly);
2483 mfx->readonly = strdup("False");
2484 free((void *)mfx->removable);
2485 mfx->removable = strdup("True");
2489 memset(buffer, 0x00, sizeof(buffer));
2498 static int __check_preload_updated(manifest_x * mfx, const char *manifest, uid_t uid)
2500 if (!strstr(manifest, getUserManifestPath(uid))) {
2501 /* if downloaded app is updated, then update tag set true*/
2503 free((void *)mfx->update);
2504 mfx->update = strdup("true");
2511 API int pkgmgr_parser_create_desktop_file(manifest_x *mfx)
2513 /* desktop file is no longer used */
2517 API int pkgmgr_parser_create_usr_desktop_file(manifest_x *mfx, uid_t uid)
2519 /* desktop file is no longer used */
2524 API void pkgmgr_parser_free_manifest_xml(manifest_x *mfx)
2526 pkgmgrinfo_basic_free_package((package_x *)mfx);
2529 API manifest_x *pkgmgr_parser_process_manifest_xml(const char *manifest)
2531 _LOGD("parsing start pkgmgr_parser_process_manifest_xml\n");
2532 xmlTextReaderPtr reader;
2533 manifest_x *mfx = NULL;
2535 reader = xmlReaderForFile(manifest, NULL, 0);
2537 mfx = malloc(sizeof(manifest_x));
2539 memset(mfx, '\0', sizeof(manifest_x));
2540 if (__process_manifest(reader, mfx, GLOBAL_USER) < 0) {
2541 _LOGD("Parsing Failed\n");
2542 pkgmgr_parser_free_manifest_xml(mfx);
2545 _LOGD("Parsing Success\n");
2547 _LOGD("Memory allocation error\n");
2549 xmlFreeTextReader(reader);
2551 _LOGD("Unable to create xml reader\n");
2557 API manifest_x *pkgmgr_parser_usr_process_manifest_xml(const char *manifest, uid_t uid)
2559 _LOGD("parsing start pkgmgr_parser_usr_process_manifest_xml\n");
2560 xmlTextReaderPtr reader;
2561 manifest_x *mfx = NULL;
2563 reader = xmlReaderForFile(manifest, NULL, 0);
2565 mfx = malloc(sizeof(manifest_x));
2567 memset(mfx, '\0', sizeof(manifest_x));
2568 if (__process_manifest(reader, mfx, uid) < 0) {
2569 _LOGD("Parsing Failed\n");
2570 pkgmgr_parser_free_manifest_xml(mfx);
2573 _LOGD("Parsing Success\n");
2575 _LOGD("Memory allocation error\n");
2577 xmlFreeTextReader(reader);
2579 _LOGD("Unable to create xml reader\n");
2584 /* These APIs are intended to call parser directly */
2586 API int pkgmgr_parser_parse_manifest_for_installation(const char *manifest, char *const tagv[])
2588 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2589 _LOGD("parsing manifest for installation: %s\n", manifest);
2591 manifest_x *mfx = NULL;
2595 mfx = pkgmgr_parser_process_manifest_xml(manifest);
2596 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2598 _LOGD("Parsing Finished\n");
2600 __add_preload_info(mfx, manifest, GLOBAL_USER);
2602 _LOGD("Added preload infomation\n");
2604 __ps_process_tag(mfx, tagv);
2606 ret = pkgmgr_parser_insert_manifest_info_in_db(mfx);
2607 retvm_if(ret == PMINFO_R_ERROR, PMINFO_R_ERROR, "DB Insert failed");
2609 _LOGD("DB Insert Success\n");
2611 __ps_process_tag_parser(mfx, manifest, ACTION_INSTALL);
2612 ret = __ps_process_metadata_parser(mfx, ACTION_INSTALL);
2614 _LOGD("Creating metadata parser failed\n");
2616 ret = __ps_process_category_parser(mfx, ACTION_INSTALL);
2618 _LOGD("Creating category parser failed\n");
2620 pkgmgr_parser_free_manifest_xml(mfx);
2621 _LOGD("Free Done\n");
2626 API int pkgmgr_parser_parse_usr_manifest_for_installation(const char *manifest, uid_t uid, char *const tagv[])
2628 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2629 _LOGD("parsing manifest for installation: %s\n", manifest);
2630 manifest_x *mfx = NULL;
2634 mfx = pkgmgr_parser_usr_process_manifest_xml(manifest, uid);
2635 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2637 _LOGD("Parsing Finished\n");
2639 __ps_process_tag(mfx, tagv);
2641 ret = pkgmgr_parser_insert_manifest_info_in_usr_db(mfx, uid);
2642 retvm_if(ret == PMINFO_R_ERROR, PMINFO_R_ERROR, "DB Insert failed");
2644 _LOGD("DB Insert Success\n");
2646 __ps_process_tag_parser(mfx, manifest, ACTION_INSTALL);
2647 ret = __ps_process_metadata_parser(mfx, ACTION_INSTALL);
2649 _LOGD("Creating metadata parser failed\n");
2650 ret = __ps_process_category_parser(mfx, ACTION_INSTALL);
2652 _LOGD("Creating category parser failed\n");
2654 pkgmgr_parser_free_manifest_xml(mfx);
2655 _LOGD("Free Done\n");
2661 API int pkgmgr_parser_parse_manifest_for_upgrade(const char *manifest, char *const tagv[])
2663 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2664 _LOGD("pkgmgr_parser_parse_manifest_for_upgrade parsing manifest for upgradation: %s\n", manifest);
2665 manifest_x *mfx = NULL;
2667 bool preload = false;
2668 bool system = false;
2669 char *csc_path = NULL;
2670 pkgmgrinfo_pkginfo_h handle = NULL;
2673 mfx = pkgmgr_parser_process_manifest_xml(manifest);
2674 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2676 _LOGD("Parsing Finished\n");
2677 __add_preload_info(mfx, manifest, GLOBAL_USER);
2678 _LOGD("Added preload infomation\n");
2679 __check_preload_updated(mfx, manifest, GLOBAL_USER);
2681 ret = pkgmgrinfo_pkginfo_get_pkginfo(mfx->package, &handle);
2682 if (ret != PMINFO_R_OK)
2683 _LOGD("pkgmgrinfo_pkginfo_get_pkginfo failed\n");
2684 ret = pkgmgrinfo_pkginfo_is_preload(handle, &preload);
2685 if (ret != PMINFO_R_OK)
2686 _LOGD("pkgmgrinfo_pkginfo_is_preload failed\n");
2689 free((void *)mfx->preload);
2690 mfx->preload = strdup("true");
2693 ret = pkgmgrinfo_pkginfo_is_system(handle, &system);
2694 if (ret != PMINFO_R_OK)
2695 _LOGD("pkgmgrinfo_pkginfo_is_system failed\n");
2697 free((void *)mfx->system);
2698 mfx->system = strdup("true");
2701 ret = pkgmgrinfo_pkginfo_get_csc_path(handle, &csc_path);
2702 if (ret != PMINFO_R_OK)
2703 _LOGD("pkgmgrinfo_pkginfo_get_csc_path failed\n");
2705 if (csc_path != NULL) {
2707 free((void *)mfx->csc_path);
2708 mfx->csc_path = strdup(csc_path);
2711 ret = pkgmgr_parser_update_manifest_info_in_db(mfx);
2712 retvm_if(ret == PMINFO_R_ERROR, PMINFO_R_ERROR, "DB Insert failed");
2714 _LOGD("DB Update Success\n");
2716 __ps_process_tag_parser(mfx, manifest, ACTION_UPGRADE);
2717 ret = __ps_process_metadata_parser(mfx, ACTION_UPGRADE);
2719 _LOGD("Upgrade metadata parser failed\n");
2721 ret = __ps_process_category_parser(mfx, ACTION_UPGRADE);
2723 _LOGD("Creating category parser failed\n");
2724 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2725 pkgmgr_parser_free_manifest_xml(mfx);
2726 _LOGD("Free Done\n");
2732 API int pkgmgr_parser_parse_usr_manifest_for_upgrade(const char *manifest, uid_t uid, char *const tagv[])
2734 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2735 _LOGD(" pkgmgr_parser_parse_usr_manifest_for_upgrade parsing manifest for upgradation: %s\n", manifest);
2736 manifest_x *mfx = NULL;
2738 bool preload = false;
2739 bool system = false;
2740 char *csc_path = NULL;
2741 pkgmgrinfo_pkginfo_h handle = NULL;
2744 mfx = pkgmgr_parser_usr_process_manifest_xml(manifest, uid);
2745 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2747 _LOGD("Parsing Finished\n");
2748 __check_preload_updated(mfx, manifest, uid);
2750 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(mfx->package, uid, &handle);
2751 if (ret != PMINFO_R_OK)
2752 _LOGD("pkgmgrinfo_pkginfo_get_pkginfo failed\n");
2753 ret = pkgmgrinfo_pkginfo_is_preload(handle, &preload);
2754 if (ret != PMINFO_R_OK)
2755 _LOGD("pkgmgrinfo_pkginfo_is_preload failed\n");
2758 free((void *)mfx->preload);
2759 mfx->preload = strdup("true");
2762 ret = pkgmgrinfo_pkginfo_is_system(handle, &system);
2763 if (ret != PMINFO_R_OK)
2764 _LOGD("pkgmgrinfo_pkginfo_is_system failed\n");
2767 free((void *)mfx->system);
2768 mfx->system = strdup("true");
2771 ret = pkgmgrinfo_pkginfo_get_csc_path(handle, &csc_path);
2772 if (ret != PMINFO_R_OK)
2773 _LOGD("pkgmgrinfo_pkginfo_get_csc_path failed\n");
2774 if (csc_path != NULL) {
2776 free((void *)mfx->csc_path);
2777 mfx->csc_path = strdup(csc_path);
2780 ret = pkgmgr_parser_update_manifest_info_in_usr_db(mfx, uid);
2781 retvm_if(ret == PMINFO_R_ERROR, PMINFO_R_ERROR, "DB Insert failed");
2782 _LOGD("DB Update Success\n");
2784 __ps_process_tag_parser(mfx, manifest, ACTION_UPGRADE);
2785 ret = __ps_process_metadata_parser(mfx, ACTION_UPGRADE);
2787 _LOGD("Upgrade metadata parser failed\n");
2788 ret = __ps_process_category_parser(mfx, ACTION_UPGRADE);
2790 _LOGD("Creating category parser failed\n");
2791 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
2792 pkgmgr_parser_free_manifest_xml(mfx);
2793 _LOGD("Free Done\n");
2799 API int pkgmgr_parser_parse_manifest_for_uninstallation(const char *manifest, char *const tagv[])
2801 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2802 _LOGD("parsing manifest for uninstallation: %s\n", manifest);
2804 manifest_x *mfx = NULL;
2807 mfx = pkgmgr_parser_process_manifest_xml(manifest);
2808 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2810 _LOGD("Parsing Finished\n");
2812 __ps_process_tag_parser(mfx, manifest, ACTION_UNINSTALL);
2814 __add_preload_info(mfx, manifest, GLOBAL_USER);
2815 _LOGD("Added preload infomation\n");
2817 ret = __ps_process_metadata_parser(mfx, ACTION_UNINSTALL);
2819 _LOGD("Removing metadata parser failed\n");
2821 ret = __ps_process_category_parser(mfx, ACTION_UNINSTALL);
2823 _LOGD("Creating category parser failed\n");
2825 ret = pkgmgr_parser_delete_manifest_info_from_db(mfx);
2827 _LOGD("DB Delete failed\n");
2829 _LOGD("DB Delete Success\n");
2831 pkgmgr_parser_free_manifest_xml(mfx);
2832 _LOGD("Free Done\n");
2839 API int pkgmgr_parser_parse_usr_manifest_for_uninstallation(const char *manifest, uid_t uid, char *const tagv[])
2841 retvm_if(manifest == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2842 _LOGD("parsing manifest for uninstallation: %s\n", manifest);
2844 manifest_x *mfx = NULL;
2847 mfx = pkgmgr_parser_usr_process_manifest_xml(manifest, uid);
2848 retvm_if(mfx == NULL, PMINFO_R_ERROR, "argument supplied is NULL");
2850 _LOGD("Parsing Finished\n");
2852 __ps_process_tag_parser(mfx, manifest, ACTION_UNINSTALL);
2854 ret = __ps_process_metadata_parser(mfx, ACTION_UNINSTALL);
2856 _LOGD("Removing metadata parser failed\n");
2858 ret = __ps_process_category_parser(mfx, ACTION_UNINSTALL);
2860 _LOGD("Creating category parser failed\n");
2862 ret = pkgmgr_parser_delete_manifest_info_from_usr_db(mfx, uid);
2864 _LOGD("DB Delete failed\n");
2866 _LOGD("DB Delete Success\n");
2868 ret = __ps_remove_appsvc_db(mfx, uid);
2870 _LOGD("Removing appsvc_db failed\n");
2872 _LOGD("Removing appsvc_db Success\n");
2874 pkgmgr_parser_free_manifest_xml(mfx);
2875 _LOGD("Free Done\n");
2881 API int pkgmgr_parser_parse_manifest_for_preload()
2883 return pkgmgr_parser_update_preload_info_in_db();
2886 API int pkgmgr_parser_parse_usr_manifest_for_preload(uid_t uid)
2888 return pkgmgr_parser_update_preload_info_in_usr_db(uid);
2892 API char *pkgmgr_parser_get_usr_manifest_file(const char *pkgid, uid_t uid)
2894 return __pkgid_to_manifest(pkgid, uid);
2897 API char *pkgmgr_parser_get_manifest_file(const char *pkgid)
2899 return __pkgid_to_manifest(pkgid, GLOBAL_USER);
2902 API int pkgmgr_parser_run_parser_for_installation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
2904 return __ps_run_parser(docPtr, tag, ACTION_INSTALL, pkgid);
2907 API int pkgmgr_parser_run_parser_for_upgrade(xmlDocPtr docPtr, const char *tag, const char *pkgid)
2909 return __ps_run_parser(docPtr, tag, ACTION_UPGRADE, pkgid);
2912 API int pkgmgr_parser_run_parser_for_uninstallation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
2914 return __ps_run_parser(docPtr, tag, ACTION_UNINSTALL, pkgid);
2917 #define SCHEMA_FILE SYSCONFDIR "/package-manager/preload/manifest.xsd"
2919 API int pkgmgr_parser_check_manifest_validation(const char *manifest)
2921 if (manifest == NULL) {
2922 _LOGE("manifest file is NULL\n");
2923 return PMINFO_R_EINVAL;
2926 xmlSchemaParserCtxtPtr ctx;
2927 xmlSchemaValidCtxtPtr vctx;
2928 xmlSchemaPtr xschema;
2929 ctx = xmlSchemaNewParserCtxt(SCHEMA_FILE);
2931 _LOGE("xmlSchemaNewParserCtxt() Failed\n");
2932 return PMINFO_R_ERROR;
2934 xschema = xmlSchemaParse(ctx);
2935 if (xschema == NULL) {
2936 _LOGE("xmlSchemaParse() Failed\n");
2937 return PMINFO_R_ERROR;
2939 vctx = xmlSchemaNewValidCtxt(xschema);
2941 _LOGE("xmlSchemaNewValidCtxt() Failed\n");
2942 return PMINFO_R_ERROR;
2944 xmlSchemaSetValidErrors(vctx, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stderr);
2945 ret = xmlSchemaValidateFile(vctx, manifest, 0);
2947 _LOGE("xmlSchemaValidateFile() failed\n");
2948 return PMINFO_R_ERROR;
2949 } else if (ret == 0) {
2950 _LOGE("Manifest is Valid\n");
2953 _LOGE("Manifest Validation Failed with error code %d\n", ret);
2954 return PMINFO_R_ERROR;
2960 API int pkgmgr_parser_check_manifest_validation(const char *manifest)
2970 _LOGE("fork failed\n");
2975 int dev_null_fd = open ("/dev/null", O_RDWR);
2976 if (dev_null_fd >= 0)
2978 dup2 (dev_null_fd, 0);/*stdin*/
2979 dup2 (dev_null_fd, 1);/*stdout*/
2980 dup2 (dev_null_fd, 2);/*stderr*/
2983 if (execl("/usr/bin/xmllint", "xmllint", manifest, "--schema",
2984 SCHEMA_FILE, NULL) < 0) {
2985 _LOGE("execl error\n");
2995 while ((err = waitpid(pid, &status, WNOHANG)) != pid) {
2999 _LOGE("waitpid failed\n");
3005 if(WIFEXITED(status) && !WEXITSTATUS(status))