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   WriteIcon(parcel, package->icon);
 225   WriteLabel(parcel, package->label);
 226   WriteAuthor(parcel, package->author);
 227   WriteDescription(parcel, package->description);
 228   WritePrivileges(parcel, package->privileges);
 229   WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
 230   WriteProvidesAppdefinedPrivileges(parcel,
 231       package->provides_appdefined_privileges);
 232   WriteApplication(parcel, package->application);
 233   WriteDeviceprofile(parcel, package->deviceprofile);
 234   WriteDependencies(parcel, package->dependencies);
 235   WritePlugin(parcel, package->plugin);
 236   WriteResAllowedPackages(parcel, package->res_allowed_packages);
 237 }
 238
 239 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 240   int size = 0;
 241   ReadInt(parcel, &size);
 242
 243   for (int i = 0; i < size; ++i) {
 244     icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 245     ReadString(parcel, &icon->text);
 246     ReadString(parcel, &icon->lang);
 247     ReadString(parcel, &icon->section);
 248     ReadString(parcel, &icon->size);
 249     ReadString(parcel, &icon->resolution);
 250     ReadString(parcel, &icon->dpi);
 251
 252     *list = g_list_append(*list, icon);
 253   }
 254 }
 255
 256 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 257   int size = 0;
 258   ReadInt(parcel, &size);
 259
 260   for (int i = 0; i < size; ++i) {
 261     label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
 262     ReadString(parcel, &label->lang);
 263     ReadString(parcel, &label->name);
 264     ReadString(parcel, &label->text);
 265
 266     *list = g_list_append(*list, label);
 267   }
 268 }
 269
 270 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 271   int size = 0;
 272   ReadInt(parcel, &size);
 273
 274   for (int i = 0; i < size; ++i) {
 275     author_x* author = reinterpret_cast<author_x*>(
 276         calloc(1, sizeof(author_x)));
 277     ReadString(parcel, &author->email);
 278     ReadString(parcel, &author->href);
 279     ReadString(parcel, &author->text);
 280     ReadString(parcel, &author->lang);
 281
 282     *list = g_list_append(*list, author);
 283   }
 284 }
 285
 286 void PkgInfoParcelable::ReadDescription(
 287     tizen_base::Parcel* parcel, GList** list) {
 288   int size = 0;
 289   ReadInt(parcel, &size);
 290
 291   for (int i = 0; i < size; ++i) {
 292     description_x* description =
 293         reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
 294     ReadString(parcel, &description->name);
 295     ReadString(parcel, &description->text);
 296     ReadString(parcel, &description->lang);
 297
 298     *list = g_list_append(*list, description);
 299   }
 300 }
 301
 302 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 303   return;
 304 }
 305
 306 void PkgInfoParcelable::ReadPrivileges(
 307     tizen_base::Parcel* parcel, GList** list) {
 308   int size = 0;
 309   ReadInt(parcel, &size);
 310
 311   for (int i = 0; i < size; ++i) {
 312     privilege_x* privilege =
 313         reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
 314     ReadString(parcel, &privilege->type);
 315     ReadString(parcel, &privilege->value);
 316
 317     *list = g_list_append(*list, privilege);
 318   }
 319 }
 320
 321 void PkgInfoParcelable::ReadAppdefinedPrivileges(
 322     tizen_base::Parcel* parcel, GList** list) {
 323   int size = 0;
 324   ReadInt(parcel, &size);
 325
 326   for (int i = 0; i < size; ++i) {
 327     appdefined_privilege_x* appdefined_privilege =
 328         reinterpret_cast<appdefined_privilege_x*>(
 329             calloc(1, sizeof(appdefined_privilege_x)));
 330     ReadString(parcel, &appdefined_privilege->type);
 331     ReadString(parcel, &appdefined_privilege->value);
 332     ReadString(parcel, &appdefined_privilege->license);
 333
 334     *list = g_list_append(*list, appdefined_privilege);
 335   }
 336 }
 337
 338 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
 339     tizen_base::Parcel* parcel, GList** list) {
 340   int size = 0;
 341   ReadInt(parcel, &size);
 342
 343   for (int i = 0; i < size; ++i) {
 344     appdefined_privilege_x* appdefined_privilege =
 345         reinterpret_cast<appdefined_privilege_x*>(
 346             calloc(1, sizeof(appdefined_privilege_x)));
 347     ReadString(parcel, &appdefined_privilege->type);
 348     ReadString(parcel, &appdefined_privilege->value);
 349     ReadString(parcel, &appdefined_privilege->license);
 350
 351     *list = g_list_append(*list, appdefined_privilege);
 352   }
 353 }
 354
 355 void PkgInfoParcelable::ReadApplication(
 356     tizen_base::Parcel* parcel, GList** list) {
 357   AppInfoParcelable apps;
 358   parcel->ReadParcelable(&apps);
 359
 360   std::vector<std::shared_ptr<application_x>> vt = apps.ExtractAppInfo();
 361
 362   for (auto& application : vt)
 363     *list = g_list_append(*list, application.get());
 364 }
 365
 366 void PkgInfoParcelable::ReadCompatibility(
 367     tizen_base::Parcel* parcel, GList** list) {
 368   return;
 369 }
 370
 371 void PkgInfoParcelable::ReadDeviceprofile(
 372     tizen_base::Parcel* parcel, GList** list) {
 373   int size = 0;
 374   ReadInt(parcel, &size);
 375
 376   for (int i = 0; i < size; ++i) {
 377     char* device_profile = nullptr;
 378     ReadString(parcel, &device_profile);
 379     *list = g_list_append(*list, device_profile);
 380   }
 381 }
 382
 383 void PkgInfoParcelable::ReadDependencies(
 384     tizen_base::Parcel* parcel, GList** list) {
 385   int size = 0;
 386   ReadInt(parcel, &size);
 387
 388   for (int i = 0; i < size; ++i) {
 389     dependency_x* dependendy =
 390         reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
 391     ReadString(parcel, &dependendy->depends_on);
 392     ReadString(parcel, &dependendy->type);
 393     ReadString(parcel, &dependendy->required_version);
 394
 395     *list = g_list_append(*list, dependendy);
 396   }
 397 }
 398
 399 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 400   int size = 0;
 401   ReadInt(parcel, &size);
 402
 403   for (int i = 0; i < size; ++i) {
 404     plugin_x* plugin = reinterpret_cast<plugin_x*>(
 405         calloc(1, sizeof(plugin_x)));
 406     ReadString(parcel, &plugin->pkgid);
 407     ReadString(parcel, &plugin->appid);
 408     ReadString(parcel, &plugin->plugin_type);
 409     ReadString(parcel, &plugin->plugin_name);
 410
 411     *list = g_list_append(*list, plugin);
 412   }
 413 }
 414
 415 void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
 416     GList** list) {
 417   int size = 0;
 418   ReadInt(parcel, &size);
 419
 420   for (int i = 0; i < size; ++i) {
 421     res_allowed_package_x* res_allowed_package =
 422         reinterpret_cast<res_allowed_package_x*>(
 423             calloc(1, sizeof(res_allowed_package_x)));
 424     ReadString(parcel, &res_allowed_package->allowed_package);
 425
 426     int priv_len;
 427     GList* priv_list = nullptr;
 428     ReadInt(parcel, &priv_len);
 429     for (int i = 0; i < priv_len; ++i) {
 430       char* priv = nullptr;
 431       ReadString(parcel, &priv);
 432       priv_list = g_list_prepend(priv_list, priv);
 433     }
 434     res_allowed_package->required_privileges = priv_list;
 435
 436     *list = g_list_prepend(*list, res_allowed_package);
 437   }
 438 }
 439
 440 package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 441   package_x* package =
 442       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 443
 444   ReadString(parcel, &package->for_all_users);
 445   ReadString(parcel, &package->package);
 446   ReadString(parcel, &package->version);
 447   ReadString(parcel, &package->installlocation);
 448   ReadString(parcel, &package->ns);
 449   ReadString(parcel, &package->removable);
 450   ReadString(parcel, &package->preload);
 451   ReadString(parcel, &package->readonly);
 452   ReadString(parcel, &package->update);
 453   ReadString(parcel, &package->appsetting);
 454   ReadString(parcel, &package->system);
 455   ReadString(parcel, &package->type);
 456   ReadString(parcel, &package->package_size);
 457   ReadString(parcel, &package->installed_time);
 458   ReadString(parcel, &package->installed_storage);
 459   ReadString(parcel, &package->storeclient_id);
 460   ReadString(parcel, &package->mainapp_id);
 461   ReadString(parcel, &package->package_url);
 462   ReadString(parcel, &package->root_path);
 463   ReadString(parcel, &package->csc_path);
 464   ReadString(parcel, &package->nodisplay_setting);
 465   ReadString(parcel, &package->support_mode);
 466   ReadString(parcel, &package->support_disable);
 467   ReadString(parcel, &package->api_version);
 468   ReadString(parcel, &package->tep_name);
 469   ReadString(parcel, &package->zip_mount_file);
 470   ReadString(parcel, &package->backend_installer);
 471   ReadString(parcel, &package->external_path);
 472   ReadString(parcel, &package->use_system_certs);
 473   ReadString(parcel, &package->locale);
 474   ReadString(parcel, &package->res_type);
 475   ReadString(parcel, &package->res_version);
 476   ReadString(parcel, &package->is_disabled);
 477   ReadIcon(parcel, &package->icon);
 478   ReadLabel(parcel, &package->label);
 479   ReadAuthor(parcel, &package->author);
 480   ReadDescription(parcel, &package->description);
 481   ReadPrivileges(parcel, &package->privileges);
 482   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
 483   ReadProvidesAppdefinedPrivileges(parcel,
 484       &package->provides_appdefined_privileges);
 485   ReadApplication(parcel, &package->application);
 486   ReadDeviceprofile(parcel, &package->deviceprofile);
 487   ReadDependencies(parcel, &package->dependencies);
 488   ReadPlugin(parcel, &package->plugin);
 489   ReadResAllowedPackages(parcel, &package->res_allowed_packages);
 490
 491   return package;
 492 }
 493
 494 PkgInfoParcelable::PkgInfoParcelable()
 495     : AbstractParcelable(0, ParcelableType::PkgInfo),
 496     write_type_(PkgWriteType::None), auto_release_(true) {}
 497
 498 PkgInfoParcelable::PkgInfoParcelable(
 499     uid_t uid, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 500     PkgWriteType write_type, bool auto_release)
 501     : AbstractParcelable(uid, ParcelableType::PkgInfo),
 502     pkg_list_(std::move(pkg_list)), write_type_(write_type),
 503     auto_release_(auto_release) {}
 504
 505 PkgInfoParcelable::PkgInfoParcelable(
 506     int ret, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 507     bool auto_release)
 508     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
 509     pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
 510     auto_release_(auto_release) {}
 511
 512 PkgInfoParcelable::~PkgInfoParcelable() {
 513 }
 514
 515 const std::vector<std::shared_ptr<package_x>>& PkgInfoParcelable::GetPkgInfo() {
 516   return pkg_list_;
 517 }
 518
 519 std::vector<std::shared_ptr<package_x>> PkgInfoParcelable::ExtractPkgInfo() {
 520   return std::move(pkg_list_);
 521 }
 522
 523 PkgWriteType PkgInfoParcelable::GetWriteType() {
 524   return write_type_;
 525 }
 526
 527 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 528   AbstractParcelable::WriteToParcel(parcel);
 529   WriteInt(parcel, static_cast<int>(write_type_));
 530
 531   WriteInt(parcel, pkg_list_.size());
 532
 533   for (auto& pkg : pkg_list_)
 534     WritePackage(parcel, pkg.get());
 535 }
 536
 537 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 538   int len = 0;
 539   int write_type = 0;
 540
 541   AbstractParcelable::ReadFromParcel(parcel);
 542
 543   ReadInt(parcel, &write_type);
 544   write_type_ = static_cast<PkgWriteType>(write_type);
 545
 546   ReadInt(parcel, &len);
 547
 548   for (int i = 0; i < len ; ++i)
 549     pkg_list_.emplace_back(ReadPackage(parcel), [] (package_x*) -> void {});
 550 }
 551
 552 }  // namespace parcel
 553 }  // namespace pkgmgr_common