comm/pkgmgr_installer.h

   1 /*
   2  * slp-pkgmgr
   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
  24 #include <sys/types.h>
  25
  26 #ifndef __PKGMGR_INSTALLER_H__
  27 #define __PKGMGR_INSTALLER_H__
  28
  29 /**
  30  * @file pkgmgr_installer.h
  31  * @author Youmin Ha <youmin.ha@samsung.com>
  32  * @version 0.1
  33  * @brief    This file declares API of pkgmgr_installer
  34  */
  35
  36 #ifdef __cplusplus
  37 extern "C" {
  38 #endif
  39
  40
  41 /**
  42  * pkgmgr_installer is an opaque type for an object
  43  */
  44 typedef struct pkgmgr_installer pkgmgr_installer;
  45 typedef void* pkgmgr_instcertinfo_h;
  46
  47 /**
  48  * @brief listening event type in pkgmgr.
  49  */
  50 #define PKGMGR_INSTALLER_START_KEY_STR           "start"
  51 #define PKGMGR_INSTALLER_END_KEY_STR             "end"
  52 #define PKGMGR_INSTALLER_ERROR_KEY_STR           "error"
  53 #define PKGMGR_INSTALLER_APPID_KEY_STR           "appid"
  54 #define PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR "install_percent"
  55 #define PKGMGR_INSTALLER_GET_SIZE_KEY_STR        "get_size"
  56
  57 #define PKGMGR_INSTALLER_INSTALL_EVENT_STR       "install"
  58 #define PKGMGR_INSTALLER_UNINSTALL_EVENT_STR     "uninstall"
  59 #define PKGMGR_INSTALLER_CLEAR_EVENT_STR         "clear"
  60 #define PKGMGR_INSTALLER_MOVE_EVENT_STR          "move"
  61 #define PKGMGR_INSTALLER_UPGRADE_EVENT_STR       "update"
  62 #define PKGMGR_INSTALLER_OK_EVENT_STR            "ok"
  63 #define PKGMGR_INSTALLER_FAIL_EVENT_STR          "fail"
  64
  65
  66
  67
  68 /**
  69  * Request type.
  70  */
  71 enum {
  72         PKGMGR_REQ_PERM = -1,
  73         PKGMGR_REQ_INVALID = 0,
  74         PKGMGR_REQ_INSTALL = 1,
  75         PKGMGR_REQ_UNINSTALL = 2,
  76         PKGMGR_REQ_CLEAR = 3,
  77         PKGMGR_REQ_MOVE = 4,
  78         PKGMGR_REQ_RECOVER = 5,
  79         PKGMGR_REQ_REINSTALL = 6,
  80         PKGMGR_REQ_GETSIZE = 7,
  81         PKGMGR_REQ_UPGRADE = 8,
  82         PKGMGR_REQ_SMACK = 9,
  83         PKGMGR_REQ_MANIFEST_DIRECT_INSTALL = 10,
  84         PKGMGR_REQ_ENABLE_DISABLE_APP = 11
  85 };
  86
  87 enum {
  88         PKGMGR_INSTALLER_EINVAL = -2,           /**< Invalid argument */
  89         PKGMGR_INSTALLER_ERROR = -1,            /**< General error */
  90         PKGMGR_INSTALLER_EOK = 0                        /**< General success */
  91 };
  92
  93
  94 typedef enum {
  95         PM_SET_AUTHOR_ROOT_CERT = 0,
  96         PM_SET_AUTHOR_INTERMEDIATE_CERT = 1,
  97         PM_SET_AUTHOR_SIGNER_CERT = 2,
  98         PM_SET_DISTRIBUTOR_ROOT_CERT = 3,
  99         PM_SET_DISTRIBUTOR_INTERMEDIATE_CERT = 4,
 100         PM_SET_DISTRIBUTOR_SIGNER_CERT = 5,
 101         PM_SET_DISTRIBUTOR2_ROOT_CERT = 6,
 102         PM_SET_DISTRIBUTOR2_INTERMEDIATE_CERT = 7,
 103         PM_SET_DISTRIBUTOR2_SIGNER_CERT = 8,
 104 }pkgmgr_instcert_type;
 105
 106
 107 /**
 108  * @brief       Create a pkgmgr_installer object.
 109  * @pre         None
 110  * @post        pkgmgr_installer object must be freed.
 111  * @see         pkgmgr_installer_free
 112  * @return      pkgmgr_installer object
 113  * @retval      NULL    on failure creating an object
 114  * @remark      None
 115 @code
 116 #include <pkgmgr_installer.h>
 117 pkgmgr_installer *pi = pkgmgr_installer_new();
 118 pkgmgr_installer_free(pi);
 119 @endcode
 120  */
 121 pkgmgr_installer *pkgmgr_installer_new(void);
 122
 123 /**
 124  * @brief       Create a pkgmgr_installer object in offline mode
 125  * @pre         None
 126  * @post        pkgmgr_installer object must be freed.
 127  * @see         pkgmgr_installer_free
 128  * @return      pkgmgr_installer object
 129  * @retval      NULL    on failure creating an object
 130  * @remark      None
 131 @code
 132 #include <pkgmgr_installer.h>
 133 pkgmgr_installer *pi = pkgmgr_installer_offline_new();
 134 pkgmgr_installer_free(pi);
 135 @endcode
 136  */
 137 pkgmgr_installer *pkgmgr_installer_offline_new(void);
 138
 139 /**
 140         @brief          Free a pkgmgr_installer object
 141         @pre            pi must be a valid object.
 142         @post           None
 143         @see            pkgmgr_installer_new
 144         @param[in]      pi      A pkgmgr_installer object
 145         @return         Operation result
 146         @retval         0       on success
 147         @retval         -errno  on error
 148         @remark         None
 149         @code
 150 #include <pkgmgr_installer.h>
 151 pkgmgr_installer *pi = pkgmgr_installer_new();
 152 pkgmgr_installer_free(pi);
 153         @endcode
 154  */
 155 int pkgmgr_installer_free(pkgmgr_installer *pi);
 156
 157 /**
 158         @brief          Receive a request from argv
 159         @pre            None
 160         @post           pkgmgr_installer_get_*(), pkgmgr_installer_is_quiet() can be called.
 161         @see            pkgmgr_installer_get_request_type, pkgmgr_installer_get_request_info, pkgmgr_installer_get_session_id, pkgmgr_installer_is_quiet
 162         @param[in]      pi      a pkgmgr_installer object
 163         @param[in]      argc    argc from system
 164         @param[in]      argv    argv from system
 165         @return         Operation result
 166         @retval         0 on success
 167         @retval         -errno on failure
 168         @remark         None
 169         @code
 170 #include <pkgmgr_installer.h>
 171 int main(int argc, char **argv)
 172 {
 173         pkgmgr_installer *pi;
 174         int r;
 175
 176         pi = pkgmgr_installer_new();
 177         int r = pkgmgr_installer_receive_request(pi, argc, argv);
 178         pkgmgr_installer_free(pi);
 179
 180         return 0;
 181 }
 182         @endcode
 183  */
 184 int pkgmgr_installer_receive_request(pkgmgr_installer *pi,
 185                                      const int argc, char **argv);
 186
 187 /**
 188         @brief          Get request type
 189         @pre            pkgmgr_installer_receive_request() must be called.
 190         @post           None
 191         @see            pkgmgr_installer_receive_request
 192         @param[in]      pi      pkgmgr_installer object
 193         @return         Request type (One of PKGMGR_REQ_* enum values)
 194         @remark         None
 195         @code
 196 int main(int argc, char **argv)
 197 {
 198         pkgmgr_installer *pi;
 199         int r = 0;
 200
 201         pi = pkgmgr_installer_new();
 202         if(!pi) return -1;
 203         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 204                 r = -1;
 205                 goto CLEANUP_RET;
 206         }
 207
 208         switch(pkgmgr_installer_get_request_type(pi)) {
 209                 case PKGMGR_REQ_PERM:
 210                         // Do error processing
 211                         break;
 212                 case PKGMGR_REQ_INVALID:
 213                         // Do error processing
 214                         r = -1;
 215                         break;
 216                 case PKGMGR_REQ_INSTALL:
 217                         // Do install processing
 218                         break;
 219                 case PKGMGR_REQ_UNINSTALL:
 220                         // Do uninstall processing
 221                         break;
 222                 case PKGMGR_REQ_RECOVER:
 223                         // Do recovere processing
 224                         break;
 225                 case PKGMGR_REQ_REINSTALL:
 226                         // Do reinstall processing
 227                         break;
 228                 default:
 229                         goto CLEANUP_END;
 230         }
 231 CLEANUP_END:
 232         pkgmgr_installer_free(pi);
 233
 234         return r;
 235 }
 236         @endcode
 237  */
 238 int pkgmgr_installer_get_request_type(pkgmgr_installer *pi);
 239
 240 /**
 241         @brief          Get request info
 242         @pre            pkgmgr_installer_receive_request() must be called.
 243         @post           None
 244         @see            pkgmgr_installer_receive_request
 245         @param[in]      pi      pkgmgr_installer object
 246         @return         Request info. When PKGMGR_REQ_INSTALL, this is a package file path to be installed. When PKGMGR_REQ_UNINSTALL, this is a package name to be uninstalled.
 247         @retval         NULL    on function failure
 248         @remark         Returned string must not be modified.
 249         @code
 250 #include <pkgmgr_installer.h>
 251 int main(int argc, char **argv)
 252 {
 253         pkgmgr_installer *pi;
 254         int r = 0;
 255         char *req_info = NULL;
 256
 257         pi = pkgmgr_installer_new();
 258         if(!pi) return -1;
 259         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 260                 r = -1;
 261                 goto CLEANUP_RET;
 262         }
 263         req_info = (char *) pkgmgr_installer_get_request_info(pi);
 264
 265         // Do something...
 266
 267         pkgmgr_installer_free(pi);
 268         return r;
 269 }
 270         @endcode
 271  */
 272 const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi);
 273
 274 /**
 275         @brief          Get TEP path
 276         @pre            pkgmgr_installer_receive_request() must be called.
 277         @post           None
 278         @see            pkgmgr_installer_receive_request
 279         @param[in]      pi      pkgmgr_installer object
 280         @return         TEP path if exists
 281         @retval         NULL    on function failure
 282         @remark         Returned string must not be modified.
 283         @code
 284 #include <pkgmgr_installer.h>
 285 int main(int argc, char **argv)
 286 {
 287         pkgmgr_installer *pi;
 288         int r = 0;
 289         char *tep_path = NULL;
 290
 291         pi = pkgmgr_installer_new();
 292         if(!pi) return -1;
 293         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 294                 r = -1;
 295                 goto CLEANUP_RET;
 296         }
 297         tep_path = (char *) pkgmgr_installer_get_tep_path(pi);
 298
 299         // Do something...
 300
 301         pkgmgr_installer_free(pi);
 302         return r;
 303 }
 304 @endcode
 305  */
 306 const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi);
 307
 308 /**
 309         @brief          Get TEP move type
 310         @pre            pkgmgr_installer_receive_request() must be called.
 311         @post           None
 312         @see            pkgmgr_installer_receive_request
 313         @param[in]      pi      pkgmgr_installer object
 314         @return         integer value indicates tep move type(0: copy TEP file / 1: move TEP file)
 315         @retval         0       on function failure
 316         @remark         Returned string must not be modified.
 317         @code
 318 #include <pkgmgr_installer.h>
 319 int main(int argc, char **argv)
 320 {
 321         pkgmgr_installer *pi;
 322         int r = 0;
 323         int tep_move_type = -1;
 324
 325         pi = pkgmgr_installer_new();
 326         if(!pi) return -1;
 327         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 328                 r = -1;
 329                 goto CLEANUP_RET;
 330         }
 331         tep_move_type = pkgmgr_installer_get_tep_move_type(pi);
 332
 333         // Do something...
 334
 335         pkgmgr_installer_free(pi);
 336         return r;
 337 }
 338 @endcode
 339  */
 340 int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi);
 341
 342 /**
 343         @brief          Get session ID for a certain session
 344         @pre            pkgmgr_installer_receive_request() must be called.
 345         @post           None
 346         @see            pkgmgr_installer_receive_request
 347         @param[in]      pi      pkgmgr_installer object
 348         @return         A session ID
 349         @retval         NULL    on function failure
 350         @remark         Returned string must not be modified.
 351         @code
 352 #include <pkgmgr_installer.h>
 353 int main(int argc, char **argv)
 354 {
 355         pkgmgr_installer *pi;
 356         int r = 0;
 357         char *session_id = NULL;
 358
 359         pi = pkgmgr_installer_new();
 360         if(!pi) return -1;
 361         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 362                 r = -1;
 363                 goto CLEANUP_RET;
 364         }
 365         session_id = (char *) pkgmgr_installer_get_session_id(pi);
 366
 367         // Do something...
 368
 369         pkgmgr_installer_free(pi);
 370         return r;
 371 }
 372 @endcode
 373  */
 374 const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi);
 375
 376 /**
 377         @brief          Get a license path
 378         @pre            pkgmgr_installer_receive_request() must be called.
 379         @post           None
 380         @see            pkgmgr_installer_receive_request
 381         @param[in]      pi      pkgmgr_installer object
 382         @return         license path
 383         @retval         NULL    on function failure
 384         @remark         Returned string must not be modified.
 385         @code
 386 #include <pkgmgr_installer.h>
 387 int main(int argc, char **argv)
 388 {
 389         pkgmgr_installer *pi;
 390         int r = 0;
 391         char *license_path = NULL;
 392
 393         pi = pkgmgr_installer_new();
 394         if(!pi) return -1;
 395         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 396                 r = -1;
 397                 goto CLEANUP_RET;
 398         }
 399         session_id = (char *) pkgmgr_installer_get_license_path(pi);
 400
 401         // Do something...
 402
 403         pkgmgr_installer_free(pi);
 404         return r;
 405 }
 406 @endcode
 407  */
 408 const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi);
 409
 410 /**
 411         @brief          Get a optional data
 412         @pre            pkgmgr_installer_receive_request() must be called.
 413         @post           None
 414         @see            pkgmgr_installer_receive_request
 415         @param[in]      pi      pkgmgr_installer object
 416         @return         optional data
 417         @retval         NULL    on function failure
 418         @remark         Returned string must not be modified.
 419         @code
 420 #include <pkgmgr_installer.h>
 421 int main(int argc, char **argv)
 422 {
 423         pkgmgr_installer *pi;
 424         int r = 0;
 425         char *optional_data = NULL;
 426
 427         pi = pkgmgr_installer_new();
 428         if(!pi) return -1;
 429         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 430                 r = -1;
 431                 goto CLEANUP_RET;
 432         }
 433         optional_data = (char *) pkgmgr_installer_get_optional_data(pi);
 434
 435         // Do something...
 436
 437         pkgmgr_installer_free(pi);
 438         return r;
 439 }
 440 @endcode
 441  */
 442 const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi);
 443
 444 /**
 445         @brief          Get if a request is with quite mode or not
 446         @pre            pkgmgr_installer_receive_request() must be called.
 447         @post           None
 448         @see            pkgmgr_installer_receive_request
 449         @param[in]      pi      pkgmgr_installer object
 450         @return         Operation result
 451         @retval         0 if a request is not quiet mode
 452         @retval         1 if a request is quiet mode
 453         @remark         None
 454         @code
 455 #include <pkgmgr_installer.h>
 456 int main(int argc, char **argv)
 457 {
 458         pkgmgr_installer *pi;
 459         int r = 0;
 460
 461         pi = pkgmgr_installer_new();
 462         if(!pi) return -1;
 463         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 464                 r = -1;
 465                 goto CLEANUP_RET;
 466         }
 467         if(pkgmgr_installer_is_quiet(pi)) {
 468                 // Do quiet mode work...
 469         } else {
 470                 // Do normal mode work...
 471         }
 472
 473         pkgmgr_installer_free(pi);
 474         return r;
 475 }
 476         @endcode
 477  */
 478 int pkgmgr_installer_is_quiet(pkgmgr_installer *pi);
 479
 480 /**
 481         @brief          Get move type
 482         @pre            pkgmgr_installer_receive_request() must be called.
 483         @post           None
 484         @see            pkgmgr_installer_receive_request
 485         @param[in]      pi      pkgmgr_installer object
 486         @return         Operation result
 487         @retval         enum value of move type
 488         @remark         None
 489         @code
 490 #include <pkgmgr_installer.h>
 491 int main(int argc, char **argv)
 492 {
 493         pkgmgr_installer *pi;
 494         int r = 0;
 495
 496         pi = pkgmgr_installer_new();
 497         if(!pi) return -1;
 498         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 499                 r = -1;
 500                 goto CLEANUP_RET;
 501         }
 502         move_type = pkgmgr_installer_get_move_type(pi);
 503
 504         //Do Something
 505
 506         pkgmgr_installer_free(pi);
 507         return r;
 508 }
 509         @endcode
 510  */
 511 int pkgmgr_installer_get_move_type(pkgmgr_installer *pi);
 512
 513 /**
 514         @brief          Get caller package id
 515         @pre            pkgmgr_installer_receive_request() must be called.
 516         @post           None
 517         @see            pkgmgr_installer_receive_request
 518         @param[in]      pi      pkgmgr_installer object
 519         @return         Operation result
 520         @retval         enum value of move type
 521         @remark         None
 522         @code
 523 #include <pkgmgr_installer.h>
 524 int main(int argc, char **argv)
 525 {
 526         pkgmgr_installer *pi;
 527         int r = 0;
 528         char *pkgid = NULL;
 529
 530         pi = pkgmgr_installer_new();
 531         if(!pi) return -1;
 532         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 533                 r = -1;
 534                 goto CLEANUP_RET;
 535         }
 536         pkgid = (char *) pkgmgr_installer_get_caller_pkgid(pi);
 537
 538         // Do something...
 539
 540         pkgmgr_installer_free(pi);
 541         return r;
 542 }
 543         @endcode
 544  */
 545 const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi);
 546
 547 /**
 548         @brief          Get if the request is for preload app or not
 549         @pre            pkgmgr_installer_receive_request() must be called.
 550         @post           None
 551         @see            pkgmgr_installer_receive_request
 552         @param[in]      pi      pkgmgr_installer object
 553         @return         Operation result
 554         @retval         0 if a request is not for preload
 555         @retval         1 if a request is for preload
 556         @remark         None
 557         @code
 558 #include <pkgmgr_installer.h>
 559 int main(int argc, char **argv)
 560 {
 561         pkgmgr_installer *pi;
 562         int r = 0;
 563         int is_preload = 0;
 564
 565         pi = pkgmgr_installer_new();
 566         if(!pi) return -1;
 567         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 568                 r = -1;
 569                 goto CLEANUP_RET;
 570         }
 571         preload = pkgmgr_installer_get_is_preload(pi);
 572
 573         // Do something...
 574
 575         pkgmgr_installer_free(pi);
 576         return r;
 577 }
 578         @endcode
 579  */
 580 int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi);
 581
 582 /**
 583         @brief          Send a process status signal
 584         @pre            None
 585         @post           None
 586         @see            None
 587         @param[in]      pi      pkgmgr_installer object
 588         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 589         @param[in]      pkgid   package id
 590         @param[in]      key                     Signal key
 591         @param[in]      val                     Signal value
 592         @return         Operation result
 593         @retval         0 on success
 594         @retval         -errno on failure
 595         @remark         If pkgmgr_installer_receive_request() is not called, the session ID will be null string (=="/0").
 596         @code
 597 #include <pkgmgr_installer.h>
 598 int main(int argc, char **argv)
 599 {
 600         pkgmgr_installer *pi;
 601         int r = 0;
 602         char *session_id = NULL;
 603
 604         pi = pkgmgr_installer_new();
 605         if(!pi) return -1;
 606         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 607                 r = -1;
 608                 goto CLEANUP_RET;
 609         }
 610
 611         // Do something...
 612         pkgmgr_installer_send_signal(pi,
 613          "deb", "org.tizen.foo", "install_percent", "100");
 614         // A sample signal
 615
 616         pkgmgr_installer_free(pi);
 617         return r;
 618 }
 619         @endcode
 620  */
 621 int pkgmgr_installer_send_signal(pkgmgr_installer *pi,
 622                                  const char *pkg_type,
 623                                  const char *pkgid, const char *key,
 624                                  const char *val);
 625
 626 /**
 627         @brief          Send a signal which indicates application is being uninstalled
 628         @pre            None
 629         @post           None
 630         @see            None
 631         @param[in]      pi      pkgmgr_installer object
 632         @param[in]      pkg_type        package type: "deb", "jar", "wgt", ...
 633         @param[in]      pkgid   package id
 634         @param[in]      key                     Signal key
 635         @param[in]      val                     Signal value
 636         @return         Operation result
 637         @retval         0 on success
 638         @retval         -errno on failure
 639         @code
 640 #include <pkgmgr_installer.h>
 641 int main(int argc, char **argv)
 642 {
 643         pkgmgr_installer *pi;
 644         int r = 0;
 645         char *session_id = NULL;
 646
 647         pi = pkgmgr_installer_new();
 648         if(!pi) return -1;
 649         if(pkgmgr_installer_receive_request(pi, argc, argv)) {
 650                 r = -1;
 651                 goto CLEANUP_RET;
 652         }
 653
 654         // Do something...
 655         pkgmgr_installer_send_app_uninstall_signal(pi,
 656          "tpk", "org.tizen.foo");
 657         // A sample signal
 658
 659         pkgmgr_installer_free(pi);
 660         return r;
 661 }
 662         @endcode
 663  */
 664 int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
 665                              const char *pkg_type,
 666                              const char *pkgid,
 667                              const char *val);
 668
 669 /**
 670  * @brief       This API sets the requst info of given pkgmgr_installer.
 671  *
 672  *              This API is for package-manager client application.\n
 673  *
 674  * @param[in]pi                         pointer to pkgmgr_installer
 675  * @param[in]   request_type                            request type
 676  * @return      0 if success, error code(<0) if fail\n
 677 */
 678 int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type);
 679
 680 /**
 681  * @brief       This API sets the session ID.
 682  *
 683  *              This API is for package-manager client application.\n
 684  *
 685  * @param[in]   pi                              pointer to pkgmgr_installer
 686  * @param[in]   session_id                              session ID to be set
 687  * @return      0 if success, error code(<0) if fail\n
 688 */
 689 int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, char *session_id);
 690
 691 /**
 692  * @brief       This API creates the certinfo handle.
 693  *
 694  *              This API is for package-manager client application.\n
 695  *
 696  * @param[out]  handle                          pointer to cert info handle
 697  * @return      0 if success, error code(<0) if fail\n
 698 */
 699 int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle);
 700
 701 /**
 702  * @brief       This API sets cert value for corresponding cert type.
 703  *
 704  *              This API is for package-manager client application.\n
 705  *
 706  * @param[in]   handle                          pointer to cert info handle
 707  * @param[in]   cert_type                       enum value for certificate type
 708  * @param[in]   cert_value                      certificate value
 709  * @return      0 if success, error code(<0) if fail\n
 710 */
 711 int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value);
 712
 713 /**
 714  * @brief       This API saves cert info in DB.
 715  *
 716  *              This API is for package-manager client application.\n
 717  *
 718  * @param[in]   pkgid                           package ID
 719  * @param[in]   handle                          pointer to cert info handle
 720  * @return      0 if success, error code(<0) if fail\n
 721 */
 722 int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid);
 723
 724 /**
 725  * @brief       This API destroys cert info handle freeing all resources.
 726  *
 727  *              This API is for package-manager client application.\n
 728  *
 729  * @param[in]   handle                          pointer to cert info handle
 730  * @return      0 if success, error code(<0) if fail\n
 731 */
 732 int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle);
 733
 734 /**
 735  * @brief       This API deletes cert info from DB. To be used to cleanup info upon pkg uninstallation
 736  *
 737  *              This API is for package-manager client application.\n
 738  *
 739  * @param[in]   pkgid                           package ID
 740  * @return      0 if success, error code(<0) if fail\n
 741 */
 742  int pkgmgr_installer_delete_certinfo(const char *pkgid);
 743
 744 #ifdef __cplusplus
 745 }
 746 #endif
 747
 748 #endif                          /* __PKGMGR_INSTALLER_H__ */
 749