Fix memory leak in Parcelable

Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/src/common/parcel/appinfo_parcelable.cc b/src/common/parcel/appinfo_parcelable.cc
index cf3ba3c..3bcd6ce 100644 (file)
--- a/src/common/parcel/appinfo_parcelable.cc
+++ b/src/common/parcel/appinfo_parcelable.cc
@@ -378,10 +378,19 @@ void AppInfoParcelable::ReadSplashscreens(tizen_base::Parcel* parcel, GList** li
 }
 
 AppInfoParcelable::AppInfoParcelable()
-    : AbstractParcelable(0, ParcelableType::AppInfo) {}
+    : AbstractParcelable(0, ParcelableType::AppInfo), auto_release_(true) {}
 
-AppInfoParcelable::AppInfoParcelable(int ret, std::vector<application_x *>&& app_list)
-    : AbstractParcelable(0, ParcelableType::AppInfo, ret), app_list_(std::move(app_list)) {}
+AppInfoParcelable::AppInfoParcelable(int ret, std::vector<application_x *>&& app_list, bool auto_release)
+    : AbstractParcelable(0, ParcelableType::AppInfo, ret), app_list_(std::move(app_list)), auto_release_(auto_release) {}
+
+AppInfoParcelable::~AppInfoParcelable() {
+  if (!auto_release_)
+    return;
+
+  for (auto app : app_list_) {
+    pkgmgrinfo_basic_free_application(app);
+  }
+}
 
 const std::vector<application_x *>& AppInfoParcelable::GetAppInfo() {
   return app_list_;

diff --git a/src/common/parcel/appinfo_parcelable.hh b/src/common/parcel/appinfo_parcelable.hh
index 7025277..e216ec8 100644 (file)
--- a/src/common/parcel/appinfo_parcelable.hh
+++ b/src/common/parcel/appinfo_parcelable.hh
@@ -17,9 +17,10 @@ namespace parcel {
 class EXPORT_API AppInfoParcelable : public AbstractParcelable {
  public:
   AppInfoParcelable();
-  AppInfoParcelable(int ret, std::vector<application_x *>&& app_list);
+  AppInfoParcelable(int ret, std::vector<application_x *>&& app_list, bool auto_release);
+  ~AppInfoParcelable();
   const std::vector<application_x *>& GetAppInfo();
-  std::vector<application_x *>&&ExtractAppInfo();
+  std::vector<application_x *>&& ExtractAppInfo();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
@@ -55,6 +56,7 @@ class EXPORT_API AppInfoParcelable : public AbstractParcelable {
   application_x *ReadApplication(tizen_base::Parcel* parcel);
 
   std::vector<application_x *> app_list_;
+  bool auto_release_;
 };
 
 }  // namespace parcel

diff --git a/src/common/parcel/certinfo_parcelable.cc b/src/common/parcel/certinfo_parcelable.cc
index af118d5..a349fb9 100644 (file)
--- a/src/common/parcel/certinfo_parcelable.cc
+++ b/src/common/parcel/certinfo_parcelable.cc
@@ -26,33 +26,53 @@ namespace parcel {
 CertInfoParcelable::CertInfoParcelable()
     : AbstractParcelable(0, ParcelableType::CertInfo),
       cert_info_(nullptr),
-      pkgid_("") {}
+      pkgid_(""),
+      auto_release_(true) {}
 
-CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info)
+CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
       cert_info_(cert_info),
-      pkgid_("") {}
+      pkgid_(""),
+      auto_release_(auto_release) {}
 
-CertInfoParcelable::CertInfoParcelable(int ret, pkgmgr_certinfo_x* cert_info)
+CertInfoParcelable::CertInfoParcelable(int ret, pkgmgr_certinfo_x* cert_info, bool auto_release)
     : AbstractParcelable(0, ParcelableType::CertInfo, ret),
       cert_info_(cert_info),
-      pkgid_("") {}
+      pkgid_(""),
+      auto_release_(auto_release) {}
 
 CertInfoParcelable::CertInfoParcelable(uid_t uid, std::string pkgid)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
       cert_info_(nullptr),
-      pkgid_(pkgid) {}
+      pkgid_(pkgid),
+      auto_release_(true) {}
 
 CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info,
-                                       std::string pkgid)
+                                       std::string pkgid, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
       cert_info_(cert_info),
-      pkgid_(pkgid) {}
+      pkgid_(pkgid),
+      auto_release_(auto_release) {}
+
+CertInfoParcelable::~CertInfoParcelable() {
+  if (!auto_release_)
+    return;
+
+  if (cert_info_ != nullptr)
+    pkgmgrinfo_pkginfo_destroy_certinfo(cert_info_);
+}
 
 const pkgmgr_certinfo_x* CertInfoParcelable::GetCertInfo() {
   return cert_info_;
 }
 
+pkgmgr_certinfo_x* CertInfoParcelable::ExtractCertInfo() {
+  pkgmgr_certinfo_x* cert = cert_info_;
+  cert_info_ = nullptr;
+
+  return cert;
+}
+
 const std::string& CertInfoParcelable::GetPkgId() { return pkgid_; }
 
 void CertInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {

diff --git a/src/common/parcel/certinfo_parcelable.hh b/src/common/parcel/certinfo_parcelable.hh
index 781cfce..8ab08fe 100644 (file)
--- a/src/common/parcel/certinfo_parcelable.hh
+++ b/src/common/parcel/certinfo_parcelable.hh
@@ -19,11 +19,13 @@ class EXPORT_API CertInfoParcelable : public AbstractParcelable {
  public:
   CertInfoParcelable();
   CertInfoParcelable(uid_t uid, std::string pkgid);
-  CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x *cert_info);
-  CertInfoParcelable(int ret, pkgmgr_certinfo_x *cert_info);
+  CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x *cert_info, bool auto_release);
+  CertInfoParcelable(int ret, pkgmgr_certinfo_x *cert_info, bool auto_release);
   CertInfoParcelable(uid_t uid,
-      pkgmgr_certinfo_x *cert_info, std::string pkgid);
+      pkgmgr_certinfo_x *cert_info, std::string pkgid, bool auto_release);
+  ~CertInfoParcelable();
   const pkgmgr_certinfo_x *GetCertInfo();
