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