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