tizen_base::Parcel p;
p.WriteParcelable(*parcel_.get());
- const auto& raw = p.GetRaw();
- int len = raw.size();
// CREATE_DB request type need to be executed directly by the caller
if (req_type_ == pkgmgr_common::ReqType::CREATE_DB) {
is_offline_ = true;
- return RequestHandlerDirectAccess(p.GetRaw());
+ return RequestHandlerDirectAccess(&p);
}
if (!check_server.IsReady()) {
LOG(WARNING) << "Server is not ready, try to direct access";
is_offline_ = true;
- return RequestHandlerDirectAccess(p.GetRaw());
+ return RequestHandlerDirectAccess(&p);
}
LOG(WARNING) << "Try to send request, Request type: "
if (!socket_->Connect(req_type_)) {
LOG(ERROR) << "Failed to connect client socket, try to direct access";
is_offline_ = true;
- return RequestHandlerDirectAccess(p.GetRaw());
+ return RequestHandlerDirectAccess(&p);
}
if (socket_->SendData(&req_type_, sizeof(req_type_)) != 0) {
return false;
}
+ size_t len = p.GetDataSize();
if (socket_->SendData(&len, sizeof(len)) != 0) {
LOG(ERROR) << "fail to send data";
return false;
}
- if (socket_->SendData(&raw[0], len) != 0) {
+ if (socket_->SendData(p.GetData(), len) != 0) {
LOG(ERROR) << "Fail to send data";
return false;
}
return nullptr;
}
- unsigned char* raw = new (std::nothrow) unsigned char[len];
+ unsigned char* raw = static_cast<unsigned char*>(malloc(len));
if (raw == nullptr) {
LOG(ERROR) << "Out of memory";
return nullptr;
if (socket_->ReceiveData(raw, len) != 0) {
LOG(ERROR) << "Fail to receive data";
- delete[] raw;
+ free(raw);
return nullptr;
}
cpu_inheritance_invoker_.ClearCPUInheritance();
- auto res = pkgmgr_common::parcel::ParcelableFactory::GetInst().CreateParcel(
+ return pkgmgr_common::parcel::ParcelableFactory::GetInst().CreateParcel(
raw, len);
- delete[] raw;
-
- return res;
}
-bool PkgInfoClient::RequestHandlerDirectAccess(
- const std::vector<uint8_t>& raw) {
+bool PkgInfoClient::RequestHandlerDirectAccess(tizen_base::Parcel* parcel) {
static std::mutex lock;
static void* handle = nullptr;
- static void* (*dl_func)(int, const unsigned char*, int, const char*);
+ static void* (*dl_func)(int, unsigned char*, int, const char*);
std::unique_lock<std::mutex> u(lock);
if (handle == nullptr) {
return false;
}
dl_func = reinterpret_cast<void* (*)(
- int, const unsigned char*, int, const char*)>(
+ int, unsigned char*, int, const char*)>(
dlsym(handle, DIRECT_ACCESS_FUNC));
if (dl_func == nullptr) {
LOG(ERROR) << "cannot find " << DIRECT_ACCESS_FUNC << " symbol in "
}
u.unlock();
+ size_t len = 0;
+ uint8_t* raw = parcel->Detach(&len);
result_parcel_.reset(
reinterpret_cast<pkgmgr_common::parcel::AbstractParcelable*>(
- dl_func(req_type_, &raw[0], raw.size(),
+ dl_func(req_type_, raw, len,
pkgmgr_common::SystemLocale::GetInst(false).Get().c_str())));
return true;
std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> GetResultParcel();
private:
- bool RequestHandlerDirectAccess(const std::vector<uint8_t>& raw);
+ bool RequestHandlerDirectAccess(tizen_base::Parcel* parcel);
std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcel_;
std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> result_parcel_;
}
std::unique_ptr<AbstractParcelable> ParcelableFactory::CreateParcel(
- const unsigned char* data, int size) {
+ unsigned char* data, int size, bool copy) {
int tmp;
std::unique_ptr<AbstractParcelable> res = nullptr;
- tizen_base::Parcel parcel(data, size);
+ tizen_base::Parcel parcel(data, size, copy);
parcel.ReadInt32(&tmp);
parcel.ResetReader();
ParcelableType type = static_cast<ParcelableType>(tmp);
class EXPORT_API ParcelableFactory {
public:
static ParcelableFactory& GetInst();
- std::unique_ptr<AbstractParcelable> CreateParcel(
- const unsigned char* data, int size);
+ std::unique_ptr<AbstractParcelable> CreateParcel(unsigned char* data,
+ int size, bool copy = false);
private:
ParcelableFactory();
return pkgmgr_common::ReqType::CREATE_CACHE;
}
-bool CreateCacheRequest::SendData(tizen_base::Parcel parcel) {
- bool ret = static_cast<bool>((parcel.GetRaw().data())[0]);
+bool CreateCacheRequest::SendData(const tizen_base::Parcel& parcel) {
+ bool ret;
+ const_cast<tizen_base::Parcel&>(parcel).ReadBool(&ret);
if (listener_ != nullptr)
listener_->OnCreateCacheDone(ret);
pid_t GetSenderTID() override;
uid_t GetSenderUID() override;
pkgmgr_common::ReqType GetRequestType() override;
- bool SendData(tizen_base::Parcel parcel) override;
+ bool SendData(const tizen_base::Parcel& parcel) override;
bool GetPrivilegeChecked() override;
private:
}
PkgRequest::~PkgRequest() {
- if (data_ != nullptr)
- delete[] data_;
+ free(data_);
}
const unsigned char* PkgRequest::GetData() {
return false;
}
- data_ = new (std::nothrow) unsigned char[data_size_];
+ data_ = static_cast<unsigned char*>(malloc(data_size_));
if (data_ == nullptr) {
LOG(ERROR) << "Out of memory";
request_type_ = pkgmgr_common::REQ_TYPE_NONE;
ret = socket_->ReceiveData(reinterpret_cast<void*>(data_), data_size_);
if (ret < 0) {
LOG(ERROR) << "Failed to ReceiveData";
- delete[] data_;
+ free(data_);
data_ = nullptr;
request_type_ = pkgmgr_common::REQ_TYPE_NONE;
return false;
return true;
}
-bool PkgRequest::SendData(tizen_base::Parcel parcel) {
- const std::vector<uint8_t>& raw = parcel.GetRaw();
- unsigned int size = raw.size();
+bool PkgRequest::SendData(const tizen_base::Parcel& parcel) {
+ auto* raw = parcel.GetData();
+ size_t size = parcel.GetDataSize();
if (socket_->SendData(&size, sizeof(size)) < 0)
return false;
- return (socket_->SendData(raw.data(), size) == 0);
+ return (socket_->SendData(raw, size) == 0);
}
bool PkgRequest::GetPrivilegeChecked() {
privilege_checked_ = checked;
}
+unsigned char* PkgRequest::DetachData() {
+ unsigned char* data = data_;
+ data_ = nullptr;
+ return data;
+}
+
} // namespace pkgmgr_server
virtual pid_t GetSenderTID();
virtual uid_t GetSenderUID();
virtual pkgmgr_common::ReqType GetRequestType();
- virtual bool SendData(tizen_base::Parcel parcel);
+ virtual bool SendData(const tizen_base::Parcel& parcel);
virtual bool GetPrivilegeChecked();
virtual void SetPrivilegeChecked(bool cheked);
+ virtual unsigned char* DetachData();
private:
std::unique_ptr<pkgmgr_common::socket::DataSocket> socket_;
class EXPORT_API AbstractRequestHandler {
public:
virtual ~AbstractRequestHandler() = default;
- virtual bool HandleRequest(const unsigned char* data, int size,
+ virtual bool HandleRequest(unsigned char* data, int size,
const std::string& locale) = 0;
virtual tizen_base::Parcel ExtractResult();
namespace pkgmgr_server {
namespace request_handler {
-bool CommandRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool CommandRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API CommandRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
} // namespace request_handler
} // namespace pkgmgr_server
-#endif // COMMAND_REQUEST_HANDLER_HH_
\ No newline at end of file
+#endif // COMMAND_REQUEST_HANDLER_HH_
CreateCacheRequestHandler::CreateCacheRequestHandler(): scheduler_(gettid()) {
}
-bool CreateCacheRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool CreateCacheRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
psd::CacheDBHandler db(GetUID(), GetPID());
db.SetLocale(locale);
class EXPORT_API CreateCacheRequestHandler : public AbstractRequestHandler {
public:
CreateCacheRequestHandler();
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
tizen_base::Parcel ExtractResult() override;
namespace pkgmgr_server {
namespace request_handler {
-bool CreateDBRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool CreateDBRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API CreateDBRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
namespace pkgmgr_server {
namespace request_handler {
-bool GetAppinfoRequestHandler::HandleRequest(const unsigned char* data,
+bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data,
int size, const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API GetAppinfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string &locale) override;
};
namespace pkgmgr_server {
namespace request_handler {
-bool GetCertRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API GetCertRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
namespace pkgmgr_server {
namespace request_handler {
-bool GetDepinfoRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API GetDepinfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
namespace pkgmgr_server {
namespace request_handler {
-bool GetPkginfoRequestHandler::HandleRequest(const unsigned char* data,
+bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data,
int size, const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API GetPkginfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
namespace pkgmgr_server {
namespace request_handler {
-bool QueryRequestHandler::HandleRequest(const unsigned char* data, int size,
+bool QueryRequestHandler::HandleRequest(unsigned char* data, int size,
const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
class EXPORT_API QueryRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
};
#define EXPORT_API __attribute__((visibility("default")))
extern "C" EXPORT_API void* _request_handler_direct_access(int req_type,
- const unsigned char* data, int size, const char *locale) {
+ unsigned char* data, int size, const char *locale) {
if (data == nullptr || size < 0 || locale == nullptr) {
LOG(ERROR) << "Invalid parameter";
return nullptr;
if (handler == nullptr) {
LOG(ERROR) << "Can't reset handler with type : " << req_type;
+ free(data);
return nullptr;
}
return nullptr;
}
tizen_base::Parcel parcel = handler->ExtractResult();
- const std::vector<uint8_t>& raw = parcel.GetRaw();
- if (raw.size() == 0) {
+ if (parcel.GetDataSize() == 0) {
LOG(ERROR) << "Fail to extract result";
return nullptr;
}
return pkgmgr_common::parcel::ParcelableFactory::GetInst()
- .CreateParcel(&raw[0], raw.size())
+ .CreateParcel(parcel.GetData(), parcel.GetDataSize(), true)
.release();
}
extern "C" {
#endif
-void *_request_handler_direct_access(int req_type, const unsigned char* data,
+void *_request_handler_direct_access(int req_type, unsigned char* data,
int size, const char *locale);
#ifdef __cplusplus
namespace pkgmgr_server {
namespace request_handler {
-bool SetCertRequestHandler::HandleRequest(const unsigned char* data, int size,
- const std::string& locale) {
+bool SetCertRequestHandler::HandleRequest(unsigned char* data, int size,
+ const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
public:
SetCertRequestHandler(bool is_offline = false) :
AbstractRequestHandler(), is_offline_(is_offline) {}
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
private:
namespace pkgmgr_server {
namespace request_handler {
-bool SetPkginfoRequestHandler::HandleRequest(const unsigned char* data,
+bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data,
int size, const std::string& locale) {
auto abstract_parcel =
pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
public:
SetPkginfoRequestHandler(bool is_offline = false) :
AbstractRequestHandler(), is_offline_(is_offline) {}
- bool HandleRequest(const unsigned char* data, int size,
+ bool HandleRequest(unsigned char* data, int size,
const std::string& locale) override;
private:
handler->PreExec();
handler->SetUID(ConvertUID(req->GetSenderUID()));
handler->SetPID(req->GetSenderPID());
- if (!handler->HandleRequest(req->GetData(), req->GetSize(),
+ if (!handler->HandleRequest(req->DetachData(), req->GetSize(),
locale_.GetObject()))
LOG(ERROR) << "Failed to handle request";
0, pkgmgr_common::parcel::ParcelableType::Unknown, PMINFO_R_ERROR);
tizen_base::Parcel p;
p.WriteParcelable(parcelable);
- req->SendData(std::move(p));
+ req->SendData(p);
}
} // namespace pkgmgr_server
pp::DepInfoParcelable depinfo_parcelable;
parcel.WriteParcelable(appinfo_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
parcel.Clear();
parcel.WriteParcelable(certinfo_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
parcel.Clear();
parcel.WriteParcelable(filter_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
parcel.Clear();
parcel.WriteParcelable(pkginfo_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
parcel.Clear();
parcel.WriteParcelable(query_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
parcel.Clear();
parcel.WriteParcelable(result_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
parcel.Clear();
parcel.WriteParcelable(command_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Command);
parcel.Clear();
parcel.WriteParcelable(depinfo_parcelable);
- ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
- parcel.GetRaw().size());
+ ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+ parcel.GetDataSize(), true);
EXPECT_NE(ptr, nullptr);
EXPECT_EQ(ptr->GetType(), pp::ParcelableType::DepInfo);
parcel.Clear();