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