+  pkgmgr_certinfo_x *ExtractCertInfo();
   const std::string& GetPkgId();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -37,6 +39,7 @@ class EXPORT_API CertInfoParcelable : public AbstractParcelable {
 
   pkgmgr_certinfo_x *cert_info_;
   std::string pkgid_;
+  bool auto_release_;
 };
 
 }  // namespace parcel

diff --git a/src/common/parcel/depinfo_parcelable.cc b/src/common/parcel/depinfo_parcelable.cc
index 3f524a9..4e4eacf 100644 (file)
--- a/src/common/parcel/depinfo_parcelable.cc
+++ b/src/common/parcel/depinfo_parcelable.cc
@@ -24,23 +24,37 @@ namespace parcel {
 
 DepInfoParcelable::DepInfoParcelable()
     : AbstractParcelable(0, ParcelableType::DepInfo),
-        pkgid_("") {}
+        pkgid_(""), auto_release_(true) {}
 
 DepInfoParcelable::DepInfoParcelable(int ret,
-    std::vector<dependency_x *>&& dependency_list)
+    std::vector<dependency_x *>&& dependency_list, bool auto_release)
     : AbstractParcelable(0, ParcelableType::DepInfo, ret),
         pkgid_(""),
-        dependency_list_(std::move(dependency_list)) {}
+        dependency_list_(std::move(dependency_list)),
+        auto_release_(auto_release) {}
 
 DepInfoParcelable::DepInfoParcelable(const std::string& pkgid)
     : AbstractParcelable(0, ParcelableType::DepInfo),
-        pkgid_(pkgid) {}
+        pkgid_(pkgid), auto_release_(true) {}
+
+DepInfoParcelable::~DepInfoParcelable() {
+  if (!auto_release_)
+    return;
+
+  for (auto dep : dependency_list_) {
+    pkgmgrinfo_basic_free_dependency(dep);
+  }
+}
 
 
 const std::vector<dependency_x *>& DepInfoParcelable::GetDependencyInfo() {
   return dependency_list_;
 }
 
