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