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