+std::vector<dependency_x *>&& DepInfoParcelable::ExtractDependencyInfo() {
+  return std::move(dependency_list_);
+}
+
 const std::string& DepInfoParcelable::GetPkgID() {
   return pkgid_;
 }

diff --git a/src/common/parcel/depinfo_parcelable.hh b/src/common/parcel/depinfo_parcelable.hh
index 4088e29..0dcce22 100644 (file)
--- a/src/common/parcel/depinfo_parcelable.hh
+++ b/src/common/parcel/depinfo_parcelable.hh
@@ -17,9 +17,11 @@ namespace parcel {
 class EXPORT_API DepInfoParcelable : public AbstractParcelable {
  public:
   DepInfoParcelable();
-  DepInfoParcelable(int ret, std::vector<dependency_x *>&& dependency_list);
+  DepInfoParcelable(int ret, std::vector<dependency_x *>&& dependency_list, bool auto_release);
   DepInfoParcelable(const std::string& pkgid);
+  ~DepInfoParcelable();
   const std::vector<dependency_x *>& GetDependencyInfo();
+  std::vector<dependency_x *>&& ExtractDependencyInfo();
   const std::string& GetPkgID();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -32,6 +34,7 @@ class EXPORT_API DepInfoParcelable : public AbstractParcelable {
 
   std::string pkgid_;
   std::vector<dependency_x *> dependency_list_;
+  bool auto_release_;
 };
 
 }  // namespace parcel

diff --git a/src/common/parcel/filter_parcelable.cc b/src/common/parcel/filter_parcelable.cc
index 724761e..a0de5e8 100644 (file)
--- a/src/common/parcel/filter_parcelable.cc
+++ b/src/common/parcel/filter_parcelable.cc
@@ -28,13 +28,22 @@ namespace parcel {
 FilterParcelable::FilterParcelable()
     : AbstractParcelable(0, ParcelableType::Filter),
       filter_(nullptr),
-      flag_(0) {}
+      flag_(0), auto_release_(true) {}
 
 FilterParcelable::FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter,
-                                   int flag)
+                                   int flag, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::Filter),
       filter_(filter),
-      flag_(flag) {}
+      flag_(flag), auto_release_(auto_release) {}
+
+FilterParcelable::~FilterParcelable() {
+  if (!auto_release_)
+    return;
+
+  if (filter_ != nullptr)
+    pkgmgrinfo_pkginfo_filter_destroy(filter_);
+
+}
 
 const pkgmgrinfo_filter_x *FilterParcelable::GetFilter() { return filter_; }
 

diff --git a/src/common/parcel/filter_parcelable.hh b/src/common/parcel/filter_parcelable.hh
index 0be9227..cc3d210 100644 (file)
--- a/src/common/parcel/filter_parcelable.hh
+++ b/src/common/parcel/filter_parcelable.hh
@@ -17,7 +17,8 @@ namespace parcel {
 class EXPORT_API FilterParcelable : public AbstractParcelable {
  public:
   FilterParcelable();
-  FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter, int flag);
+  FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter, int flag, bool auto_release);
+  ~FilterParcelable();
   const pkgmgrinfo_filter_x* GetFilter();
   int GetFlag();
 
@@ -34,6 +35,7 @@ class EXPORT_API FilterParcelable : public AbstractParcelable {
 
   pkgmgrinfo_filter_x *filter_;
   int flag_;
+  bool auto_release_;
 };
 
 }  // namespace parcel

diff --git a/src/common/parcel/pkginfo_parcelable.cc b/src/common/parcel/pkginfo_parcelable.cc
index 9e7b751..870ecff 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.cc
+++ b/src/common/parcel/pkginfo_parcelable.cc
@@ -127,7 +127,7 @@ void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel, GList* appl
     app_vt.push_back(ptr);
   }
 
-  AppInfoParcelable apps(0, std::move(app_vt));
+  AppInfoParcelable apps(0, std::move(app_vt), false);
 
   parcel->WriteParcelable(apps);
 }
