src/common/parcel/pkginfo_parcelable.cc

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   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 #include "pkginfo_parcelable.hh"
  18
  19 #include <vector>
  20
  21 #include "appinfo_parcelable.hh"
  22
  23 #include "pkgmgrinfo_private.h"
  24
  25 namespace pkgmgr_common {
  26 namespace parcel {
  27
  28 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
  29     GList* icon) const {
  30   WriteInt(parcel, g_list_length(icon));
  31
  32   for (GList* tmp = icon; tmp; tmp = tmp->next) {
  33     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
  34     WriteString(parcel, ptr->text);
  35     WriteString(parcel, ptr->lang);
  36     WriteString(parcel, ptr->section);
  37     WriteString(parcel, ptr->size);
  38     WriteString(parcel, ptr->resolution);
  39     WriteString(parcel, ptr->dpi);
  40   }
  41 }
  42
  43 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
  44     GList* label) const {
  45   WriteInt(parcel, g_list_length(label));
  46
  47   for (GList* tmp = label; tmp; tmp = tmp->next) {
  48     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
  49     WriteString(parcel, ptr->lang);
  50     WriteString(parcel, ptr->name);
  51     WriteString(parcel, ptr->text);
  52   }
  53 }
  54
  55 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
  56     GList* author) const {
  57   WriteInt(parcel, g_list_length(author));
  58
  59   for (GList* tmp = author; tmp; tmp = tmp->next) {
  60     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
  61     WriteString(parcel, ptr->email);
  62     WriteString(parcel, ptr->href);
  63     WriteString(parcel, ptr->text);
  64     WriteString(parcel, ptr->lang);
  65   }
  66 }
  67
  68 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
  69     GList* description) const {
  70   WriteInt(parcel, g_list_length(description));
  71
  72   for (GList* tmp = description; tmp; tmp = tmp->next) {
  73     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
  74     WriteString(parcel, ptr->name);
  75     WriteString(parcel, ptr->text);
  76     WriteString(parcel, ptr->lang);
  77   }
  78 }
  79
  80 void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
  81     GList* license) const {
  82   return;
  83 }
  84
  85 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
  86     GList* privileges) const {
  87   WriteInt(parcel, g_list_length(privileges));
  88
  89   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
  90     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
  91     WriteString(parcel, ptr->type);
  92     WriteString(parcel, ptr->value);
  93   }
  94 }
  95
  96 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
  97     GList* appdefined_privileges) const {
  98   WriteInt(parcel, g_list_length(appdefined_privileges));
  99
 100   for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
 101     appdefined_privilege_x* ptr =
 102         reinterpret_cast<appdefined_privilege_x*>(tmp->data);
 103     WriteString(parcel, ptr->type);
 104     WriteString(parcel, ptr->value);
 105     WriteString(parcel, ptr->license);
 106   }
 107 }
 108
 109 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
 110     tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
 111   WriteInt(parcel, g_list_length(provides_appdefined_privileges));
 112
 113   for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
 114     appdefined_privilege_x* ptr =
 115         reinterpret_cast<appdefined_privilege_x*>(tmp->data);
 116     WriteString(parcel, ptr->type);
 117     WriteString(parcel, ptr->value);
 118     WriteString(parcel, ptr->license);
 119   }
 120 }
 121
 122 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
 123     GList* application) const {
 124   std::vector<std::shared_ptr<application_x>> app_vt;
 125
 126   for (GList* tmp = application; tmp; tmp = tmp->next) {
 127     application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
 128     app_vt.emplace_back(ptr, [] (application_x*) -> void {});
 129   }
 130
 131   AppInfoParcelable apps(0, std::move(app_vt), false);
 132
 133   parcel->WriteParcelable(apps);
 134 }
 135
 136 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 137     GList* compatibility) const {
 138   return;
 139 }
 140
 141 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
 142     GList* deviceprofile) const {
 143   WriteInt(parcel, g_list_length(deviceprofile));
 144
 145   for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
 146     WriteString(parcel, reinterpret_cast<char*>(tmp->data));
 147 }
 148
 149 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
 150     GList* dependencies) const {
 151   WriteInt(parcel, g_list_length(dependencies));
 152
 153   for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
 154     dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
 155     WriteString(parcel, ptr->depends_on);
 156     WriteString(parcel, ptr->type);
 157     WriteString(parcel, ptr->required_version);
 158   }
 159 }
 160
 161 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
 162     GList* plugin) const {
 163   WriteInt(parcel, g_list_length(plugin));
 164
 165   for (GList* tmp = plugin; tmp; tmp = tmp->next) {
 166     plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
 167     WriteString(parcel, ptr->pkgid);
 168     WriteString(parcel, ptr->appid);
 169     WriteString(parcel, ptr->plugin_type);
 170     WriteString(parcel, ptr->plugin_name);
 171   }
 172 }
 173
 174 void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
 175     GList* res_allowed_packages) const {
 176   WriteInt(parcel, g_list_length(res_allowed_packages));
 177
 178   for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
 179     res_allowed_package_x* ptr =
 180         reinterpret_cast<res_allowed_package_x*>(tmp->data);
 181     WriteString(parcel, ptr->allowed_package);
 182
 183     WriteInt(parcel, g_list_length(ptr->required_privileges));
 184     for (GList* priv = ptr->required_privileges; priv; priv = priv->next)
 185       WriteString(parcel, reinterpret_cast<char*>(priv->data));
 186   }
 187 }
 188
 189 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
 190     package_x* package) const {
 191   WriteString(parcel, package->for_all_users);
 192   WriteString(parcel, package->package);
 193   WriteString(parcel, package->version);
 194   WriteString(parcel, package->installlocation);
 195   WriteString(parcel, package->ns);
 196   WriteString(parcel, package->removable);
 197   WriteString(parcel, package->preload);
 198   WriteString(parcel, package->readonly);
 199   WriteString(parcel, package->update);
 200   WriteString(parcel, package->appsetting);
 201   WriteString(parcel, package->system);
 202   WriteString(parcel, package->type);
 203   WriteString(parcel, package->package_size);
 204   WriteString(parcel, package->installed_time);
 205   WriteString(parcel, package->installed_storage);
 206   WriteString(parcel, package->storeclient_id);
 207   WriteString(parcel, package->mainapp_id);
 208   WriteString(parcel, package->package_url);
 209   WriteString(parcel, package->root_path);
 210   WriteString(parcel, package->csc_path);
 211   WriteString(parcel, package->nodisplay_setting);
 212   WriteString(parcel, package->support_mode);
 213   WriteString(parcel, package->support_disable);
 214   WriteString(parcel, package->api_version);
 215   WriteString(parcel, package->tep_name);
 216   WriteString(parcel, package->zip_mount_file);
 217   WriteString(parcel, package->backend_installer);
 218   WriteString(parcel, package->external_path);
 219   WriteString(parcel, package->use_system_certs);
 220   WriteString(parcel, package->locale);
 221   WriteString(parcel, package->res_type);
 222   WriteString(parcel, package->res_version);
 223   WriteString(parcel, package->is_disabled);
 224   WriteString(parcel, package->light_user_switch_mode);
 225   WriteIcon(parcel, package->icon);
 226   WriteLabel(parcel, package->label);
 227   WriteAuthor(parcel, package->author);
 228   WriteDescription(parcel, package->description);
 229   WritePrivileges(parcel, package->privileges);
 230   WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
 231   WriteProvidesAppdefinedPrivileges(parcel,
 232       package->provides_appdefined_privileges);
 233   WriteApplication(parcel, package->application);
 234   WriteDeviceprofile(parcel, package->deviceprofile);
 235   WriteDependencies(parcel, package->dependencies);
 236   WritePlugin(parcel, package->plugin);
 237   WriteResAllowedPackages(parcel, package->res_allowed_packages);
 238 }
 239
 240 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 241   int size = 0;
 242   ReadInt(parcel, &size);
 243
 244   for (int i = 0; i < size; ++i) {
 245     icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 246     ReadString(parcel, &icon->text);
 247     ReadString(parcel, &icon->lang);
 248     ReadString(parcel, &icon->section);
 249     ReadString(parcel, &icon->size);
 250     ReadString(parcel, &icon->resolution);
 251     ReadString(parcel, &icon->dpi);
 252
 253     *list = g_list_append(*list, icon);
 254   }
 255 }
 256
 257 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 258   int size = 0;
 259   ReadInt(parcel, &size);
 260
 261   for (int i = 0; i < size; ++i) {
 262     label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
 263     ReadString(parcel, &label->lang);
 264     ReadString(parcel, &label->name);
 265     ReadString(parcel, &label->text);
 266
 267     *list = g_list_append(*list, label);
 268   }
 269 }
 270
 271 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 272   int size = 0;
 273   ReadInt(parcel, &size);
 274
 275   for (int i = 0; i < size; ++i) {
 276     author_x* author = reinterpret_cast<author_x*>(
 277         calloc(1, sizeof(author_x)));
 278     ReadString(parcel, &author->email);
 279     ReadString(parcel, &author->href);
 280     ReadString(parcel, &author->text);
 281     ReadString(parcel, &author->lang);
 282
 283     *list = g_list_append(*list, author);
 284   }
 285 }
 286
 287 void PkgInfoParcelable::ReadDescription(
 288     tizen_base::Parcel* parcel, GList** list) {
 289   int size = 0;
 290   ReadInt(parcel, &size);
 291
 292   for (int i = 0; i < size; ++i) {
 293     description_x* description =
 294         reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
 295     ReadString(parcel, &description->name);
 296     ReadString(parcel, &description->text);
 297     ReadString(parcel, &description->lang);
 298
 299     *list = g_list_append(*list, description);
 300   }
 301 }
 302
 303 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 304   return;
 305 }
 306
 307 void PkgInfoParcelable::ReadPrivileges(
 308     tizen_base::Parcel* parcel, GList** list) {
 309   int size = 0;
 310   ReadInt(parcel, &size);
 311
 312   for (int i = 0; i < size; ++i) {
 313     privilege_x* privilege =
 314         reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
 315     ReadString(parcel, &privilege->type);
 316     ReadString(parcel, &privilege->value);
 317
 318     *list = g_list_append(*list, privilege);
 319   }
 320 }
 321
 322 void PkgInfoParcelable::ReadAppdefinedPrivileges(
 323     tizen_base::Parcel* parcel, GList** list) {
 324   int size = 0;
 325   ReadInt(parcel, &size);
 326
 327   for (int i = 0; i < size; ++i) {
 328     appdefined_privilege_x* appdefined_privilege =
 329         reinterpret_cast<appdefined_privilege_x*>(
 330             calloc(1, sizeof(appdefined_privilege_x)));
 331     ReadString(parcel, &appdefined_privilege->type);
 332     ReadString(parcel, &appdefined_privilege->value);
 333     ReadString(parcel, &appdefined_privilege->license);
 334
 335     *list = g_list_append(*list, appdefined_privilege);
 336   }
 337 }
 338
 339 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
 340     tizen_base::Parcel* parcel, GList** list) {
 341   int size = 0;
 342   ReadInt(parcel, &size);
 343
 344   for (int i = 0; i < size; ++i) {
 345     appdefined_privilege_x* appdefined_privilege =
 346         reinterpret_cast<appdefined_privilege_x*>(
 347             calloc(1, sizeof(appdefined_privilege_x)));
 348     ReadString(parcel, &appdefined_privilege->type);
 349     ReadString(parcel, &appdefined_privilege->value);
 350     ReadString(parcel, &appdefined_privilege->license);
 351
 352     *list = g_list_append(*list, appdefined_privilege);
 353   }
 354 }
 355
 356 void PkgInfoParcelable::ReadApplication(
 357     tizen_base::Parcel* parcel, GList** list) {
 358   AppInfoParcelable apps;
 359   parcel->ReadParcelable(&apps);
 360
 361   std::vector<std::shared_ptr<application_x>> vt = apps.ExtractAppInfo();
 362
 363   for (auto& application : vt)
 364     *list = g_list_append(*list, application.get());
 365 }
 366
 367 void PkgInfoParcelable::ReadCompatibility(
 368     tizen_base::Parcel* parcel, GList** list) {
 369   return;
 370 }
 371
 372 void PkgInfoParcelable::ReadDeviceprofile(
 373     tizen_base::Parcel* parcel, GList** list) {
 374   int size = 0;
 375   ReadInt(parcel, &size);
 376
 377   for (int i = 0; i < size; ++i) {
 378     char* device_profile = nullptr;
 379     ReadString(parcel, &device_profile);
 380     *list = g_list_append(*list, device_profile);
 381   }
 382 }
 383
 384 void PkgInfoParcelable::ReadDependencies(
 385     tizen_base::Parcel* parcel, GList** list) {
 386   int size = 0;
 387   ReadInt(parcel, &size);
 388
 389   for (int i = 0; i < size; ++i) {
 390     dependency_x* dependendy =
 391         reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
 392     ReadString(parcel, &dependendy->depends_on);
 393     ReadString(parcel, &dependendy->type);
 394     ReadString(parcel, &dependendy->required_version);
 395
 396     *list = g_list_append(*list, dependendy);
 397   }
 398 }
 399
 400 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 401   int size = 0;
 402   ReadInt(parcel, &size);
 403
 404   for (int i = 0; i < size; ++i) {
 405     plugin_x* plugin = reinterpret_cast<plugin_x*>(
 406         calloc(1, sizeof(plugin_x)));
 407     ReadString(parcel, &plugin->pkgid);
 408     ReadString(parcel, &plugin->appid);
 409     ReadString(parcel, &plugin->plugin_type);
 410     ReadString(parcel, &plugin->plugin_name);
 411
 412     *list = g_list_append(*list, plugin);
 413   }
 414 }
 415
 416 void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
 417     GList** list) {
 418   int size = 0;
 419   ReadInt(parcel, &size);
 420
 421   for (int i = 0; i < size; ++i) {
 422     res_allowed_package_x* res_allowed_package =
 423         reinterpret_cast<res_allowed_package_x*>(
 424             calloc(1, sizeof(res_allowed_package_x)));
 425     ReadString(parcel, &res_allowed_package->allowed_package);
 426
 427     int priv_len;
 428     GList* priv_list = nullptr;
 429     ReadInt(parcel, &priv_len);
 430     for (int i = 0; i < priv_len; ++i) {
 431       char* priv = nullptr;
 432       ReadString(parcel, &priv);
 433       priv_list = g_list_prepend(priv_list, priv);
 434     }
 435     res_allowed_package->required_privileges = priv_list;
 436
 437     *list = g_list_prepend(*list, res_allowed_package);
 438   }
 439 }
 440
 441 package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 442   package_x* package =
 443       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 444
 445   ReadString(parcel, &package->for_all_users);
 446   ReadString(parcel, &package->package);
 447   ReadString(parcel, &package->version);
 448   ReadString(parcel, &package->installlocation);
 449   ReadString(parcel, &package->ns);
 450   ReadString(parcel, &package->removable);
 451   ReadString(parcel, &package->preload);
 452   ReadString(parcel, &package->readonly);
 453   ReadString(parcel, &package->update);
 454   ReadString(parcel, &package->appsetting);
 455   ReadString(parcel, &package->system);
 456   ReadString(parcel, &package->type);
 457   ReadString(parcel, &package->package_size);
 458   ReadString(parcel, &package->installed_time);
 459   ReadString(parcel, &package->installed_storage);
 460   ReadString(parcel, &package->storeclient_id);
 461   ReadString(parcel, &package->mainapp_id);
 462   ReadString(parcel, &package->package_url);
 463   ReadString(parcel, &package->root_path);
 464   ReadString(parcel, &package->csc_path);
 465   ReadString(parcel, &package->nodisplay_setting);
 466   ReadString(parcel, &package->support_mode);
 467   ReadString(parcel, &package->support_disable);
 468   ReadString(parcel, &package->api_version);
 469   ReadString(parcel, &package->tep_name);
 470   ReadString(parcel, &package->zip_mount_file);
 471   ReadString(parcel, &package->backend_installer);
 472   ReadString(parcel, &package->external_path);
 473   ReadString(parcel, &package->use_system_certs);
 474   ReadString(parcel, &package->locale);
 475   ReadString(parcel, &package->res_type);
 476   ReadString(parcel, &package->res_version);
 477   ReadString(parcel, &package->is_disabled);
 478   ReadString(parcel, &package->light_user_switch_mode);
 479   ReadIcon(parcel, &package->icon);
 480   ReadLabel(parcel, &package->label);
 481   ReadAuthor(parcel, &package->author);
 482   ReadDescription(parcel, &package->description);
 483   ReadPrivileges(parcel, &package->privileges);
 484   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
 485   ReadProvidesAppdefinedPrivileges(parcel,
 486       &package->provides_appdefined_privileges);
 487   ReadApplication(parcel, &package->application);
 488   ReadDeviceprofile(parcel, &package->deviceprofile);
 489   ReadDependencies(parcel, &package->dependencies);
 490   ReadPlugin(parcel, &package->plugin);
 491   ReadResAllowedPackages(parcel, &package->res_allowed_packages);
 492
 493   return package;
 494 }
 495
 496 PkgInfoParcelable::PkgInfoParcelable()
 497     : AbstractParcelable(0, ParcelableType::PkgInfo),
 498     write_type_(PkgWriteType::None), auto_release_(true) {}
 499
 500 PkgInfoParcelable::PkgInfoParcelable(
 501     uid_t uid, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 502     PkgWriteType write_type, bool auto_release)
 503     : AbstractParcelable(uid, ParcelableType::PkgInfo),
 504     pkg_list_(std::move(pkg_list)), write_type_(write_type),
 505     auto_release_(auto_release) {}
 506
 507 PkgInfoParcelable::PkgInfoParcelable(
 508     int ret, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 509     bool auto_release)
 510     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
 511     pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
 512     auto_release_(auto_release) {}
 513
 514 PkgInfoParcelable::~PkgInfoParcelable() {
 515 }
 516
 517 const std::vector<std::shared_ptr<package_x>>& PkgInfoParcelable::GetPkgInfo() {
 518   return pkg_list_;
 519 }
 520
 521 std::vector<std::shared_ptr<package_x>> PkgInfoParcelable::ExtractPkgInfo() {
 522   return std::move(pkg_list_);
 523 }
 524
 525 PkgWriteType PkgInfoParcelable::GetWriteType() {
 526   return write_type_;
 527 }
 528
 529 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 530   AbstractParcelable::WriteToParcel(parcel);
 531   WriteInt(parcel, static_cast<int>(write_type_));
 532
 533   WriteInt(parcel, pkg_list_.size());
 534
 535   for (auto& pkg : pkg_list_)
 536     WritePackage(parcel, pkg.get());
 537 }
 538
 539 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 540   int len = 0;
 541   int write_type = 0;
 542
 543   AbstractParcelable::ReadFromParcel(parcel);
 544
 545   ReadInt(parcel, &write_type);
 546   write_type_ = static_cast<PkgWriteType>(write_type);
 547
 548   ReadInt(parcel, &len);
 549
 550   for (int i = 0; i < len ; ++i)
 551     pkg_list_.emplace_back(ReadPackage(parcel), [] (package_x*) -> void {});
 552 }
 553
 554 }  // namespace parcel
 555 }  // namespace pkgmgr_common