installer/src/api_stub.cc

   1 /*
   2 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 #include "pkgmgr_installer.h"
  19 #include "pkgmgr_installer_debug.h"
  20 #include "pkgmgr_installer_info.h"
  21
  22 #include <tzplatform_config.h>
  23 #include <unistd.h>
  24
  25 #include "control.hh"
  26
  27 #include <pkgmgr-info.h>
  28
  29 #ifdef API
  30 #undef API
  31 #endif
  32 #define API __attribute__ ((visibility("default")))
  33
  34 #define CHK_PI_RET(r) \
  35   do { if (nullptr == pi) return (r); } while (0)
  36
  37 static uid_t g_target_uid;
  38
  39 API pkgmgr_installer* pkgmgr_installer_new() {
  40   try {
  41     return new pkgmgr::installer::Control();
  42   } catch (...) {
  43     _E("pkgmgr_installer_new fail");
  44     return nullptr;
  45   }
  46
  47   return nullptr;
  48 }
  49
  50 API pkgmgr_installer* pkgmgr_installer_offline_new() {
  51   return new pkgmgr::installer::Control(true);
  52 }
  53
  54 API int pkgmgr_installer_free(pkgmgr_installer* pi) {
  55   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
  56   delete cls;
  57   return 0;
  58 }
  59
  60 API int pkgmgr_installer_receive_request(pkgmgr_installer *pi,
  61     const int argc, char **argv) {
  62   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
  63
  64   int ret = cls->SetRequestFromArgv(argc, argv);
  65   if (ret < 0)
  66     return ret;
  67
  68   /* if target user is not set, set as tizenglobalapp user */
  69   if (cls->GetRequest()->GetUid() == 0)
  70     cls->GetRequest()->SetUid(tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
  71
  72   g_target_uid = cls->GetRequest()->GetUid();
  73
  74   return 0;
  75 }
  76
  77 API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi) {
  78   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
  79   if (!cls->GetRequest())
  80     return PKGMGR_REQ_INVALID;
  81   return cls->GetRequest()->GetRequestType();
  82 }
  83
  84 API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi) {
  85   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
  86   if (!cls->GetRequest())
  87     return PKGMGR_REQ_INVALID;
  88   return cls->GetRequest()->GetUid();
  89 }
  90
  91 API const char* pkgmgr_installer_get_request_info(pkgmgr_installer *pi) {
  92   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
  93   if (!cls->GetRequest())
  94     return nullptr;
  95   return cls->GetRequest()->GetRequestInfo().c_str();
  96 }
  97
  98 API const char* pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
  99     int at) {
 100   CHK_PI_RET(nullptr);
 101   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 102   auto& rq = cls->GetRequest();
 103   if (!rq)
 104     return nullptr;
 105
 106   const auto& requests = rq->GetRequests();
 107   if (requests.size() <= at)
 108     return nullptr;
 109
 110   return requests[at].c_str();
 111 }
 112
 113 API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi) {
 114   CHK_PI_RET(PKGMGR_REQ_INVALID);
 115   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 116   auto& rq = cls->GetRequest();
 117   if (!rq)
 118     return PKGMGR_REQ_INVALID;
 119
 120   return rq->GetRequests().size();
 121 }
 122
 123 API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi) {
 124   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 125   if (!cls->GetRequest())
 126     return nullptr;
 127   return cls->GetRequest()->GetTepPath().c_str();
 128 }
 129
 130 API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi) {
 131   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 132   if (!cls->GetRequest())
 133     return PKGMGR_REQ_INVALID;
 134   return cls->GetRequest()->IsTepMove() ? 1 : 0;
 135 }
 136
 137 API const char* pkgmgr_installer_get_session_id(pkgmgr_installer *pi) {
 138   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 139   if (!cls->GetRequest())
 140     return nullptr;
 141   return cls->GetRequest()->GetSessionId().c_str();
 142 }
 143
 144 API const char* pkgmgr_installer_get_license_path(pkgmgr_installer *pi) {
 145   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 146   if (!cls->GetRequest())
 147     return nullptr;
 148   return cls->GetRequest()->GetLicensePath().c_str();
 149 }
 150
 151 API const char* pkgmgr_installer_get_optional_data(pkgmgr_installer *pi) {
 152   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 153   if (!cls->GetRequest())
 154     return nullptr;
 155   return cls->GetRequest()->GetOptionalData().c_str();
 156 }
 157
 158 API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi) {
 159   return 1;
 160 }
 161
 162 API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi) {
 163   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 164   if (!cls->GetRequest())
 165     return PKGMGR_REQ_INVALID;
 166   return cls->GetRequest()->GetMoveType();
 167 }
 168
 169 API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi) {
 170   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 171   if (!cls->GetRequest())
 172     return nullptr;
 173   return cls->GetRequest()->GetCallerPkgid().c_str();
 174 }
 175
 176 API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi) {
 177   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 178   if (!cls->GetRequest())
 179     return PKGMGR_REQ_INVALID;
 180   return cls->GetRequest()->IsPreload() ? 1 : 0;
 181 }
 182
 183 API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi) {
 184   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 185   if (!cls->GetRequest())
 186     return PKGMGR_REQ_INVALID;
 187   return cls->GetRequest()->IsForceRemoval() ? 1 : 0;
 188 }
 189
 190 API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi) {
 191   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 192   if (!cls->GetRequest())
 193     return PKGMGR_REQ_INVALID;
 194   return cls->GetRequest()->IsPreloadRw() ? 1 : 0;
 195 }
 196
 197 API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi) {
 198   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 199   if (!cls->GetRequest())
 200     return PKGMGR_REQ_INVALID;
 201   return cls->GetRequest()->IsNoRemoval() ? 1 : 0;
 202 }
 203
 204 API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi) {
 205   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 206   if (!cls->GetRequest())
 207     return PKGMGR_REQ_INVALID;
 208   return cls->GetRequest()->IsKeepRwData() ? 1 : 0;
 209 }
 210
 211 API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi) {
 212   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 213   if (!cls->GetRequest())
 214     return PKGMGR_REQ_INVALID;
 215   return cls->GetRequest()->IsPartialRw() ? 1 : 0;
 216 }
 217
 218 API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi) {
 219   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 220   if (!cls->GetRequest())
 221     return PKGMGR_REQ_INVALID;
 222   return cls->GetRequest()->IsDebugMode() ? 1 : 0;
 223 }
 224
 225 API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi) {
 226   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 227   if (!cls->GetRequest())
 228     return PKGMGR_REQ_INVALID;
 229   return cls->GetRequest()->IsSkipCheckReference() ? 1 : 0;
 230 }
 231
 232 API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi) {
 233   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 234   if (!cls->GetRequest())
 235     return PKGMGR_REQ_INVALID;
 236   return cls->GetRequest()->IsSkipOptimization() ? 1 : 0;
 237 }
 238
 239 API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi) {
 240   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 241   if (!cls->GetRequest())
 242     return PKGMGR_REQ_INVALID;
 243   return cls->GetRequest()->IsRecoveryCleanup() ? 1 : 0;
 244 }
 245
 246 API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
 247     const char *pkg_type, const char *pkgid, const char *val) {
 248   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 249   if (!cls->GetRequest())
 250     return -1;
 251   return cls->SendSignal(pkg_type, pkgid, "", PKGMGR_INSTALLER_APPID_KEY_STR, val);
 252 }
 253
 254 API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
 255     pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
 256     const char *pkgid, const char *val) {
 257   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 258   if (!cls->GetRequest())
 259     return -1;
 260   return cls->SendSignalForUid(uid, pkg_type, pkgid, "", PKGMGR_INSTALLER_APPID_KEY_STR, val);
 261 }
 262
 263 API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid) {
 264   if (pi == NULL)
 265     return -1;
 266
 267   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 268   if (!cls->GetRequest())
 269     return -1;
 270
 271   cls->GetRequest()->SetUid(uid);
 272
 273   g_target_uid = uid;
 274
 275   return 0;
 276 }
 277
 278 API int pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
 279     const char *pkg_type, const char *pkgid, const char *appid,
 280     const char *key, const char *val) {
 281   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 282   if (!cls->GetRequest())
 283     return -1;
 284   return cls->SendSignal(pkg_type, pkgid, appid, key, val);
 285 }
 286
 287 API int pkgmgr_installer_send_signal(pkgmgr_installer *pi,
 288     const char *pkg_type, const char *pkgid, const char *key,
 289     const char *val) {
 290   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 291   if (!cls->GetRequest())
 292     return -1;
 293   return cls->SendSignal(pkg_type, pkgid, "", key, val);
 294 }
 295
 296 API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
 297     uid_t uid, const char *pkg_type, const char *pkgid,
 298     const char *appid, const char *key, const char *val) {
 299   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 300   if (!cls->GetRequest())
 301     return -1;
 302   return cls->SendSignalForUid(uid, pkg_type, pkgid, appid, key, val);
 303 }
 304
 305 API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
 306     uid_t uid, const char *pkg_type, const char *pkgid,
 307     const char *key, const char *val) {
 308   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 309   if (!cls->GetRequest())
 310     return -1;
 311   return cls->SendSignalForUid(uid, pkg_type, pkgid, "", key, val);
 312 }
 313
 314 API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi,
 315     int request_type) {
 316   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 317   if (!cls->GetRequest())
 318     return -1;
 319   cls->GetRequest()->SetRequestType(request_type);
 320   return 0;
 321 }
 322
 323 API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi,
 324     const char *session_id) {
 325   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 326   if (!cls->GetRequest())
 327     return -1;
 328   cls->GetRequest()->SetSessionId(std::string(session_id));
 329   return 0;
 330 }
 331
 332 API int pkgmgr_installer_create_certinfo_set_handle(
 333     pkgmgr_instcertinfo_h *handle) {
 334   return pkgmgrinfo_create_certinfo_set_handle(handle);
 335 }
 336
 337 API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle,
 338     pkgmgr_instcert_type cert_type, char *cert_value) {
 339   return pkgmgrinfo_set_cert_value(handle, static_cast<pkgmgrinfo_instcert_type>(cert_type), cert_value);
 340 }
 341
 342 API int pkgmgr_installer_save_certinfo(const char *pkgid,
 343     pkgmgr_instcertinfo_h handle, uid_t uid) {
 344   return pkgmgrinfo_save_certinfo(pkgid, handle, uid);
 345 }
 346
 347 API int pkgmgr_installer_destroy_certinfo_set_handle(
 348     pkgmgr_instcertinfo_h handle) {
 349   return pkgmgrinfo_destroy_certinfo_set_handle(handle);
 350 }
 351
 352 API int pkgmgr_installer_delete_certinfo(const char *pkgid) {
 353   return pkgmgrinfo_delete_certinfo(pkgid);
 354 }
 355
 356 API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level) {
 357   //TODO
 358   return 0;
 359 }
 360
 361 API int pkgmgr_installer_info_get_target_uid(uid_t *uid) {
 362   *uid = g_target_uid;
 363
 364   return 0;
 365 }
 366
 367 API int pkgmgr_installer_info_get_privilege_level(
 368     pkgmgr_privilege_level *level) {
 369   //TODO
 370   return 0;
 371 }
 372
 373 API int pkgmgr_installer_info_get_debug_mode(int *debug_mode) {
 374   //TODO
 375   return 0;
 376 }
 377
 378 API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization) {
 379   //TODO
 380   return 0;
 381 }
 382
 383 API const char* pkgmgr_installer_error_to_string(int error_code) {
 384   //TODO
 385   return nullptr;
 386 }
 387
 388 API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
 389     const char *pkgid, const char *pkg_type) {
 390   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 391   cls->AddPkg(pkgid, pkg_type);
 392
 393   return 0;
 394 }
 395
 396 API int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
 397     const char *key, const char *val) {
 398   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 399   if (!cls->GetRequest())
 400     return -1;
 401   return cls->SendSignals(key, val);
 402 }
 403
 404 API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
 405     const char *key, const char *val) {
 406   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 407   if (!cls->GetRequest())
 408     return -1;
 409   return cls->SendSignalsForUid(uid, key, val);
 410 }
 411
 412 API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) {
 413   //TODO
 414   return 0;
 415 }
 416
 417 API int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi,
 418     const char *pkgid, const char *status,
 419     pkgmgr_res_event_info *event_info) {
 420   if (!pi || !pkgid || !status || !event_info) {
 421     _E("invalid argument");
 422     return -1;
 423   }
 424
 425   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 426   if (!cls->GetRequest())
 427     return -1;
 428
 429   return cls->SendSignalForResource(pkgid, status,
 430       reinterpret_cast<rpc_port::PkgSignal::ExtraData*>(event_info));
 431 }
 432
 433 API int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi,
 434     uid_t uid, const char *pkgid, const char *status,
 435     pkgmgr_res_event_info *event_info) {
 436   if (!pi || !pkgid || !status || !event_info) {
 437     _E("invalid argument");
 438     return -1;
 439   }
 440
 441   auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
 442   if (!cls->GetRequest())
 443     return -1;
 444
 445   return cls->SendSignalForResourceForUid(uid, pkgid, status,
 446       reinterpret_cast<rpc_port::PkgSignal::ExtraData*>(event_info));
 447 }
 448
 449 API int pkgmgr_installer_send_pkg_upgrade_signal(pkgmgr_installer *pi,
 450     unsigned int progress) {
 451   //TODO
 452   return 0;
 453 }