@@ -333,7 +333,9 @@ void PkgInfoParcelable::ReadApplication(tizen_base::Parcel* parcel, GList** list
   AppInfoParcelable apps;
   parcel->ReadParcelable(&apps);
 
-  for (const auto& application : apps.GetAppInfo())
+  std::vector<application_x *> vt = apps.ExtractAppInfo();
+
+  for (application_x *application : vt)
     *list = g_list_append(*list, application);
 }
 
@@ -434,18 +436,31 @@ package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 }
 
 PkgInfoParcelable::PkgInfoParcelable()
-    : AbstractParcelable(0, ParcelableType::PkgInfo), write_type_(WriteType::None) {}
+    : AbstractParcelable(0, ParcelableType::PkgInfo), write_type_(WriteType::None), auto_release_(true) {}
+
+PkgInfoParcelable::PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type, bool auto_release)
+    : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type), auto_release_(auto_release) {}
 
-PkgInfoParcelable::PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type)
-    : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type) {}
+PkgInfoParcelable::PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list, bool auto_release)
+    : AbstractParcelable(0, ParcelableType::PkgInfo, ret), pkg_list_(std::move(pkg_list)), write_type_(WriteType::None), auto_release_(auto_release) {}
 
-PkgInfoParcelable::PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list)
-    : AbstractParcelable(0, ParcelableType::PkgInfo, ret), pkg_list_(std::move(pkg_list)), write_type_(WriteType::None) {}
+PkgInfoParcelable::~PkgInfoParcelable() {
+  if (!auto_release_)
+    return;
+
+  for (auto pkg : pkg_list_) {
+    pkgmgrinfo_basic_free_package(pkg);
+  }
+}
 
 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
   return pkg_list_;
 }
 
+std::vector<package_x *>&& PkgInfoParcelable::ExtractPkgInfo() {
+  return std::move(pkg_list_);
+}
+
 WriteType PkgInfoParcelable::GetWriteType() {
   return write_type_;
 }

diff --git a/src/common/parcel/pkginfo_parcelable.hh b/src/common/parcel/pkginfo_parcelable.hh
index 851b2af..24b1d82 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.hh
+++ b/src/common/parcel/pkginfo_parcelable.hh
@@ -18,9 +18,11 @@ namespace parcel {
 class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
  public:
   PkgInfoParcelable();
-  PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type = None);
-  PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list);
+  PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type, bool auto_release);
+  PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list, bool auto_release);
+  ~PkgInfoParcelable();
   const std::vector<package_x *>& GetPkgInfo();
+  std::vector<package_x *>&& ExtractPkgInfo();
   WriteType GetWriteType();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -58,6 +60,7 @@ class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
 
   std::vector<package_x *> pkg_list_;
   WriteType write_type_;
+  bool auto_release_;
 };
 
 }  // namespace parcel

diff --git a/src/common/request_handler/get_appinfo_request_handler.cc b/src/common/request_handler/get_appinfo_request_handler.cc
index 049f0de..6987a39 100644 (file)
--- a/src/common/request_handler/get_appinfo_request_handler.cc
+++ b/src/common/request_handler/get_appinfo_request_handler.cc
@@ -25,7 +25,7 @@ bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data, int size,
       abstract_parcel->GetType() != ParcelableType::Filter) {
     _LOGE("Invalid parcel or type");
     result_ = std::make_shared<AppInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<application_x*>{});
+        PMINFO_R_ERROR, std::vector<application_x*>{}, true);
     return false;
   }
 
@@ -33,7 +33,7 @@ bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data, int size,
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
     result_ = std::make_shared<AppInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<application_x*>{});
+        PMINFO_R_ERROR, std::vector<application_x*>{}, true);
     return false;
   }
 
@@ -44,7 +44,7 @@ bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data, int size,
   if (ret < 0)
     _LOGE("Failed to execute");
 
-  result_ = std::make_shared<AppInfoParcelable>(ret, db.GetAppHandle());
+  result_ = std::make_shared<AppInfoParcelable>(ret, db.GetAppHandle(), true);
 
   return true;
 }

