src/manager/client-async/storage-receiver.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 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       receiver.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #include <storage-receiver.h>
  23 #include <protocols.h>
  24 #include <dpl/log/log.h>
  25 #include <key-impl.h>
  26 #include <certificate-impl.h>
  27 #include <client-common.h>
  28
  29 namespace CKM {
  30
  31 namespace {
  32
  33 enum class DataType {
  34     KEY,
  35     CERT,
  36     DATA
  37 };
  38
  39 DataType type(int dbDataType)
  40 {
  41     switch(static_cast<DBDataType>(dbDataType))
  42     {
  43     case DBDataType::KEY_RSA_PUBLIC:
  44     case DBDataType::KEY_RSA_PRIVATE:
  45     case DBDataType::KEY_ECDSA_PUBLIC:
  46     case DBDataType::KEY_ECDSA_PRIVATE:
  47     case DBDataType::KEY_DSA_PUBLIC:
  48     case DBDataType::KEY_DSA_PRIVATE:
  49     case DBDataType::KEY_AES:
  50         return DataType::KEY;
  51
  52     case DBDataType::CERTIFICATE:
  53         return DataType::CERT;
  54
  55     case DBDataType::BINARY_DATA:
  56         return DataType::DATA;
  57
  58     default:
  59         LogError("Unsupported data type: " <<dbDataType);
  60         ThrowMsg(IReceiver::BadResponse, "Unsupported data type: " << dbDataType);
  61     }
  62 }
  63
  64 } // namespace anonymous
  65
  66 StorageReceiver::StorageReceiver(MessageBuffer& buffer, AsyncRequest::Map& requests) :
  67     m_buffer(buffer),
  68     m_requests(requests),
  69     m_observer(NULL)
  70 {
  71 }
  72
  73 void StorageReceiver::parseResponse()
  74 {
  75     int command, id;
  76     m_buffer.Deserialize(command, id);
  77
  78     auto it = m_requests.find(id);
  79     if (it == m_requests.end()) {
  80         LogError("Request with id " << id << " not found!");
  81         ThrowMsg(BadResponse, "Request with id " << id << " not found!");
  82     }
  83
  84     // let it throw
  85     AsyncRequest req = std::move(m_requests.at(id));
  86     m_requests.erase(id);
  87
  88     m_observer = req.observer;
  89
  90     switch (static_cast<LogicCommand>(command)) {
  91     case LogicCommand::GET:
  92         parseGetCommand();
  93         break ;
  94     case LogicCommand::GET_LIST:
  95         parseGetListCommand();
  96         break;
  97     case LogicCommand::SAVE:
  98         parseSaveCommand();
  99         break;
 100     case LogicCommand::REMOVE:
 101         parseRemoveCommand();
 102         break;
 103     case LogicCommand::CREATE_KEY_PAIR_RSA:
 104         parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairRSA);
 105         break;
 106     case LogicCommand::CREATE_KEY_PAIR_ECDSA:
 107         parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairECDSA);
 108         break;
 109     case LogicCommand::GET_CHAIN_CERT:
 110     case LogicCommand::GET_CHAIN_ALIAS:
 111         parseGetChainCertCommand();
 112         break;
 113     case LogicCommand::CREATE_SIGNATURE:
 114         parseCreateSignatureCommand();
 115         break;
 116     case LogicCommand::VERIFY_SIGNATURE:
 117         parseRetCode(&ManagerAsync::Observer::ReceivedVerifySignature);
 118         break;
 119     case LogicCommand::CREATE_KEY_PAIR_DSA:
 120         parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPairDSA);
 121         break;
 122     case LogicCommand::ALLOW_ACCESS:
 123         parseRetCode(&ManagerAsync::Observer::ReceivedAllowAccess);
 124         break;
 125     case LogicCommand::DENY_ACCESS:
 126         parseRetCode(&ManagerAsync::Observer::ReceivedDenyAccess);
 127         break;
 128
 129     default:
 130         LogError("Unknown command id: " << command);
 131         ThrowMsg(BadResponse, "Unknown command id: " << command);
 132         break;
 133     }
 134 }
 135
 136 void StorageReceiver::parseGetCommand()
 137 {
 138     RawBuffer rawData;
 139     int dataType, retCode;
 140     m_buffer.Deserialize(retCode, dataType, rawData);
 141
 142     // check error code
 143     if (retCode != CKM_API_SUCCESS) {
 144          m_observer->ReceivedError(retCode);
 145          return;
 146     }
 147
 148     switch(type(dataType))
 149     {
 150     case DataType::KEY:
 151         m_observer->ReceivedKey(KeyImpl(rawData));
 152         break;
 153     case DataType::CERT:
 154         m_observer->ReceivedCertificate(CertificateImpl(rawData, DataFormat::FORM_DER));
 155         break;
 156     case DataType::DATA:
 157         m_observer->ReceivedData(std::move(rawData));
 158         break;
 159     }
 160 }
 161
 162 void StorageReceiver::parseGetListCommand()
 163 {
 164     int dataType, retCode;
 165     LabelAliasVector labelAliasVector;
 166     m_buffer.Deserialize(retCode, dataType, labelAliasVector);
 167
 168     // check error code
 169     if (retCode != CKM_API_SUCCESS) {
 170          m_observer->ReceivedError(retCode);
 171          return;
 172     }
 173
 174     AliasVector aliasVector;
 175     for(const auto it : labelAliasVector)
 176         aliasVector.push_back( AliasSupport::merge(it.first, it.second) );
 177
 178     switch(type(dataType))
 179     {
 180     case DataType::KEY:
 181         m_observer->ReceivedKeyAliasVector(std::move(aliasVector));
 182         break;
 183     case DataType::CERT:
 184         m_observer->ReceivedCertificateAliasVector(std::move(aliasVector));
 185         break;
 186     case DataType::DATA:
 187         m_observer->ReceivedDataAliasVector(std::move(aliasVector));
 188         break;
 189     }
 190 }
 191
 192 void StorageReceiver::parseSaveCommand()
 193 {
 194     int dataType, retCode;
 195     m_buffer.Deserialize(retCode, dataType);
 196
 197     // check error code
 198     if (retCode != CKM_API_SUCCESS) {
 199          m_observer->ReceivedError(retCode);
 200          return;
 201     }
 202
 203     switch(type(dataType))
 204     {
 205     case DataType::KEY:
 206         m_observer->ReceivedSaveKey();
 207         break;
 208     case DataType::CERT:
 209         m_observer->ReceivedSaveCertificate();
 210         break;
 211     case DataType::DATA:
 212         m_observer->ReceivedSaveData();
 213         break;
 214     }
 215 }
 216
 217 void StorageReceiver::parseRemoveCommand()
 218 {
 219     int dataType, retCode;
 220     m_buffer.Deserialize(retCode, dataType);
 221
 222     // check error code
 223     if (retCode != CKM_API_SUCCESS) {
 224          m_observer->ReceivedError(retCode);
 225          return;
 226     }
 227
 228     switch(type(dataType))
 229     {
 230     case DataType::KEY:
 231         m_observer->ReceivedSaveKey();
 232         break;
 233     case DataType::CERT:
 234         m_observer->ReceivedSaveCertificate();
 235         break;
 236     case DataType::DATA:
 237         m_observer->ReceivedSaveData();
 238         break;
 239     }
 240 }
 241
 242 void StorageReceiver::parseGetChainCertCommand()
 243 {
 244     CertificateShPtrVector certificateChainVector;
 245     RawBufferVector rawBufferVector;
 246     int retCode;
 247     m_buffer.Deserialize(retCode, rawBufferVector);
 248
 249     // check error code
 250     if (retCode != CKM_API_SUCCESS) {
 251          m_observer->ReceivedError(retCode);
 252          return;
 253     }
 254
 255     for (auto &e: rawBufferVector) {
 256         CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
 257         if (cert->empty()) {
 258             m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 259             return;
 260         }
 261         certificateChainVector.push_back(cert);
 262     }
 263     m_observer->ReceivedGetCertificateChain(std::move(certificateChainVector));
 264 }
 265
 266 void StorageReceiver::parseCreateSignatureCommand()
 267 {
 268     int retCode;
 269     RawBuffer signature;
 270     m_buffer.Deserialize(retCode, signature);
 271
 272     // check error code
 273     if (retCode != CKM_API_SUCCESS) {
 274          m_observer->ReceivedError(retCode);
 275          return;
 276     }
 277
 278     m_observer->ReceivedCreateSignature(std::move(signature));
 279 }
 280
 281 void StorageReceiver::parseAllowAccessCommand()
 282 {
 283     int retCode;
 284     m_buffer.Deserialize(retCode);
 285
 286     // check error code
 287     if (retCode != CKM_API_SUCCESS) {
 288          m_observer->ReceivedError(retCode);
 289          return;
 290     }
 291
 292     m_observer->ReceivedAllowAccess();
 293 }
 294
 295 void StorageReceiver::parseDenyAccessCommand()
 296 {
 297     int retCode;
 298     m_buffer.Deserialize(retCode);
 299
 300     // check error code
 301     if (retCode != CKM_API_SUCCESS) {
 302          m_observer->ReceivedError(retCode);
 303          return;
 304     }
 305
 306     m_observer->ReceivedDenyAccess();
 307 }
 308
 309 void StorageReceiver::parseRetCode(ObserverCb callback)
 310 {
 311     int retCode;
 312     m_buffer.Deserialize(retCode);
 313
 314     // check error code
 315     if (retCode != CKM_API_SUCCESS) {
 316          m_observer->ReceivedError(retCode);
 317          return;
 318     }
 319
 320     (m_observer.get()->*callback)();
 321 }
 322
 323 } /* namespace CKM */