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__ */