return pkgmgr_common::ReqType::CREATE_CACHE;
}
-bool CreateCacheRequest::SendData(unsigned char* data, int size) {
- bool ret = static_cast<bool>(data[0]);
+bool CreateCacheRequest::SendData(tizen_base::Parcel parcel) {
+ bool ret = static_cast<bool>((parcel.GetRaw().data())[0]);
if (listener_ != nullptr)
listener_->OnCreateCacheDone(ret);
pid_t GetSenderPID() override;
uid_t GetSenderUID() override;
pkgmgr_common::ReqType GetRequestType() override;
- bool SendData(unsigned char* data, int size) override;
+ bool SendData(tizen_base::Parcel parcel) override;
bool GetPrivilegeChecked() override;
private:
return true;
}
-bool PkgRequest::SendData(unsigned char* data, int size) {
+bool PkgRequest::SendData(tizen_base::Parcel parcel) {
+ const std::vector<uint8_t>& raw = parcel.GetRaw();
+ unsigned int size = raw.size();
if (socket_->SendData(&size, sizeof(size)) < 0)
return false;
- return (socket_->SendData(data, size) == 0);
+ return (socket_->SendData(raw.data(), size) == 0);
}
bool PkgRequest::GetPrivilegeChecked() {
#include "data_socket.hh"
#include "request_type.hh"
+#include <parcel.hh>
+
namespace pkgmgr_server {
#ifndef EXPORT_API
virtual pid_t GetSenderPID();
virtual uid_t GetSenderUID();
virtual pkgmgr_common::ReqType GetRequestType();
- virtual bool SendData(unsigned char* data, int size);
+ virtual bool SendData(tizen_base::Parcel parcel);
virtual bool GetPrivilegeChecked();
virtual void SetPrivilegeChecked(bool cheked);
return uid_;
}
+tizen_base::Parcel AbstractRequestHandler::ExtractResult() {
+ tizen_base::Parcel parcel;
+ parcel.WriteParcelable(*result_);
+ const std::vector<uint8_t>& raw = parcel.GetRaw();
+
+ result_.reset();
+
+ return parcel;
+}
+
} // namespace request_handler
} // namespace pkgmgr_server
#ifndef SERVER_ABSTRACT_REQUEST_HANDLER_HH_
#define SERVER_ABSTRACT_REQUEST_HANDLER_HH_
+#include "abstract_parcelable.hh"
+
#include <string>
#include <sys/types.h>
virtual bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) = 0;
- virtual std::vector<uint8_t> ExtractResult() = 0;
+ virtual tizen_base::Parcel ExtractResult();
virtual void PreExec();
virtual void PostExec();
void SetUID(uid_t uid);
protected:
+ std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> result_;
pid_t GetPID();
uid_t GetUID();
return true;
}
-std::vector<uint8_t> CommandRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
public:
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
-
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
};
} // namespace request_handler
return success_;
}
-std::vector<uint8_t> CreateCacheRequestHandler::ExtractResult() {
- return { static_cast<uint8_t>(success_) };
+tizen_base::Parcel CreateCacheRequestHandler::ExtractResult() {
+ tizen_base::Parcel parcel;
+ parcel.WriteBool(success_);
+ return parcel;
}
void CreateCacheRequestHandler::PreExec() {
CreateCacheRequestHandler();
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
- std::vector<uint8_t> ExtractResult() override;
+ tizen_base::Parcel ExtractResult() override;
void PreExec() override;
void PostExec() override;
private:
bool success_ = false;
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
Scheduler scheduler_;
};
return true;
}
-std::vector<uint8_t> CreateDBRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
public:
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
-
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> GetAppinfoRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
public:
bool HandleRequest(const unsigned char* data, int size,
const std::string &locale) override;
-
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::AppInfoParcelable> result_;
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> GetCertRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
public:
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
-
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::CertInfoParcelable> result_;
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> GetDepinfoRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::DepInfoParcelable> result_;
-
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> GetPkginfoRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
public:
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
-
- std::vector<uint8_t> ExtractResult() override;
-
- private:
- std::shared_ptr<pkgmgr_common::parcel::PkgInfoParcelable> result_;
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> QueryRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
- std::vector<uint8_t> ExtractResult() override;
-
-private:
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
-
};
} // namespace request_handler
LOG(ERROR) << "Failed to handle request";
return nullptr;
}
- auto result = handler->ExtractResult();
- if (result.size() == 0) {
+ tizen_base::Parcel parcel = handler->ExtractResult();
+ const std::vector<uint8_t>& raw = parcel.GetRaw();
+ if (raw.size() == 0) {
LOG(ERROR) << "Fail to extract result";
return nullptr;
}
return pkgmgr_common::parcel::ParcelableFactory::GetInst()
- .CreateParcel(&result[0], result.size())
+ .CreateParcel(&raw[0], raw.size())
.release();
}
return true;
}
-std::vector<uint8_t> SetCertRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
- std::vector<uint8_t> ExtractResult() override;
-
private:
bool is_offline_;
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
};
} // namespace request_handler
return true;
}
-std::vector<uint8_t> SetPkginfoRequestHandler::ExtractResult() {
- tizen_base::Parcel parcel;
-
- parcel.WriteParcelable(*result_);
- std::vector<uint8_t> raw = parcel.GetRaw();
-
- result_.reset();
-
- return raw;
-}
-
} // namespace request_handler
} // namespace pkgmgr_server
bool HandleRequest(const unsigned char* data, int size,
const std::string& locale) override;
- std::vector<uint8_t> ExtractResult() override;
-
private:
bool is_offline_;
- std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
};
} // namespace request_handler
locale_.GetObject()))
LOG(ERROR) << "Failed to handle request";
- std::vector<uint8_t> result_data = handler->ExtractResult();
- if (req->SendData(result_data.data(), result_data.size()) == false)
+ if (req->SendData(handler->ExtractResult()) == false)
LOG(ERROR) << "Failed to send response pid: " << req->GetSenderPID();
else
LOG(WARNING) << "Success response pid: " << req->GetSenderPID();
0, pkgmgr_common::parcel::ParcelableType::Unknown, PMINFO_R_ERROR);
tizen_base::Parcel p;
p.WriteParcelable(parcelable);
- std::vector<uint8_t> raw = p.GetRaw();
- req->SendData(&raw[0], raw.size());
+ req->SendData(std::move(p));
}
} // namespace pkgmgr_server