src/services/ace/socket/ace_service_callbacks.cpp

   1 /*
   2  * Copyright (c) 2012 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  * @file        ace_service_callbacks.cpp
  18  * @author      Zofia Abramowska (z.abramowska@samsung.com)
  19  * @version     1.0
  20  * @brief       Implementation of Ace Service callbacks
  21  */
  22 #include <string>
  23 #include <vector>
  24 #include <dpl/log/log.h>
  25 #include "ace_service_callbacks.h"
  26 #include <callback_api.h>
  27 #include <ace/Request.h>
  28 #include <ace/PolicyResult.h>
  29 #include <security_controller.h>
  30 #include <security_caller.h>
  31 #include <attribute_facade.h>
  32
  33 namespace RPC {
  34
  35 void AceServiceCallbacks::checkAccess(SocketConnection * connector){
  36
  37     int widgetHandle = 0;
  38     std::string subject, resource, sessionId;
  39     std::vector<std::string> paramNames, paramValues;
  40     Try {
  41         connector->read(&widgetHandle,
  42                         &subject,
  43                         &resource,
  44                         &paramNames,
  45                         &paramValues,
  46                         &sessionId);
  47     } Catch (SocketConnection::Exception::SocketConnectionException){
  48         LogError("Socket Connection read error");
  49         ReThrowMsg(ServiceCallbackApi::Exception::ServiceCallbackException,
  50                    "Socket Connection read error");
  51     }
  52
  53     if (paramNames.size() != paramValues.size()) {
  54         ThrowMsg(ServiceCallbackApi::Exception::ServiceCallbackException, "Varying sizes of parameter names and parameter values");
  55     }
  56     LogDebug("We got subject: " << subject);
  57     LogDebug("We got resource: " << resource);
  58
  59     FunctionParamImpl params;
  60     for (size_t i = 0; i < paramNames.size(); ++i) {
  61         params.addAttribute(paramNames[i], paramValues[i]);
  62     }
  63
  64     Request request(widgetHandle,
  65                     WidgetExecutionPhase_Invoke,
  66                     &params);
  67     request.addDeviceCapability(resource);
  68
  69     PolicyResult result(PolicyEffect::DENY);
  70     SecurityCallerSingleton::Instance().SendSyncEvent(
  71         SecurityControllerEvents::CheckRuntimeCallSyncEvent(
  72             &result,
  73             &request,
  74             sessionId));
  75
  76     int response = PolicyResult::serialize(result);
  77
  78     Try{
  79         connector->write(response);
  80     } Catch (SocketConnection::Exception::SocketConnectionException){
  81         LogError("Socket Connection write error");
  82         ReThrowMsg(ServiceCallbackApi::Exception::ServiceCallbackException,
  83                    "Socket Connection write error");
  84     }
  85 }
  86
  87 void AceServiceCallbacks::checkAccessInstall(SocketConnection * connector){
  88
  89     int widgetHandle;
  90     std::string resource;
  91
  92     Try {
  93         connector->read(&widgetHandle,
  94                         &resource);
  95     } Catch (SocketConnection::Exception::SocketConnectionException){
  96         LogError("Socket Connection read error");
  97         ReThrowMsg(ServiceCallbackApi::Exception::ServiceCallbackException,
  98                    "Socket Connection read error");
  99     }
 100
 101     LogDebug("We got handle: " << widgetHandle);
 102     LogDebug("We got resource: " << resource);
 103
 104     Request request(widgetHandle,
 105           WidgetExecutionPhase_WidgetInstall);
 106     request.addDeviceCapability(resource);
 107
 108     PolicyResult result(PolicyEffect::DENY);
 109     SecurityCallerSingleton::Instance().SendSyncEvent(
 110             SecurityControllerEvents::CheckFunctionCallSyncEvent(
 111                     &result,
 112                     &request));
 113
 114     int response = PolicyResult::serialize(result);
 115
 116     Try{
 117         connector->write(response);
 118     }  Catch (SocketConnection::Exception::SocketConnectionException){
 119         LogError("Socket Connection write error");
 120         ReThrowMsg(ServiceCallbackApi::Exception::ServiceCallbackException,
 121                    "Socket Connection write error");
 122     }
 123 }
 124
 125 void AceServiceCallbacks::updatePolicy(SocketConnection * /*connector*/){
 126
 127
 128     LogDebug("Policy update socket message received");
 129     SecurityCallerSingleton::Instance().SendSyncEvent(
 130             SecurityControllerEvents::UpdatePolicySyncEvent());
 131 }
 132
 133 } //namespace RPC