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