src/manager/client/client-manager-impl.cpp

   1 /* Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
   2  *
   3  *  Licensed under the Apache License, Version 2.0 (the "License");
   4  *  you may not use this file except in compliance with the License.
   5  *  You may obtain a copy of the License at
   6  *
   7  *      http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  *  Unless required by applicable law or agreed to in writing, software
  10  *  distributed under the License is distributed on an "AS IS" BASIS,
  11  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  *  See the License for the specific language governing permissions and
  13  *  limitations under the License
  14  *
  15  *
  16  * @file        client-manager-impl.cpp
  17  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  18  * @version     1.0
  19  * @brief       Manager implementation.
  20  */
  21 #include <dpl/serialization.h>
  22
  23 #include <client-manager-impl.h>
  24 #include <client-common.h>
  25 #include <client-key-impl.h>
  26 #include <message-buffer.h>
  27 #include <protocols.h>
  28
  29 namespace CKM {
  30
  31 int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
  32     m_counter++;
  33
  34     return try_catch([&] {
  35         if (alias.empty() || key.empty())
  36             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
  37
  38         MessageBuffer send, recv;
  39         Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
  40         Serialization::Serialize(send, m_counter);
  41         Serialization::Serialize(send, static_cast<int>(toDBDataType(key.getType())));
  42         Serialization::Serialize(send, alias);
  43         Serialization::Serialize(send, key.getKey());
  44         Serialization::Serialize(send, PolicySerializable(policy));
  45
  46         int retCode = sendToServer(
  47             SERVICE_SOCKET_CKM_STORAGE,
  48             send.Pop(),
  49             recv);
  50
  51         if (KEY_MANAGER_API_SUCCESS != retCode) {
  52             return retCode;
  53         }
  54
  55         int command;
  56         int counter;
  57         int opType;
  58         Deserialization::Deserialize(recv, command);
  59         Deserialization::Deserialize(recv, counter);
  60         Deserialization::Deserialize(recv, opType);
  61         Deserialization::Deserialize(recv, retCode);
  62
  63         if (counter != m_counter) {
  64             return KEY_MANAGER_API_ERROR_UNKNOWN;
  65         }
  66
  67         return retCode;
  68     });
  69 }
  70
  71 int Manager::ManagerImpl::removeKey(const Alias &alias) {
  72     return try_catch([&] {
  73         if (alias.empty())
  74             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
  75
  76         MessageBuffer send, recv;
  77         Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
  78         Serialization::Serialize(send, m_counter);
  79         Serialization::Serialize(send, static_cast<int>(DBDataType::KEY_RSA_PUBLIC));
  80         Serialization::Serialize(send, alias);
  81
  82         int retCode = sendToServer(
  83             SERVICE_SOCKET_CKM_STORAGE,
  84             send.Pop(),
  85             recv);
  86
  87         if (KEY_MANAGER_API_SUCCESS != retCode) {
  88             return retCode;
  89         }
  90
  91         int command;
  92         int counter;
  93         int opType;
  94         Deserialization::Deserialize(recv, command);
  95         Deserialization::Deserialize(recv, counter);
  96         Deserialization::Deserialize(recv, opType);
  97         Deserialization::Deserialize(recv, retCode);
  98
  99         if (counter != m_counter) {
 100             return KEY_MANAGER_API_ERROR_UNKNOWN;
 101         }
 102
 103         return retCode;
 104     });
 105 }
 106
 107 int Manager::ManagerImpl::getBinaryData(
 108     const Alias &alias,
 109     DBDataType sendDataType,
 110     const RawData &password,
 111     DBDataType &recvDataType,
 112     RawData &rawData)
 113 {
 114     return try_catch([&] {
 115         if (alias.empty())
 116             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
 117
 118         MessageBuffer send, recv;
 119         Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
 120         Serialization::Serialize(send, m_counter);
 121         Serialization::Serialize(send, static_cast<int>(sendDataType));
 122         Serialization::Serialize(send, alias);
 123         Serialization::Serialize(send, password);
 124
 125         int retCode = sendToServer(
 126             SERVICE_SOCKET_CKM_STORAGE,
 127             send.Pop(),
 128             recv);
 129
 130         if (KEY_MANAGER_API_SUCCESS != retCode) {
 131             return retCode;
 132         }
 133
 134         int command;
 135         int counter;
 136         int opType;
 137         Deserialization::Deserialize(recv, command);
 138         Deserialization::Deserialize(recv, counter);
 139         Deserialization::Deserialize(recv, opType);
 140         Deserialization::Deserialize(recv, retCode);
 141
 142         if (retCode == KEY_MANAGER_API_SUCCESS) {
 143             int tmpDataType;
 144             Deserialization::Deserialize(recv, tmpDataType);
 145             Deserialization::Deserialize(recv, rawData);
 146             recvDataType = static_cast<DBDataType>(tmpDataType);
 147         }
 148
 149         if (counter != m_counter) {
 150             return KEY_MANAGER_API_ERROR_UNKNOWN;
 151         }
 152
 153         return retCode;
 154     });
 155 }
 156
 157 int Manager::ManagerImpl::getKey(const Alias &alias, const RawData &password, Key &key) {
 158     DBDataType recvDataType;
 159     RawData rawData;
 160
 161     int retCode = getBinaryData(
 162         alias,
 163         DBDataType::KEY_RSA_PUBLIC,
 164         password,
 165         recvDataType,
 166         rawData);
 167
 168     if (retCode != KEY_MANAGER_API_SUCCESS)
 169         return retCode;
 170
 171     Key keyParsed(rawData, toKeyType(recvDataType));
 172
 173     if (keyParsed.empty())
 174         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
 175
 176     key = keyParsed;
 177
 178     return KEY_MANAGER_API_SUCCESS;
 179 }
 180
 181 } // namespace CKM
 182