ace_client/src/ace_api_client.cpp

   1 /*
   2  * Copyright (c) 2011 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_api_client.cpp
  18  * @author      Tomasz Swierczek (t.swierczek@samsung.com)
  19  * @version     1.0
  20  * @brief       This file contains implementation of ACE client API
  21  */
  22
  23 #include <dpl/log/log.h>
  24 #include <ace_popup_handler.h>
  25 #include "ace_api_client.h"
  26 #include "ace-client/ace_client.h"
  27
  28 #include <string>
  29 #include <vector>
  30 #include "popup_response_server_api.h"
  31 #ifdef DBUS_CONNECTION
  32 #include <dpl/dbus/dbus_client.h>
  33 #include "security_daemon_dbus_config.h"
  34 //#include "PromptModel.h"
  35 #endif
  36
  37
  38 ace_return_t ace_client_initialize(ace_popup_handler_func_t handler)
  39 {
  40     if (!AceClient::AceThinClientSingleton::Instance().isInitialized()) {
  41         return ACE_INTERNAL_ERROR;
  42     }
  43     popup_func = handler;
  44     // Changed order of checks to make API run with old popup implementation
  45     // instead of always needing the popup handler to be implemented.
  46     if (NULL == handler) {
  47         LogError("NULL argument(s) passed");
  48         return ACE_INVALID_ARGUMENTS;
  49     }
  50     return ACE_OK;
  51 }
  52
  53 ace_return_t ace_client_shutdown(void)
  54 {
  55     popup_func = NULL;
  56     return ACE_OK;
  57 }
  58
  59 ace_return_t ace_check_access_ex(const ace_request_t* request, ace_check_result_t* result)
  60 {
  61     if (NULL == request || NULL == result) {
  62         LogError("NULL argument(s) passed");
  63         return ACE_INVALID_ARGUMENTS;
  64     }
  65
  66     AceClient::AceRequest aceRequest;
  67     aceRequest.sessionId = request->session_id;
  68     aceRequest.widgetHandle = request->widget_handle;
  69
  70     aceRequest.apiFeatures.count = request->feature_list.count;
  71     aceRequest.apiFeatures.apiFeature =
  72             const_cast<const char**>(request->feature_list.items);
  73     aceRequest.functionName = NULL; // TODO will  be removed
  74     aceRequest.deviceCapabilities.devcapsCount = request->dev_cap_list.count;
  75     aceRequest.deviceCapabilities.paramsCount = request->dev_cap_list.count;
  76
  77     char** devCapNames = new char*[request->dev_cap_list.count];
  78     AceClient::AceParamList* paramList =
  79             new AceClient::AceParamList[request->dev_cap_list.count];
  80
  81     unsigned int i;
  82     for (i = 0; i < request->dev_cap_list.count; ++i) {
  83         devCapNames[i] = request->dev_cap_list.items[i].name;
  84         paramList[i].count = request->dev_cap_list.items[i].param_list.count;
  85
  86         paramList[i].param = new AceClient::AceParam[
  87                                request->dev_cap_list.items[i].param_list.count];
  88
  89         unsigned int j;
  90         for (j = 0; j < request->dev_cap_list.items[i].param_list.count; ++j) {
  91             paramList[i].param[j].name =
  92                     request->dev_cap_list.items[i].param_list.items[j].name;
  93             paramList[i].param[j].value =
  94                     request->dev_cap_list.items[i].param_list.items[j].value;
  95
  96         }
  97     }
  98
  99     aceRequest.deviceCapabilities.devCapNames =
 100             const_cast<const char**>(devCapNames);
 101     aceRequest.deviceCapabilities.params = paramList;
 102
 103     bool ret = false;
 104
 105     Try {
 106         ret = AceClient::AceThinClientSingleton::
 107                 Instance().checkFunctionCall(aceRequest);
 108         *result = ret ? ACE_ACCESS_GRANTED : ACE_PRIVILEGE_DENIED;
 109
 110         if (*result == ACE_ACCESS_GRANTED) {
 111             ret = AceClient::AceThinClientSingleton::
 112                 Instance().checkPrivacy(aceRequest);
 113             *result = ret ? ACE_ACCESS_GRANTED : ACE_PRIVACY_DENIED;
 114         }
 115     } Catch (AceClient::AceThinClient::Exception::AceThinClientException) {
 116         LogError("Ace client exception");
 117         delete [] devCapNames;
 118         for (i = 0; i < request->dev_cap_list.count; ++i) {
 119             delete [] paramList[i].param;
 120         }
 121         delete [] paramList;
 122         return ACE_INTERNAL_ERROR;
 123     }
 124
 125     delete [] devCapNames;
 126     for (i = 0; i < request->dev_cap_list.count; ++i) {
 127         delete [] paramList[i].param;
 128     }
 129     delete [] paramList;
 130     return ACE_OK;
 131 }