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