diff --git a/src/common/request_handler/get_cert_request_handler.cc b/src/common/request_handler/get_cert_request_handler.cc
index ee31472..b12f823 100644 (file)
--- a/src/common/request_handler/get_cert_request_handler.cc
+++ b/src/common/request_handler/get_cert_request_handler.cc
@@ -24,7 +24,7 @@ bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
       abstract_parcel->GetType() != ParcelableType::CertInfo) {
     _LOGE("Invalid parcel or type");
     result_ = std::make_shared<CertInfoParcelable>(
-        PMINFO_R_ERROR, nullptr);
+        PMINFO_R_ERROR, nullptr, true);
     return false;
   }
 
@@ -32,7 +32,7 @@ bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
     result_ = std::make_shared<CertInfoParcelable>(
-        PMINFO_R_ERROR, nullptr);
+        PMINFO_R_ERROR, nullptr, true);
     return false;
   }
 
@@ -42,7 +42,7 @@ bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
 
   int ret = db.Execute();
 
-  result_ = std::make_shared<CertInfoParcelable>(ret, db.GetCertHandle());
+  result_ = std::make_shared<CertInfoParcelable>(ret, db.GetCertHandle(), true);
 
   return true;
 }

diff --git a/src/common/request_handler/get_depinfo_request_handler.cc b/src/common/request_handler/get_depinfo_request_handler.cc
index c9c4aba..35587b8 100644 (file)
--- a/src/common/request_handler/get_depinfo_request_handler.cc
+++ b/src/common/request_handler/get_depinfo_request_handler.cc
@@ -25,7 +25,7 @@ bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
       abstract_parcel->GetType() != ParcelableType::DepInfo) {
     _LOGE("Invalid parcel or type");
     result_ = std::make_shared<DepInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<dependency_x*>{});
+        PMINFO_R_ERROR, std::vector<dependency_x*>{}, true);
     return false;
   }
 
@@ -33,7 +33,7 @@ bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
     result_ = std::make_shared<DepInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<dependency_x*>{});
+        PMINFO_R_ERROR, std::vector<dependency_x*>{}, true);
     return false;
   }
 
@@ -41,7 +41,7 @@ bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
   db.SetPkgID(parcel->GetPkgID());
   int ret = db.Execute();
 
-  result_ = std::make_shared<DepInfoParcelable>(ret, db.GetDependencyList());
+  result_ = std::make_shared<DepInfoParcelable>(ret, db.GetDependencyList(), true);
   return true;
 }
 

diff --git a/src/common/request_handler/get_pkginfo_request_handler.cc b/src/common/request_handler/get_pkginfo_request_handler.cc
index 0307c11..306330a 100644 (file)
--- a/src/common/request_handler/get_pkginfo_request_handler.cc
+++ b/src/common/request_handler/get_pkginfo_request_handler.cc
@@ -25,7 +25,7 @@ bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
       abstract_parcel->GetType() != ParcelableType::Filter) {
     _LOGE("Invalid parcel or type");
     result_ = std::make_shared<PkgInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<package_x*>{});
+        PMINFO_R_ERROR, std::vector<package_x*>{}, true);
     return false;
   }
 
@@ -33,7 +33,7 @@ bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
     result_ = std::make_shared<PkgInfoParcelable>(
-        PMINFO_R_ERROR, std::vector<package_x*>{});
+        PMINFO_R_ERROR, std::vector<package_x*>{}, true);
     return false;
   }
 
@@ -42,7 +42,7 @@ bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
   db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
   int ret = db.Execute();
 
-  result_ = std::make_shared<PkgInfoParcelable>(ret, db.GetPkgHandle());
+  result_ = std::make_shared<PkgInfoParcelable>(ret, db.GetPkgHandle(), true);
 
   return true;
 }

diff --git a/src/common/request_handler/get_pkginfo_request_handler.hh b/src/common/request_handler/get_pkginfo_request_handler.hh
index 11be834..ddb3f2d 100644 (file)
--- a/src/common/request_handler/get_pkginfo_request_handler.hh
+++ b/src/common/request_handler/get_pkginfo_request_handler.hh
@@ -25,7 +25,6 @@ class EXPORT_API GetPkginfoRequestHandler : public AbstractRequestHandler {
 
  private:
   std::shared_ptr<pkgmgr_common::parcel::PkgInfoParcelable> result_;
-
 };
 
 }  // namespace request_handler

