src/common/protocol/ProtocolAdmin.cpp

   1 /*
   2  * Copyright (c) 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        src/common/protocol/ProtocolAdmin.cpp
  18  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  19  * @author      Adam Malinowski <a.malinowsk2@partner.samsung.com>
  20  * @version     1.0
  21  * @brief       This file implements protocol class for administration
  22  */
  23
  24 #include <cinttypes>
  25 #include <memory>
  26
  27 #include <exceptions/InvalidProtocolException.h>
  28 #include <log/log.h>
  29 #include <protocol/ProtocolFrame.h>
  30 #include <protocol/ProtocolFrameSerializer.h>
  31 #include <request/AdminCheckRequest.h>
  32 #include <request/InsertOrUpdateBucketRequest.h>
  33 #include <request/RemoveBucketRequest.h>
  34 #include <request/RequestContext.h>
  35 #include <request/SetPoliciesRequest.h>
  36 #include <response/CheckResponse.h>
  37 #include <response/CodeResponse.h>
  38
  39 #include "ProtocolAdmin.h"
  40
  41 namespace Cynara {
  42
  43 ProtocolAdmin::ProtocolAdmin() {
  44 }
  45
  46 ProtocolAdmin::~ProtocolAdmin() {
  47 }
  48
  49 ProtocolPtr ProtocolAdmin::clone(void) {
  50     return std::make_shared<ProtocolAdmin>();
  51 }
  52
  53 RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(ProtocolFrameHeader &frame) {
  54     std::string clientId, userId, privilegeId;
  55     PolicyBucketId startBucket;
  56     bool recursive;
  57
  58     ProtocolDeserialization::deserialize(frame, clientId);
  59     ProtocolDeserialization::deserialize(frame, userId);
  60     ProtocolDeserialization::deserialize(frame, privilegeId);
  61     ProtocolDeserialization::deserialize(frame, startBucket);
  62     ProtocolDeserialization::deserialize(frame, recursive);
  63
  64     LOGD("Deserialized AdminCheckRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
  65          "startBucket <%s>, recursive [%d]", clientId.c_str(), userId.c_str(),
  66          privilegeId.c_str(), startBucket.c_str(), recursive);
  67
  68     return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
  69                                                startBucket, recursive, frame.sequenceNumber());
  70 }
  71
  72 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(ProtocolFrameHeader &frame) {
  73     PolicyBucketId policyBucketId;
  74     PolicyType policyType;
  75     PolicyResult::PolicyMetadata policyMetaData;
  76
  77     ProtocolDeserialization::deserialize(frame, policyBucketId);
  78     ProtocolDeserialization::deserialize(frame, policyType);
  79     ProtocolDeserialization::deserialize(frame, policyMetaData);
  80
  81     LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
  82          "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
  83          policyType, policyMetaData.c_str());
  84
  85     return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
  86             PolicyResult(policyType, policyMetaData), frame.sequenceNumber());
  87 }
  88
  89 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(ProtocolFrameHeader &frame) {
  90     PolicyBucketId policyBucketId;
  91
  92     ProtocolDeserialization::deserialize(frame, policyBucketId);
  93
  94     LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
  95
  96     return std::make_shared<RemoveBucketRequest>(policyBucketId, frame.sequenceNumber());
  97 }
  98
  99 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &frame) {
 100     ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
 101     ProtocolFrameFieldsCount policyCount;
 102     PolicyKeyFeature::ValueType clientId, user, privilege;
 103     PolicyType policyType;
 104     PolicyResult::PolicyMetadata metadata;
 105     std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
 106     std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
 107
 108     ProtocolDeserialization::deserialize(frame, toBeInsertedOrUpdatedCount);
 109     for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
 110         PolicyBucketId policyBucketId;
 111         ProtocolDeserialization::deserialize(frame, policyBucketId);
 112         ProtocolDeserialization::deserialize(frame, policyCount);
 113         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
 114             // PolicyKey
 115             ProtocolDeserialization::deserialize(frame, clientId);
 116             ProtocolDeserialization::deserialize(frame, user);
 117             ProtocolDeserialization::deserialize(frame, privilege);
 118             // PolicyResult
 119             ProtocolDeserialization::deserialize(frame, policyType);
 120             ProtocolDeserialization::deserialize(frame, metadata);
 121
 122             toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
 123                     Policy(PolicyKey(clientId, user, privilege),
 124                     PolicyResult(policyType, metadata)));
 125         }
 126     }
 127
 128     ProtocolDeserialization::deserialize(frame, toBeRemovedCount);
 129     for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
 130         PolicyBucketId policyBucketId;
 131         ProtocolDeserialization::deserialize(frame, policyBucketId);
 132         ProtocolDeserialization::deserialize(frame, policyCount);
 133         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
 134             // PolicyKey
 135             ProtocolDeserialization::deserialize(frame, clientId);
 136             ProtocolDeserialization::deserialize(frame, user);
 137             ProtocolDeserialization::deserialize(frame, privilege);
 138
 139             toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
 140         }
 141     }
 142
 143     LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
 144          "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
 145
 146     return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
 147                                                 toBeRemovedPolicies, frame.sequenceNumber());
 148 }
 149
 150 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
 151     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 152
 153     if (m_frameHeader.isFrameComplete()) {
 154         ProtocolOpCode opCode;
 155
 156         m_frameHeader.resetState();
 157         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 158         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
 159         switch (opCode) {
 160         case OpAdminCheckRequest:
 161             return deserializeAdminCheckRequest(m_frameHeader);
 162         case OpInsertOrUpdateBucket:
 163             return deserializeInsertOrUpdateBucketRequest(m_frameHeader);
 164         case OpRemoveBucket:
 165             return deserializeRemoveBucketRequest(m_frameHeader);
 166         case OpSetPolicies:
 167             return deserializeSetPoliciesRequest(m_frameHeader);
 168         default:
 169             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 170             break;
 171         }
 172     }
 173
 174     return nullptr;
 175 }
 176
 177 ResponsePtr ProtocolAdmin::deserializeCheckResponse(ProtocolFrameHeader &frame) {
 178     PolicyType result;
 179     PolicyResult::PolicyMetadata additionalInfo;
 180
 181     ProtocolDeserialization::deserialize(frame, result);
 182     ProtocolDeserialization::deserialize(frame, additionalInfo);
 183
 184     const PolicyResult policyResult(result, additionalInfo);
 185
 186     LOGD("Deserialized CheckResponse: result [%" PRIu16 "], metadata <%s>",
 187          policyResult.policyType(), policyResult.metadata().c_str());
 188
 189     return std::make_shared<CheckResponse>(policyResult, frame.sequenceNumber());
 190 }
 191
 192 ResponsePtr ProtocolAdmin::deserializeCodeResponse(ProtocolFrameHeader &frame) {
 193     ProtocolResponseCode responseCode;
 194     ProtocolDeserialization::deserialize(frame, responseCode);
 195
 196     LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
 197
 198     return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
 199                                           frame.sequenceNumber());
 200 }
 201
 202 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
 203     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 204
 205     if (m_frameHeader.isFrameComplete()) {
 206         ProtocolOpCode opCode;
 207
 208         m_frameHeader.resetState();
 209         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 210         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
 211         switch (opCode) {
 212         case OpCheckPolicyResponse:
 213             return deserializeCheckResponse(m_frameHeader);
 214         case OpCodeResponse:
 215             return deserializeCodeResponse(m_frameHeader);
 216         default:
 217             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 218             break;
 219         }
 220     }
 221
 222     return nullptr;
 223 }
 224
 225 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr request) {
 226     LOGD("Serializing AdminCheckRequest: client <%s>, user <%s>, privilege <%s>, "
 227          "startBucket <%s>, recursive [%d]", request->key().client().value().c_str(),
 228          request->key().user().value().c_str(), request->key().privilege().value().c_str(),
 229          request->startBucket().c_str(), request->recursive());
 230
 231     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 232
 233     ProtocolSerialization::serialize(frame, OpAdminCheckRequest);
 234     ProtocolSerialization::serialize(frame, request->key().client().value());
 235     ProtocolSerialization::serialize(frame, request->key().user().value());
 236     ProtocolSerialization::serialize(frame, request->key().privilege().value());
 237     ProtocolSerialization::serialize(frame, request->startBucket());
 238     ProtocolSerialization::serialize(frame, request->recursive());
 239
 240     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 241 }
 242
 243 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
 244     LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
 245          "result.type [%" PRIu16 "], result.meta <%s>", request->sequenceNumber(),
 246          request->bucketId().c_str(), request->result().policyType(),
 247          request->result().metadata().c_str());
 248
 249     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 250
 251     ProtocolSerialization::serialize(frame, OpInsertOrUpdateBucket);
 252     ProtocolSerialization::serialize(frame, request->bucketId());
 253     ProtocolSerialization::serialize(frame, request->result().policyType());
 254     ProtocolSerialization::serialize(frame, request->result().metadata());
 255
 256     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 257 }
 258
 259 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
 260     LOGD("Serializing RemoveBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>",
 261          request->sequenceNumber(), request->bucketId().c_str());
 262
 263     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 264
 265     ProtocolSerialization::serialize(frame, OpRemoveBucket);
 266     ProtocolSerialization::serialize(frame, request->bucketId());
 267
 268     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 269 }
 270
 271 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
 272     LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%" PRIu16 "], "
 273          "insertOrUpdate count [%zu], remove count [%zu]", request->sequenceNumber(),
 274          request->policiesToBeInsertedOrUpdated().size(), request->policiesToBeRemoved().size());
 275
 276     ProtocolFrame frame =
 277             ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 278
 279     ProtocolSerialization::serialize(frame, OpSetPolicies);
 280
 281     ProtocolSerialization::serialize(frame,
 282             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
 283     for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
 284         ProtocolSerialization::serialize(frame, policyBucket.first);
 285         ProtocolSerialization::serialize(frame,
 286                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 287         for (auto policy : policyBucket.second) {
 288             // PolicyKey
 289             ProtocolSerialization::serialize(frame, policy.key().client().value());
 290             ProtocolSerialization::serialize(frame, policy.key().user().value());
 291             ProtocolSerialization::serialize(frame, policy.key().privilege().value());
 292             // PolicyResult
 293             ProtocolSerialization::serialize(frame, policy.result().policyType());
 294             ProtocolSerialization::serialize(frame, policy.result().metadata());
 295         }
 296     }
 297
 298     ProtocolSerialization::serialize(frame,
 299             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
 300     for (auto policyBucket : request->policiesToBeRemoved()) {
 301         ProtocolSerialization::serialize(frame, policyBucket.first);
 302         ProtocolSerialization::serialize(frame,
 303                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 304         for (auto policyKey : policyBucket.second) {
 305             // PolicyKey
 306             ProtocolSerialization::serialize(frame, policyKey.client().value());
 307             ProtocolSerialization::serialize(frame, policyKey.user().value());
 308             ProtocolSerialization::serialize(frame, policyKey.privilege().value());
 309         }
 310     }
 311
 312     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 313 }
 314
 315 void ProtocolAdmin::execute(RequestContextPtr context, CheckResponsePtr response) {
 316     LOGD("Serializing CheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 317          "policyType [%" PRIu16 "], metadata <%s>", OpCheckPolicyResponse,
 318          response->sequenceNumber(), response->m_resultRef.policyType(),
 319          response->m_resultRef.metadata().c_str());
 320
 321     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
 322             response->sequenceNumber());
 323
 324     ProtocolSerialization::serialize(frame, OpCheckPolicyResponse);
 325     ProtocolSerialization::serialize(frame, response->m_resultRef.policyType());
 326     ProtocolSerialization::serialize(frame, response->m_resultRef.metadata());
 327
 328     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 329 }
 330
 331 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
 332     LOGD("Serializing CodeResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 333          "code [%" PRIu16 "]", OpCodeResponse, response->sequenceNumber(), response->m_code);
 334
 335     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
 336             response->sequenceNumber());
 337
 338     ProtocolSerialization::serialize(frame, OpCodeResponse);
 339     ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
 340
 341     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 342 }
 343
 344 } // namespace Cynara