Receive client's request at each thread

[platform/core/appfw/pkgmgr-info.git] / src / server / pkg_request.cc

diff --git a/src/server/pkg_request.cc b/src/server/pkg_request.cc
index 0ae4438..e018219 100644 (file)
--- a/src/server/pkg_request.cc
+++ b/src/server/pkg_request.cc
@@ -15,54 +15,82 @@
  */
 
 #include "pkg_request.hh"
+
+#include "utils/logging.hh"
+
 #include "pkgmgrinfo_debug.h"
 
 namespace pkgmgr_server {
 
+PkgRequest::PkgRequest()
+    : request_type_(pkgmgr_common::REQ_TYPE_NONE), data_size_(-1),
+        privilege_checked_(false) {}
+
 PkgRequest::PkgRequest(int fd)
-    : fd_(fd), request_type_(pkgmgr_common::REQ_TYPE_NONE), data_size_(-1) {
+    : request_type_(pkgmgr_common::REQ_TYPE_NONE), data_size_(-1),
+        privilege_checked_(false) {
   socket_ = std::unique_ptr<pkgmgr_common::socket::DataSocket>(
-      new (std::nothrow) pkgmgr_common::socket::DataSocket(fd_));
-  if (socket_ == nullptr) LOGE("Out of memory");
+      new (std::nothrow) pkgmgr_common::socket::DataSocket(fd));
+  if (socket_ == nullptr)
+    LOG(ERROR) << "Out of memory";
 }
 
 PkgRequest::~PkgRequest() {
-  if (data_ != nullptr) delete[] data_;
+  if (data_ != nullptr)
+    delete[] data_;
 }
 
-unsigned char* PkgRequest::GetData() { return data_; }
+const unsigned char* PkgRequest::GetData() {
+  return data_;
+}
 
-int PkgRequest::GetSize() { return data_size_; }
+int PkgRequest::GetSize() {
+  return data_size_;
+}
+
+int PkgRequest::GetFd() {
+  return socket_->GetFd();
+}
 
-pkgmgr_common::ReqType PkgRequest::GetRequestType() { return request_type_; }
+pid_t PkgRequest::GetSenderPID() {
+  return socket_->GetPID();
+}
+
+uid_t PkgRequest::GetSenderUID() {
+  return socket_->GetUID();
+}
+
+pkgmgr_common::ReqType PkgRequest::GetRequestType() {
+  return request_type_;
+}
 
 bool PkgRequest::ReceiveData() {
   int ret = socket_->ReceiveData(&request_type_, sizeof(request_type_));
   if (ret < 0 || request_type_ == pkgmgr_common::REQ_TYPE_NONE) {
-    LOGE("Failed to ReceiveData");
+    LOG(ERROR) << "Failed to ReceiveData";
     return false;
   }
   ret = socket_->ReceiveData(&data_size_, sizeof(data_size_));
   if (ret < 0) {
-    LOGE("Failed to ReceiveData");
+    LOG(ERROR) << "Failed to ReceiveData";
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
     return false;
   }
-  if (data_size_ < 0) {
-    LOGE("Invalid data");
+  if (data_size_ <= 0) {
+    LOG(ERROR) << "Invalid data";
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
     return false;
   }
 
   data_ = new (std::nothrow) unsigned char[data_size_];
   if (data_ == nullptr) {
-    LOGE("Out of memory");
+    LOG(ERROR) << "Out of memory";
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
     return false;
   }
-  ret = socket_->ReceiveData((void*)data_, data_size_);
+  ret = socket_->ReceiveData(reinterpret_cast<void*>(data_), data_size_);
   if (ret < 0) {
-    LOGE("Failed to ReceiveData");
+    LOG(ERROR) << "Failed to ReceiveData";
     delete[] data_;
     data_ = nullptr;
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
@@ -76,7 +104,15 @@ bool PkgRequest::SendData(unsigned char* data, int size) {
   if (socket_->SendData(&size, sizeof(size)) < 0)
     return false;
 
-  return (socket_->SendData(data, size) < 0);
+  return (socket_->SendData(data, size) == 0);
+}
+
+bool PkgRequest::GetPrivilegeChecked() {
+  return privilege_checked_;
+}
+
+void PkgRequest::SetPrivilegeChecked(bool checked) {
+  privilege_checked_ = checked;
 }
 
 }  // namespace pkgmgr_server