diff --git a/src/manager/pkginfo_manager.cc b/src/manager/pkginfo_manager.cc
index e39ffe2..503a270 100644 (file)
--- a/src/manager/pkginfo_manager.cc
+++ b/src/manager/pkginfo_manager.cc
@@ -57,7 +57,7 @@ extern "C" EXPORT_API int _pkginfo_get_packages(uid_t uid,
            pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) {
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
                        new pkgmgr_common::parcel::FilterParcelable(uid,
-                                       static_cast<pkgmgrinfo_filter_x*>(filter), flag));
+                                       static_cast<pkgmgrinfo_filter_x*>(filter), flag, false));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::GET_PKG_INFO);
@@ -84,7 +84,7 @@ extern "C" EXPORT_API int _pkginfo_get_packages(uid_t uid,
                        std::static_pointer_cast<pkgmgr_common::parcel::PkgInfoParcelable>(
                                        ptr));
 
-       auto result_list = return_parcel->GetPkgInfo();
+       auto result_list = return_parcel->ExtractPkgInfo();
        // TODO: check noentry error has returned if size of result_list is 0
        for (auto& pkginfo : result_list)
                g_hash_table_insert(packages, (gpointer)pkginfo->package,
@@ -123,7 +123,7 @@ extern "C" EXPORT_API int _pkginfo_get_depends_on(uid_t uid,
                        std::static_pointer_cast<pkgmgr_common::parcel::DepInfoParcelable>(
                                        ptr));
 
-       auto dependency_list = return_parcel->GetDependencyInfo();
+       auto dependency_list = return_parcel->ExtractDependencyInfo();
        for (auto& dependency : dependency_list)
                *dependencies = g_list_prepend(*dependencies, dependency);
        return PMINFO_R_OK;
@@ -134,7 +134,7 @@ extern "C" EXPORT_API int _appinfo_get_applications(uid_t db_uid, uid_t uid,
                pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) {
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
                        new pkgmgr_common::parcel::FilterParcelable(uid,
-                                       static_cast<pkgmgrinfo_filter_x*>(filter), flag));
+                                       static_cast<pkgmgrinfo_filter_x*>(filter), flag, false));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid, pkgmgr_common::ReqType::GET_APP_INFO);
        if (!client.SendRequest())
@@ -165,10 +165,10 @@ extern "C" EXPORT_API int _appinfo_get_applications(uid_t db_uid, uid_t uid,
                        std::static_pointer_cast<pkgmgr_common::parcel::AppInfoParcelable>(
                                        ptr));
 
-       auto result_list = return_parcel->GetAppInfo();
-       for (auto& appinfo : result_list)
-               g_hash_table_insert(packages, (gpointer)appinfo->appid,
-                               (gpointer)appinfo);
+       std::vector<application_x *> result_list = return_parcel->ExtractAppInfo();
+       for (application_x *app : result_list)
+               g_hash_table_insert(packages, (gpointer)app->appid,
+                               (gpointer)app);
 
        return PMINFO_R_OK;
 }
