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