Merge "Remove unused files and change file permission" into tizen
[platform/core/appfw/pkgmgr-info.git] / parser / pkgmgr_parser.h
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
23 #ifndef __PKGMGR_PARSER_H__
24 #define __PKGMGR_PARSER_H__
25
26 /**
27  * @file pkgmgr_parser.h
28  * @author Sewook Park <sewook7.park@samsung.com>
29  * @author Shobhit Srivastava <shobhit.s@samsung.com>
30  * @version 0.1
31  * @brief    This file declares API of pkgmgr_parser
32  * @addtogroup          APPLICATION_FRAMEWORK
33  * @{
34  *
35  * @defgroup            PackageManagerParser
36  * @section             Header Header file to include:
37  * @code
38  * #include             <pkgmgr_parser.h>
39  * @endcode
40  *
41  * @}
42  */
43
44 #include <libxml/xmlreader.h>
45
46 /* For multi-user support */
47 #include <tzplatform_config.h>
48
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52 #define DEFAULT_LOCALE          "No Locale"
53
54 #define PKG_PARSERLIB   "parserlib:"
55 #define PKG_PARSER_CONF_PATH    SYSCONFDIR "/package-manager/parser_path.conf"
56
57 #define PKG_STRING_LEN_MAX 1024
58
59 #define PKGMGR_PARSER_EMPTY_STR         ""
60 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
61
62
63 /**
64  * @brief List definitions.
65  * All lists are doubly-linked, the last element is stored to list pointer,
66  * which means that lists must be looped using the prev pointer, or by
67  * calling LISTHEAD first to go to start in order to use the next pointer.
68  */
69
70  /**
71  * @brief Convinience Macro to add node in list
72  */
73
74 #define LISTADD(list, node)                     \
75     do {                                        \
76         (node)->prev = (list);                  \
77         if (list) (node)->next = (list)->next;  \
78         else (node)->next = NULL;               \
79         if (list) (list)->next = (node);        \
80         (list) = (node);                        \
81     } while (0);
82
83  /**
84  * @brief Convinience Macro to add one node to another node
85  */
86 #define NODEADD(node1, node2)                                   \
87     do {                                                        \
88         (node2)->prev = (node1);                                \
89         (node2)->next = (node1)->next;                          \
90         if ((node1)->next) (node1)->next->prev = (node2);       \
91         (node1)->next = (node2);                                \
92     } while (0);
93
94  /**
95  * @brief Convinience Macro to concatenate two lists
96  */
97 #define LISTCAT(list, first, last)              \
98     if ((first) && (last)) {                    \
99         (first)->prev = (list);                 \
100         (list) = (last);                        \
101     }
102
103  /**
104  * @brief Convinience Macro to delete node from list
105  */
106 #define LISTDEL(list, node)                                     \
107     do {                                                        \
108         if ((node)->prev) (node)->prev->next = (node)->next;    \
109         if ((node)->next) (node)->next->prev = (node)->prev;    \
110         if (!((node)->prev) && !((node)->next)) (list) = NULL;  \
111     } while (0);
112
113  /**
114  * @brief Convinience Macro to get list head
115  */
116 #define LISTHEAD(list, node)                                    \
117     for ((node) = (list); (node)->prev; (node) = (node)->prev)
118
119  /**
120  * @brief Convinience Macro to get list tail
121  */
122 #define LISTTAIL(list, node)                                    \
123     for ((node) = (list); (node)->next; (node) = (node)->next)
124
125 typedef struct metadata_x {
126         const char *key;
127         const char *value;
128         struct metadata_x *prev;
129         struct metadata_x *next;
130 } metadata_x;
131
132 typedef struct privilege_x {
133         const char *text;
134         struct privilege_x *prev;
135         struct privilege_x *next;
136 } privilege_x;
137
138 typedef struct privileges_x {
139         struct privilege_x *privilege;
140         struct privileges_x *prev;
141         struct privileges_x *next;
142 } privileges_x;
143
144 typedef struct permission_x {
145         const char *type;
146         const char *value;
147         struct permission_x *prev;
148         struct permission_x *next;
149 } permission_x;
150
151 typedef struct icon_x {
152         const char *name;
153         const char *text;
154         const char *lang;
155         const char *section;
156         const char *size;
157         const char *resolution;
158         struct icon_x *prev;
159         struct icon_x *next;
160 } icon_x;
161
162 typedef struct image_x {
163         const char *name;
164         const char *text;
165         const char *lang;
166         const char *section;
167         struct image_x *prev;
168         struct image_x *next;
169 } image_x;
170
171 typedef struct allowed_x {
172         const char *name;
173         const char *text;
174         struct allowed_x *prev;
175         struct allowed_x *next;
176 } allowed_x;
177
178 typedef struct request_x {
179         const char *text;
180         struct request_x *prev;
181         struct request_x *next;
182 } request_x;
183
184 typedef struct define_x {
185         const char *path;
186         struct allowed_x *allowed;
187         struct request_x *request;
188         struct define_x *prev;
189         struct define_x *next;
190 } define_x;
191
192 typedef struct datashare_x {
193         struct define_x *define;
194         struct request_x *request;
195         struct datashare_x *prev;
196         struct datashare_x *next;
197 } datashare_x;
198
199 typedef struct description_x {
200         const char *name;
201         const char *text;
202         const char *lang;
203         struct description_x *prev;
204         struct description_x *next;
205 } description_x;
206
207 typedef struct registry_x {
208         const char *name;
209         const char *text;
210         struct registry_x *prev;
211         struct registry_x *next;
212 } registry_x;
213
214 typedef struct database_x {
215         const char *name;
216         const char *text;
217         struct database_x *prev;
218         struct database_x *next;
219 } database_x;
220
221 typedef struct layout_x {
222         const char *name;
223         const char *text;
224         struct layout_x *prev;
225         struct layout_x *next;
226 } layout_x;
227
228 typedef struct label_x {
229         const char *name;
230         const char *text;
231         const char *lang;
232         struct label_x *prev;
233         struct label_x *next;
234 } label_x;
235
236 typedef struct author_x {
237         const char *email;
238         const char *href;
239         const char *text;
240         const char *lang;
241         struct author_x *prev;
242         struct author_x *next;
243 } author_x;
244
245 typedef struct license_x {
246         const char *text;
247         const char *lang;
248         struct license_x *prev;
249         struct license_x *next;
250 } license_x;
251
252 typedef struct operation_x {
253         const char *name;
254         const char *text;
255         struct operation_x *prev;
256         struct operation_x *next;
257 } operation_x;
258
259 typedef struct uri_x {
260         const char *name;
261         const char *text;
262         struct uri_x *prev;
263         struct uri_x *next;
264 } uri_x;
265
266 typedef struct mime_x {
267         const char *name;
268         const char *text;
269         struct mime_x *prev;
270         struct mime_x *next;
271 } mime_x;
272
273 typedef struct subapp_x {
274         const char *name;
275         const char *text;
276         struct subapp_x *prev;
277         struct subapp_x *next;
278 } subapp_x;
279
280 typedef struct condition_x {
281         const char *name;
282         const char *text;
283         struct condition_x *prev;
284         struct condition_x *next;
285 } condition_x;
286
287 typedef struct notification_x {
288         const char *name;
289         const char *text;
290         struct notification_x *prev;
291         struct notification_x *next;
292 } notification_x;
293
294 typedef struct appsvc_x {
295         const char *text;
296         struct operation_x *operation;
297         struct uri_x *uri;
298         struct mime_x *mime;
299         struct subapp_x *subapp;
300         struct appsvc_x *prev;
301         struct appsvc_x *next;
302 } appsvc_x;
303
304 typedef struct appcontrol_x {
305         const char *text;
306         struct operation_x *operation;
307         struct uri_x *uri;
308         struct mime_x *mime;
309         struct subapp_x *subapp;
310         struct appcontrol_x *prev;
311         struct appcontrol_x *next;
312 } appcontrol_x;
313
314 typedef struct category_x{
315         const char *name;
316         struct category_x *prev;
317         struct category_x *next;
318 } category_x;
319
320 typedef struct launchconditions_x {
321         const char *text;
322         struct condition_x *condition;
323         struct launchconditions_x *prev;
324         struct launchconditions_x *next;
325 } launchconditions_x;
326
327 typedef struct compatibility_x {
328         const char *name;
329         const char *text;
330         struct compatibility_x *prev;
331         struct compatibility_x *next;
332 }compatibility_x;
333
334 typedef struct deviceprofile_x {
335         const char *name;
336         const char *text;
337         struct deviceprofile_x *prev;
338         struct deviceprofile_x *next;
339 }deviceprofile_x;
340
341 typedef struct resolution_x {
342         const char *mimetype;
343         const char *urischeme;
344         struct resolution_x *prev;
345         struct resolution_x *next;
346 } resolution_x;
347
348 typedef struct capability_x {
349         const char *operationid;
350         const char *access;
351         struct resolution_x *resolution;
352         struct capability_x *prev;
353         struct capability_x *next;
354 } capability_x;
355
356 typedef struct datacontrol_x {
357         const char *providerid;
358         const char *access;
359         const char *type;
360         struct datacontrol_x *prev;
361         struct datacontrol_x *next;
362 } datacontrol_x;
363
364 typedef struct uiapplication_x {
365         const char *appid;
366         const char *exec;
367         const char *nodisplay;
368         const char *multiple;
369         const char *taskmanage;
370         const char *enabled;
371         const char *type;
372         const char *categories;
373         const char *extraid;
374         const char *hwacceleration;
375         const char *screenreader;
376         const char *mainapp;
377         const char *package;
378         const char *recentimage;
379         const char *launchcondition;
380         const char *indicatordisplay;
381         const char *portraitimg;
382         const char *landscapeimg;
383         const char *guestmode_visibility;
384         const char *app_component;
385         const char *permission_type;
386         const char *component_type;
387         const char *preload;
388         const char *submode;
389         const char *submode_mainid;
390         struct label_x *label;
391         struct icon_x *icon;
392         struct image_x *image;
393         struct appsvc_x *appsvc;
394         struct appcontrol_x *appcontrol;
395         struct category_x *category;
396         struct metadata_x *metadata;
397         struct permission_x *permission;
398         struct launchconditions_x *launchconditions;
399         struct notification_x *notification;
400         struct datashare_x *datashare;
401         struct datacontrol_x *datacontrol;
402         struct uiapplication_x *prev;
403         struct uiapplication_x *next;
404 } uiapplication_x;
405
406 typedef struct serviceapplication_x {
407         const char *appid;
408         const char *exec;
409         const char *onboot;
410         const char *autorestart;
411         const char *enabled;
412         const char *type;
413         const char *package;
414         const char *permission_type;
415         struct label_x *label;
416         struct icon_x *icon;
417         struct appsvc_x *appsvc;
418         struct appcontrol_x *appcontrol;
419         struct category_x *category;
420         struct metadata_x *metadata;
421         struct permission_x *permission;
422         struct datacontrol_x *datacontrol;
423         struct launchconditions_x *launchconditions;
424         struct notification_x *notification;
425         struct datashare_x *datashare;
426         struct serviceapplication_x *prev;
427         struct serviceapplication_x *next;
428 } serviceapplication_x;
429
430 typedef struct daemon_x {
431         const char *name;
432         const char *text;
433         struct daemon_x *prev;
434         struct daemon_x *next;
435 } daemon_x;
436
437 typedef struct theme_x {
438         const char *name;
439         const char *text;
440         struct theme_x *prev;
441         struct theme_x *next;
442 } theme_x;
443
444 typedef struct font_x {
445         const char *name;
446         const char *text;
447         struct font_x *prev;
448         struct font_x *next;
449 } font_x;
450
451 typedef struct ime_x {
452         const char *name;
453         const char *text;
454         struct ime_x *prev;
455         struct ime_x *next;
456 } ime_x;
457
458 typedef struct manifest_x {
459         const char *for_all_users;              /**< Flag that indicates if the package is available for everyone or for current user only*/
460         const char *package;            /**< package name*/
461         const char *version;            /**< package version*/
462         const char *installlocation;            /**< package install location*/
463         const char *ns;         /**<name space*/
464         const char *removable;          /**< package removable flag*/
465         const char *preload;            /**< package preload flag*/
466         const char *readonly;           /**< package readonly flag*/
467         const char *update;                     /**< package update flag*/
468         const char *appsetting;         /**< package app setting flag*/
469         const char *system;             /**< package system flag*/
470         const char *type;               /**< package type*/
471         const char *package_size;               /**< package size for external installation*/
472         const char *installed_time;             /**< installed time after finishing of installation*/
473         const char *installed_storage;          /**< package currently installed storage*/
474         const char *storeclient_id;             /**< id of store client for installed package*/
475         const char *mainapp_id;         /**< app id of main application*/
476         const char *package_url;                /**< app id of main application*/
477         const char *root_path;          /**< package root path*/
478         const char *csc_path;           /**< package csc path*/
479         const char *nodisplay_setting;          /**< package no display setting menu*/
480         const char *main_package;               /**< main package id for sub-package(ug)*/
481         struct icon_x *icon;            /**< package icon*/
482         struct label_x *label;          /**< package label*/
483         struct author_x *author;                /**< package author*/
484         struct description_x *description;              /**< package description*/
485         struct license_x *license;              /**< package license*/
486         struct privileges_x *privileges;        /**< package privileges*/
487         struct uiapplication_x *uiapplication;          /**< package's ui application*/
488         struct serviceapplication_x *serviceapplication;                /**< package's service application*/
489         struct daemon_x *daemon;                /**< package daemon*/
490         struct theme_x *theme;          /**< package theme*/
491         struct font_x *font;            /**< package font*/
492         struct ime_x *ime;              /**< package ime*/
493         struct compatibility_x *compatibility;          /**< package compatibility*/
494         struct deviceprofile_x *deviceprofile;          /**< package device profile*/
495 } manifest_x;
496
497 /*enum uid_value {
498         ROOT,
499         GLOBAL,
500         USER
501 };*/
502
503 /**uid check
504  * 
505  */
506 /* int check_uid(uid_t uid)
507  {
508          switch(uid)
509          {
510                 case GLOBAL_USER: return GLOBAL;
511                 case 0: return ROOT;
512                 default: goto user; break;
513         }
514 user:
515 cf getdbpath
516 */
517  
518
519 /**
520  * @fn char *pkgmgr_parser_get_manifest_file(const char *pkgid)
521  * @brief       This API gets the manifest file of the package.
522  *
523  * @par         This API is for package-manager installer backends.
524  * @par Sync (or) Async : Synchronous API
525  *
526  * @param[in]   pkgid   pointer to package ID
527  * @return      manifest file path on success, NULL on failure
528  * @pre         None
529  * @post                Free the manifest file pointer that is returned by API
530  * @code
531 static int get_manifest_file(const char *pkgid)
532 {
533         char *manifest = NULL;
534         manifest = pkgmgr_parser_get_manifest_file(pkgid);
535         if (manifest == NULL)
536                 return -1;
537         printf("Manifest File Path is %s\n", manifest);
538         free(manifest);
539         return 0;
540 }
541  * @endcode
542  */
543 char *pkgmgr_parser_get_manifest_file(const char *pkgid);
544
545 /**
546  * @fn int pkgmgr_parser_parse_manifest_for_installation(const char *manifest, char *const tagv[])
547  * @fn int pkgmgr_parser_parse_usr_manifest_for_installation(const char *manifest, uid_t uid, char *const tagv[])
548  * @brief       This API parses the manifest file of the package after installation and stores the data in DB.
549  *
550  * @par         This API is for package-manager installer backends.
551  * @par Sync (or) Async : Synchronous API
552  *
553  * @param[in]   manifest        pointer to package manifest file
554  * @param[in]   uid     the addressee user id of the instruction
555  * @param[in]   tagv            array of xml tags or NULL
556  * @return      0 if success, error code(<0) if fail
557  * @retval      PMINFO_R_OK     success
558  * @retval      PMINFO_R_EINVAL invalid argument
559  * @retval      PMINFO_R_ERROR  internal error
560  * @pre         None
561  * @post                None
562  * @code
563 static int parse_manifest_file_for_installation(const char *manifest)
564 {
565         int ret = 0;
566         ret = pkgmgr_parser_parse_manifest_for_installation(manifest, NULL);
567         if (ret)
568                 return -1;
569         return 0;
570 }
571  * @endcode
572  */
573 int pkgmgr_parser_parse_manifest_for_installation(const char *manifest, char *const tagv[]);
574 int pkgmgr_parser_parse_usr_manifest_for_installation(const char *manifest, uid_t uid, char *const tagv[]);
575
576 /**
577  * @fn int pkgmgr_parser_parse_usr_manifest_for_upgrade(const char *manifest,  uid_t uid, char *const tagv[])
578  * @fn int pkgmgr_parser_parse_manifest_for_upgrade(const char *manifest, char *const tagv[])
579  * @brief       This API parses the manifest file of the package after upgrade and stores the data in DB.
580  *
581  * @par         This API is for package-manager installer backends.
582  * @par Sync (or) Async : Synchronous API
583  *
584  * @param[in]   manifest        pointer to package manifest file
585  * @param[in]   uid     the addressee user id of the instruction
586  * @param[in]   tagv            array of xml tags or NULL
587  * @return      0 if success, error code(<0) if fail
588  * @retval      PMINFO_R_OK     success
589  * @retval      PMINFO_R_EINVAL invalid argument
590  * @retval      PMINFO_R_ERROR  internal error
591  * @pre         None
592  * @post                None
593  * @code
594 static int parse_manifest_file_for_upgrade(const char *manifest)
595 {
596         int ret = 0;
597         ret = pkgmgr_parser_parse_manifest_for_upgrade(manifest, NULL);
598         if (ret)
599                 return -1;
600         return 0;
601 }
602  * @endcode
603  */
604 int pkgmgr_parser_parse_manifest_for_upgrade(const char *manifest, char *const tagv[]);
605 int pkgmgr_parser_parse_usr_manifest_for_upgrade(const char *manifest, uid_t uid, char *const tagv[]);
606 /**
607  * @fn int pkgmgr_parser_parse_manifest_for_uninstallation(const char *manifest, char *const tagv[])
608  * @fn int pkgmgr_parser_parse_usr_manifest_for_uninstallation(const char *manifest, uid_t uid, char *const tagv[])
609  * @brief       This API parses the manifest file of the package after uninstallation and deletes the data from DB.
610  *
611  * @par         This API is for package-manager installer backends.
612  * @par Sync (or) Async : Synchronous API
613  *
614  * @param[in]   manifest        pointer to package manifest file
615  * @param[in]   uid     the addressee user id of the instruction
616  * @param[in]   tagv            array of xml tags or NULL
617  * @return      0 if success, error code(<0) if fail
618  * @retval      PMINFO_R_OK     success
619  * @retval      PMINFO_R_EINVAL invalid argument
620  * @retval      PMINFO_R_ERROR  internal error
621  * @pre         None
622  * @post                None
623  * @code
624 static int parse_manifest_file_for_uninstallation(const char *manifest)
625 {
626         int ret = 0;
627         ret = pkgmgr_parser_parse_manifest_for_uninstallation(manifest, NULL);
628         if (ret)
629                 return -1;
630         return 0;
631 }
632  * @endcode
633  */
634 int pkgmgr_parser_parse_manifest_for_uninstallation(const char *manifest, char *const tagv[]);
635 int pkgmgr_parser_parse_usr_manifest_for_uninstallation(const char *manifest, uid_t uid, char *const tagv[]);
636 /**
637  * @fn int pkgmgr_parser_parse_manifest_for_preload()
638  * @fn int pkgmgr_parser_parse_usr_manifest_for_preload(uid_t uid)
639  * @brief       This API update  preload information to DB.
640  *
641  * @par         This API is for package-manager installer backends.
642  * @par Sync (or) Async : Synchronous API
643  *
644  * @return      0 if success, error code(<0) if fail
645  * @retval      PMINFO_R_OK     success
646  * @retval      PMINFO_R_EINVAL invalid argument
647  * @retval      PMINFO_R_ERROR  internal error
648  * @pre         None
649  * @post                None
650  * @code
651 static int parser_parse_manifest_for_preload()
652 {
653         int ret = 0;
654         ret = pkgmgr_parser_parse_manifest_for_preload();
655         if (ret)
656                 return -1;
657         return 0;
658 }
659  * @endcode
660  */
661 int pkgmgr_parser_parse_manifest_for_preload();
662 int pkgmgr_parser_parse_usr_manifest_for_preload(uid_t uid);
663
664 /**
665  * @fn int pkgmgr_parser_check_manifest_validation(const char *manifest)
666  * @brief       This API validates the manifest file against the manifest schema.
667  *
668  * @par         This API is for package-manager installer backends.
669  * @par Sync (or) Async : Synchronous API
670  *
671  * @param[in]   manifest        pointer to package manifest file
672  * @return      0 if success, error code(<0) if fail
673  * @retval      PMINFO_R_OK     success
674  * @retval      PMINFO_R_EINVAL invalid argument
675  * @retval      PMINFO_R_ERROR  internal error
676  * @pre         None
677  * @post                None
678  * @code
679 static int validate_manifest_file(const char *manifest)
680 {
681         int ret = 0;
682         ret = pkgmgr_parser_check_manifest_validation(manifest);
683         if (ret)
684                 return -1;
685         return 0;
686 }
687  * @endcode
688  */
689 int pkgmgr_parser_check_manifest_validation(const char *manifest);
690
691 /**
692  * @fn void pkgmgr_parser_free_manifest_xml(manifest_x *mfx)
693  * @brief       This API will free the manifest pointer by recursively freeing all sub elements.
694  *
695  * @par         This API is for package-manager installer backends.
696  * @par Sync (or) Async : Synchronous API
697  *
698  * @param[in]   mfx     pointer to parsed manifest data
699  * @pre         pkgmgr_parser_process_manifest_xml()
700  * @post                None
701  * @code
702 static int parse_manifest_file(const char *manifest)
703 {
704         manifest_x *mfx = NULL
705         mfx = pkgmgr_parser_process_manifest_xml(manifest);
706         if (mfx == NULL)
707                 return -1;
708         printf("Parsing Manifest Success\n");
709         pkgmgr_parser_free_manifest_xml(mfx);
710         return 0;
711 }
712  * @endcode
713  */
714 void pkgmgr_parser_free_manifest_xml(manifest_x *mfx);
715
716 /**
717  * @fn manifest_x *pkgmgr_parser_process_manifest_xml(const char *manifest)
718  * @fn manifest_x *pkgmgr_parser_usr_process_manifest_xml(const char *manifest, uid_t uid)
719  * @brief       This API parses the manifest file and stores all the data in the manifest structure.
720  *
721  * @par         This API is for package-manager installer backends.
722  * @par Sync (or) Async : Synchronous API
723  *
724  * @param[in]   manifest        pointer to package manifest file
725  * @param[in]   uid     the addressee user id of the instruction
726  * @return      manifest pointer on success, NULL on failure
727  * @pre         None
728  * @post                pkgmgr_parser_free_manifest_xml()
729  * @code
730 static int parse_manifest_file(const char *manifest)
731 {
732         manifest_x *mfx = NULL
733         mfx = pkgmgr_parser_process_manifest_xml(manifest);
734         if (mfx == NULL)
735                 return -1;
736         printf("Parsing Manifest Success\n");
737         pkgmgr_parser_free_manifest_xml(mfx);
738         return 0;
739 }
740  * @endcode
741  */
742 manifest_x *pkgmgr_parser_process_manifest_xml(const char *manifest);
743 manifest_x *pkgmgr_parser_usr_process_manifest_xml(const char *manifest, uid_t uid);
744
745 /**
746  * @fn manifest_x *pkgmgr_parser_get_manifest_info(const char *pkigid)
747  * @brief       This API gets the manifest info from DB and stores all the data in the manifest structure.
748  *
749  * @par         This API is for package-manager installer backends.
750  * @par Sync (or) Async : Synchronous API
751  *
752  * @param[in]   pkgid   package id for package
753  * @return      manifest pointer on success, NULL on failure
754  * @pre         None
755  * @post                pkgmgr_parser_free_manifest_xml()
756  * @code
757 static int get_manifest_info(const char *pkgid)
758 {
759         manifest_x *mfx = NULL
760         mfx = pkgmgr_parser_get_manifest_info(pkgid);
761         if (mfx == NULL)
762                 return -1;
763         printf("Parsing Manifest Success\n");
764         pkgmgr_parser_free_manifest_xml(mfx);
765         return 0;
766 }
767  * @endcode
768  */
769 manifest_x *pkgmgr_parser_get_manifest_info(const char *pkigid);
770
771 /* These APIs are intended to call parser directly */
772 typedef int (*ps_iter_fn) (const char *tag, int type, void *userdata);
773
774 int pkgmgr_parser_has_parser(const char *tag, int *type);
775 int pkgmgr_parser_get_list(ps_iter_fn iter_fn, void *data);
776
777 /**
778  * @fn int pkgmgr_parser_run_parser_for_installation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
779  * @brief       This API calls the parser directly by supplying the xml docptr. It is used during package installation
780  *
781  * @par         This API is for package-manager installer backends.
782  * @par Sync (or) Async : Synchronous API
783  *
784  * @param[in]   docPtr  XML doxument pointer
785  * @param[in]   tag             the xml tag corresponding to the parser that will parse the docPtr
786  * @param[in]   pkgid           the package id
787  * @return      0 if success, error code(<0) if fail
788  * @retval      PMINFO_R_OK     success
789  * @retval      PMINFO_R_EINVAL invalid argument
790  * @retval      PMINFO_R_ERROR  internal error
791  * @pre         None
792  * @post                None
793  * @code
794 static int parse_docptr_for_installation(xmlDocPtr docPtr)
795 {
796         int ret = 0;
797         ret = pkgmgr_parser_run_parser_for_installation(docPtr, "theme", "com.samsung.test");
798         if (ret)
799                 return -1;
800         return 0;
801 }
802  * @endcode
803  */
804 int pkgmgr_parser_run_parser_for_installation(xmlDocPtr docPtr, const char *tag, const char *pkgid);
805
806 /**
807  * @fn int pkgmgr_parser_run_parser_for_upgrade(xmlDocPtr docPtr, const char *tag, const char *pkgid)
808  * @brief       This API calls the parser directly by supplying the xml docptr. It is used during package upgrade
809  *
810  * @par         This API is for package-manager installer backends.
811  * @par Sync (or) Async : Synchronous API
812  *
813  * @param[in]   docPtr  XML doxument pointer
814  * @param[in]   tag             the xml tag corresponding to the parser that will parse the docPtr
815  * @param[in]   pkgid           the package id
816  * @return      0 if success, error code(<0) if fail
817  * @retval      PMINFO_R_OK     success
818  * @retval      PMINFO_R_EINVAL invalid argument
819  * @retval      PMINFO_R_ERROR  internal error
820  * @pre         None
821  * @post                None
822  * @code
823 static int parse_docptr_for_upgrade(xmlDocPtr docPtr)
824 {
825         int ret = 0;
826         ret = pkgmgr_parser_run_parser_for_upgrade(docPtr, "theme", "com.samsung.test");
827         if (ret)
828                 return -1;
829         return 0;
830 }
831  * @endcode
832  */
833 int pkgmgr_parser_run_parser_for_upgrade(xmlDocPtr docPtr, const char *tag, const char *pkgid);
834
835 /**
836  * @fn int pkgmgr_parser_run_parser_for_uninstallation(xmlDocPtr docPtr, const char *tag, const char *pkgid)
837  * @brief       This API calls the parser directly by supplying the xml docptr. It is used during package uninstallation
838  *
839  * @par         This API is for package-manager installer backends.
840  * @par Sync (or) Async : Synchronous API
841  *
842  * @param[in]   docPtr  XML doxument pointer
843  * @param[in]   tag             the xml tag corresponding to the parser that will parse the docPtr
844  * @param[in]   pkgid           the package id
845  * @return      0 if success, error code(<0) if fail
846  * @retval      PMINFO_R_OK     success
847  * @retval      PMINFO_R_EINVAL invalid argument
848  * @retval      PMINFO_R_ERROR  internal error
849  * @pre         None
850  * @post                None
851  * @code
852 static int parse_docptr_for_uninstallation(xmlDocPtr docPtr)
853 {
854         int ret = 0;
855         ret = pkgmgr_parser_run_parser_for_uninstallation(docPtr, "theme", "com.samsung.test");
856         if (ret)
857                 return -1;
858         return 0;
859 }
860  * @endcode
861  */
862 int pkgmgr_parser_run_parser_for_uninstallation(xmlDocPtr docPtr, const char *tag, const char *pkgid);
863
864
865
866 /**
867  * @fn int pkgmgr_parser_create_desktop_file(manifest_x *mfx)
868  * @fn int pkgmgr_parser_create_usr_desktop_file(manifest_x *mfx, uid_t uid)
869  * @brief       This API generates the application desktop file
870  *
871  * @par         This API is for package-manager installer backends.
872  * @par Sync (or) Async : Synchronous API
873  *
874  * @param[in]   mfx     manifest pointer
875  * @param[in]   uid     the addressee user id of the instruction
876  * @return      0 if success, error code(<0) if fail
877  * @retval      PMINFO_R_OK     success
878  * @retval      PMINFO_R_EINVAL invalid argument
879  * @retval      PMINFO_R_ERROR  internal error
880  * @pre         pkgmgr_parser_process_manifest_xml()
881  * @post        pkgmgr_parser_free_manifest_xml()
882  * @code
883 static int create_desktop_file(char *manifest)
884 {
885         int ret = 0;
886         manifest_x *mfx = NULL;
887         mfx = pkgmgr_parser_process_manifest_xml(manifest);
888         ret = pkgmgr_parser_create_desktop_file(mfx);
889         if (ret)
890                 return -1;
891         pkgmgr_parser_free_manifest_xml(mfx);
892         return 0;
893 }
894  * @endcode
895  */
896 int pkgmgr_parser_create_desktop_file(manifest_x *mfx);
897 int pkgmgr_parser_create_usr_desktop_file(manifest_x *mfx, uid_t uid);
898
899 /** @} */
900 #ifdef __cplusplus
901 }
902 #endif
903 #endif                          /* __PKGMGR_PARSER_H__ */