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 StorageReceiver::StorageReceiver(MessageBuffer& buffer, AsyncRequest::Map& requests) :
  32     m_buffer(buffer),
  33     m_requests(requests),
  34     m_observer(NULL)
  35 {
  36 }
  37
  38 void StorageReceiver::parseResponse()
  39 {
  40     int command = 0, id = 0;
  41     m_buffer.Deserialize(command, id);
  42
  43     auto it = m_requests.find(id);
  44     if (it == m_requests.end()) {
  45         LogError("Request with id " << id << " not found!");
  46         ThrowMsg(BadResponse, "Request with id " << id << " not found!");
  47     }
  48
  49     // let it throw
  50     AsyncRequest req = std::move(m_requests.at(id));
  51     m_requests.erase(id);
  52
  53     m_observer = req.observer;
  54
  55     switch (static_cast<LogicCommand>(command)) {
  56     case LogicCommand::GET:
  57         parseGetCommand();
  58         break;
  59     case LogicCommand::GET_PKCS12:
  60         parseGetPKCS12Command();
  61         break;
  62     case LogicCommand::GET_LIST:
  63         parseGetListCommand();
  64         break;
  65     case LogicCommand::SAVE:
  66         parseSaveCommand();
  67         break;
  68     case LogicCommand::SAVE_PKCS12:
  69         parseSavePKCS12Command();
  70         break;
  71     case LogicCommand::REMOVE:
  72         parseRemoveCommand();
  73         break;
  74     case LogicCommand::CREATE_KEY_PAIR:
  75         parseRetCode(&ManagerAsync::Observer::ReceivedCreateKeyPair);
  76         break;
  77     case LogicCommand::GET_CHAIN_CERT:
  78     case LogicCommand::GET_CHAIN_ALIAS:
  79         parseGetChainCertCommand();
  80         break;
  81     case LogicCommand::CREATE_SIGNATURE:
  82         parseCreateSignatureCommand();
  83         break;
  84     case LogicCommand::VERIFY_SIGNATURE:
  85         parseRetCode(&ManagerAsync::Observer::ReceivedVerifySignature);
  86         break;
  87     case LogicCommand::SET_PERMISSION:
  88         parseRetCode(&ManagerAsync::Observer::ReceivedSetPermission);
  89         break;
  90
  91     default:
  92         LogError("Unknown command id: " << command);
  93         ThrowMsg(BadResponse, "Unknown command id: " << command);
  94         break;
  95     }
  96 }
  97
  98 void StorageReceiver::parseGetCommand()
  99 {
 100     RawBuffer rawData;
 101     int dataType = 0, retCode = 0;
 102     m_buffer.Deserialize(retCode, dataType, rawData);
 103
 104     // check error code
 105     if (retCode != CKM_API_SUCCESS) {
 106          m_observer->ReceivedError(retCode);
 107          return;
 108     }
 109
 110     DataType type(dataType);
 111     if (type.isKey())
 112         m_observer->ReceivedKey(KeyImpl(rawData));
 113     else if (type.isCertificate())
 114         m_observer->ReceivedCertificate(CertificateImpl(rawData, DataFormat::FORM_DER));
 115     else if (type.isBinaryData())
 116         m_observer->ReceivedData(std::move(rawData));
 117     else
 118         m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 119 }
 120
 121 void StorageReceiver::parseGetPKCS12Command()
 122 {
 123     int retCode;
 124     PKCS12Serializable gotPkcs;
 125     m_buffer.Deserialize(retCode, gotPkcs);
 126
 127     // check error code
 128     if (retCode != CKM_API_SUCCESS) {
 129          m_observer->ReceivedError(retCode);
 130          return;
 131     }
 132
 133     m_observer->ReceivedPKCS12(std::make_shared<PKCS12Impl>(std::move(gotPkcs)));
 134 }
 135
 136 void StorageReceiver::parseGetListCommand()
 137 {
 138     int dataType = 0, retCode = 0;
 139     LabelNameVector labelNameVector;
 140     m_buffer.Deserialize(retCode, dataType, labelNameVector);
 141
 142     // check error code
 143     if (retCode != CKM_API_SUCCESS) {
 144          m_observer->ReceivedError(retCode);
 145          return;
 146     }
 147
 148     AliasVector aliasVector;
 149     for(const auto &it : labelNameVector)
 150         aliasVector.push_back( AliasSupport::merge(it.first, it.second) );
 151
 152     DataType type(dataType);
 153
 154     if (type.isKey())
 155         m_observer->ReceivedKeyAliasVector(std::move(aliasVector));
 156     else if (type.isCertificate())
 157         m_observer->ReceivedCertificateAliasVector(std::move(aliasVector));
 158     else if (type.isBinaryData())
 159         m_observer->ReceivedDataAliasVector(std::move(aliasVector));
 160     else
 161         m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 162 }
 163
 164 void StorageReceiver::parseSaveCommand()
 165 {
 166     int dataType = 0, retCode = 0;
 167     m_buffer.Deserialize(retCode, dataType);
 168
 169     // check error code
 170     if (retCode != CKM_API_SUCCESS) {
 171          m_observer->ReceivedError(retCode);
 172          return;
 173     }
 174
 175     DataType type(dataType);
 176     if (type.isKey())
 177         m_observer->ReceivedSaveKey();
 178     else if (type.isCertificate())
 179         m_observer->ReceivedSaveCertificate();
 180     else if (type.isBinaryData())
 181         m_observer->ReceivedSaveData();
 182     else
 183         m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 184 }
 185
 186 void StorageReceiver::parseSavePKCS12Command()
 187 {
 188     int retCode = 0;
 189     m_buffer.Deserialize(retCode);
 190
 191     // check error code
 192     if (retCode != CKM_API_SUCCESS) {
 193          m_observer->ReceivedError(retCode);
 194          return;
 195     }
 196
 197     m_observer->ReceivedSavePKCS12();
 198 }
 199
 200 void StorageReceiver::parseRemoveCommand()
 201 {
 202     int retCode = 0;
 203     m_buffer.Deserialize(retCode);
 204
 205     // check error code
 206     if (retCode != CKM_API_SUCCESS) {
 207          m_observer->ReceivedError(retCode);
 208          return;
 209     }
 210
 211     m_observer->ReceivedRemovedAlias();
 212 }
 213
 214 void StorageReceiver::parseGetChainCertCommand()
 215 {
 216     CertificateShPtrVector certificateChainVector;
 217     RawBufferVector rawBufferVector;
 218     int retCode = 0;
 219     m_buffer.Deserialize(retCode, rawBufferVector);
 220
 221     // check error code
 222     if (retCode != CKM_API_SUCCESS) {
 223          m_observer->ReceivedError(retCode);
 224          return;
 225     }
 226
 227     for (auto &e: rawBufferVector) {
 228         CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
 229         if (cert->empty()) {
 230             m_observer->ReceivedError(CKM_API_ERROR_BAD_RESPONSE);
 231             return;
 232         }
 233         certificateChainVector.push_back(cert);
 234     }
 235     m_observer->ReceivedGetCertificateChain(std::move(certificateChainVector));
 236 }
 237
 238 void StorageReceiver::parseCreateSignatureCommand()
 239 {
 240     int retCode = 0;
 241     RawBuffer signature;
 242     m_buffer.Deserialize(retCode, signature);
 243
 244     // check error code
 245     if (retCode != CKM_API_SUCCESS) {
 246          m_observer->ReceivedError(retCode);
 247          return;
 248     }
 249
 250     m_observer->ReceivedCreateSignature(std::move(signature));
 251 }
 252
 253 void StorageReceiver::parseSetPermission()
 254 {
 255     int retCode;
 256     m_buffer.Deserialize(retCode);
 257
 258     // check error code
 259     if (retCode != CKM_API_SUCCESS) {
 260          m_observer->ReceivedError(retCode);
 261          return;
 262     }
 263
 264     m_observer->ReceivedSetPermission();
 265 }
 266
 267 void StorageReceiver::parseRetCode(ObserverCb callback)
 268 {
 269     int retCode = 0;
 270     m_buffer.Deserialize(retCode);
 271
 272     // check error code
 273     if (retCode != CKM_API_SUCCESS) {
 274          m_observer->ReceivedError(retCode);
 275          return;
 276     }
 277
 278     (m_observer.get()->*callback)();
 279 }
 280
 281 } /* namespace CKM */