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