@@ -1016,10 +1016,9 @@ extern "C" EXPORT_API int _parser_execute_write_queries(const char **queries, in
 
 extern "C" EXPORT_API int _parser_insert_manifest_info(manifest_x *mfx, uid_t uid)
 {
-       std::vector<package_x *> vt { mfx };
-
-       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Insert));
+       auto parcelable =
+                       std::make_shared<pkgmgr_common::parcel::PkgInfoParcelable>(uid,
+                                       std::vector<package_x *>{ mfx }, WriteType::Insert, false);
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::SET_PKG_INFO);
@@ -1048,10 +1047,9 @@ extern "C" EXPORT_API int _parser_insert_manifest_info(manifest_x *mfx, uid_t ui
 
 extern "C" EXPORT_API int _parser_update_manifest_info(manifest_x *mfx, uid_t uid)
 {
-       std::vector<package_x *> vt { mfx };
-
-       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Update));
+       auto parcelable =
+                       std::make_shared<pkgmgr_common::parcel::PkgInfoParcelable>(uid,
+                                       std::vector<package_x *>{ mfx }, WriteType::Update, false);
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::SET_PKG_INFO);
@@ -1080,10 +1078,9 @@ extern "C" EXPORT_API int _parser_update_manifest_info(manifest_x *mfx, uid_t ui
 
 extern "C" EXPORT_API int _parser_delete_manifest_info(manifest_x *mfx, uid_t uid)
 {
-       std::vector<package_x *> vt { mfx };
-
-       std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::PkgInfoParcelable(uid, std::move(vt), WriteType::Delete));
+       auto parcelable =
+                       std::make_shared<pkgmgr_common::parcel::PkgInfoParcelable>(uid,
+                                       std::vector<package_x *>{ mfx }, WriteType::Delete, false);
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::SET_PKG_INFO);
@@ -1114,7 +1111,7 @@ extern "C" EXPORT_API int _pkginfo_insert_certinfo(const char* pkgid,
                pkgmgr_certinfo_x* cert, uid_t uid)
 {
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::CertInfoParcelable(uid, cert));
+                       new pkgmgr_common::parcel::CertInfoParcelable(uid, cert, false));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::SET_CERT_INFO);
@@ -1172,18 +1169,24 @@ extern "C" EXPORT_API int _pkginfo_get_certinfo(const char *pkgid,
                std::static_pointer_cast<pkgmgr_common::parcel::CertInfoParcelable>(
                                ptr));
 
-       const pkgmgr_certinfo_x *certinfo = return_parcel->GetCertInfo();
+       pkgmgr_certinfo_x *certinfo = return_parcel->ExtractCertInfo();
        if (certinfo == nullptr)
                return PMINFO_R_ERROR;
 
        cert->for_all_users = certinfo->for_all_users;
        cert->pkgid = certinfo->pkgid;
+       certinfo->pkgid = nullptr;
        cert->cert_value = certinfo->cert_value;
-       for (int i = 0; i < MAX_CERT_TYPE; i++)
+       certinfo->cert_value = nullptr;
+       for (int i = 0; i < MAX_CERT_TYPE; i++) {
                cert->cert_info[i] = certinfo->cert_info[i];
+               certinfo->cert_info[i] = nullptr;
+       }
        for (int i = 0; i < MAX_CERT_TYPE; i++)
                cert->cert_id[i] = certinfo->cert_id[i];
 
+       free(certinfo);
+
        return PMINFO_R_OK;
 }
 

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index d6be955..ccbc756 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -107,7 +107,7 @@ TEST_F(ParcelTest, AppInfoParcelable) {
 
   origin_applications.emplace_back(GetTestApplication("test_appid1"));
   origin_applications.emplace_back(GetTestApplication("test_appid2"));
-  pp::AppInfoParcelable origin_parcelable(0, std::move(origin_applications));
+  pp::AppInfoParcelable origin_parcelable(0, std::move(origin_applications), true);
   pp::AppInfoParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
@@ -122,7 +122,7 @@ TEST_F(ParcelTest, PkgInfoParcelable) {
 
   origin_packages.emplace_back(GetTestPackage("test_pkgid1"));
   origin_packages.emplace_back(GetTestPackage("test_pkgid2"));
-  pp::PkgInfoParcelable origin_parcelable(0, std::move(origin_packages));
+  pp::PkgInfoParcelable origin_parcelable(0, std::move(origin_packages), true);
   pp::PkgInfoParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
@@ -136,7 +136,7 @@ TEST_F(ParcelTest, FilterParcelable) {
   pkgmgrinfo_filter_x *filter = GetTestFilter();
   int flag = 0b101010;
 
-  pp::FilterParcelable origin_parcelable(0, filter, flag);
+  pp::FilterParcelable origin_parcelable(0, filter, flag, true);
   pp::FilterParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
@@ -151,7 +151,7 @@ TEST_F(ParcelTest, CertInfoParcelable) {
   pkgmgr_certinfo_x *certinfo = GetTestCertInfo();
   std::string test_str = "test_str";
 
-  pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str);
+  pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str, true);
   pp::CertInfoParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);