src/common/protocol/ProtocolAdmin.cpp

   1 /*
   2  * Copyright (c) 2014-2015 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  * @author      Pawel Wieczorek <p.wieczorek2@samsung.com>
  21  * @version     1.0
  22  * @brief       This file implements protocol class for administration
  23  */
  24
  25 #include <cinttypes>
  26 #include <memory>
  27
  28 #include <exceptions/InvalidProtocolException.h>
  29 #include <log/log.h>
  30 #include <protocol/ProtocolFrame.h>
  31 #include <protocol/ProtocolFrameSerializer.h>
  32 #include <request/AdminCheckRequest.h>
  33 #include <request/DescriptionListRequest.h>
  34 #include <request/EraseRequest.h>
  35 #include <request/InsertOrUpdateBucketRequest.h>
  36 #include <request/ListRequest.h>
  37 #include <request/RemoveBucketRequest.h>
  38 #include <request/RequestContext.h>
  39 #include <request/SetPoliciesRequest.h>
  40 #include <response/AdminCheckResponse.h>
  41 #include <response/CodeResponse.h>
  42 #include <response/DescriptionListResponse.h>
  43 #include <response/ListResponse.h>
  44 #include <types/PolicyKey.h>
  45
  46 #include "ProtocolAdmin.h"
  47
  48 namespace Cynara {
  49
  50 ProtocolAdmin::ProtocolAdmin() {
  51 }
  52
  53 ProtocolAdmin::~ProtocolAdmin() {
  54 }
  55
  56 ProtocolPtr ProtocolAdmin::clone(void) {
  57     return std::make_shared<ProtocolAdmin>();
  58 }
  59
  60 RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(void) {
  61     std::string clientId, userId, privilegeId;
  62     PolicyBucketId startBucket;
  63     bool recursive;
  64
  65     ProtocolDeserialization::deserialize(m_frameHeader, clientId);
  66     ProtocolDeserialization::deserialize(m_frameHeader, userId);
  67     ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
  68     ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
  69     ProtocolDeserialization::deserialize(m_frameHeader, recursive);
  70
  71     LOGD("Deserialized AdminCheckRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
  72          "startBucket <%s>, recursive [%d]", clientId.c_str(), userId.c_str(),
  73          privilegeId.c_str(), startBucket.c_str(), recursive);
  74
  75     return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
  76                                                startBucket, recursive,
  77                                                m_frameHeader.sequenceNumber());
  78 }
  79
  80 RequestPtr ProtocolAdmin::deserializeDescriptionListRequest(void) {
  81     LOGD("Deserialized DescriptionListRequest");
  82     return std::make_shared<DescriptionListRequest>(m_frameHeader.sequenceNumber());
  83 }
  84
  85 RequestPtr ProtocolAdmin::deserializeEraseRequest(void) {
  86     PolicyBucketId startBucket;
  87     bool recursive;
  88     PolicyKeyFeature::ValueType client, user, privilege;
  89
  90     ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
  91     ProtocolDeserialization::deserialize(m_frameHeader, recursive);
  92     ProtocolDeserialization::deserialize(m_frameHeader, client);
  93     ProtocolDeserialization::deserialize(m_frameHeader, user);
  94     ProtocolDeserialization::deserialize(m_frameHeader, privilege);
  95
  96     LOGD("Deserialized EraseRequest: startBucket <%s>, recursive [%d], filter client <%s> "
  97          "filter user <%s>, filter privilege <%s>", startBucket.c_str(),
  98          static_cast<int>(recursive), client.c_str(), user.c_str(), privilege.c_str());
  99
 100     return std::make_shared<EraseRequest>(startBucket, recursive,
 101                                           PolicyKey(client, user, privilege),
 102                                           m_frameHeader.sequenceNumber());
 103 }
 104
 105 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(void) {
 106     PolicyBucketId policyBucketId;
 107     PolicyType policyType;
 108     PolicyResult::PolicyMetadata policyMetaData;
 109
 110     ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
 111     ProtocolDeserialization::deserialize(m_frameHeader, policyType);
 112     ProtocolDeserialization::deserialize(m_frameHeader, policyMetaData);
 113
 114     LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
 115          "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
 116          policyType, policyMetaData.c_str());
 117
 118     return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
 119             PolicyResult(policyType, policyMetaData), m_frameHeader.sequenceNumber());
 120 }
 121
 122 RequestPtr ProtocolAdmin::deserializeListRequest(void) {
 123     PolicyBucketId bucketId;
 124     PolicyKeyFeature::ValueType client, user, privilege;
 125
 126     ProtocolDeserialization::deserialize(m_frameHeader, bucketId);
 127     ProtocolDeserialization::deserialize(m_frameHeader, client);
 128     ProtocolDeserialization::deserialize(m_frameHeader, user);
 129     ProtocolDeserialization::deserialize(m_frameHeader, privilege);
 130
 131     LOGD("Deserialized ListRequest: bucketId <%s>, filter client <%s> filter user <%s>, filter "
 132          "privilege <%s>", bucketId.c_str(), client.c_str(), user.c_str(), privilege.c_str());
 133
 134     return std::make_shared<ListRequest>(bucketId, PolicyKey(client, user, privilege),
 135                                          m_frameHeader.sequenceNumber());
 136 }
 137
 138 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(void) {
 139     PolicyBucketId policyBucketId;
 140
 141     ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
 142
 143     LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
 144
 145     return std::make_shared<RemoveBucketRequest>(policyBucketId, m_frameHeader.sequenceNumber());
 146 }
 147
 148 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(void) {
 149     ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
 150     ProtocolFrameFieldsCount policyCount;
 151     PolicyKeyFeature::ValueType clientId, user, privilege;
 152     PolicyType policyType;
 153     PolicyResult::PolicyMetadata metadata;
 154     std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
 155     std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
 156
 157     ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedCount);
 158     for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
 159         PolicyBucketId policyBucketId;
 160         ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
 161         ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
 162         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
 163             // PolicyKey
 164             ProtocolDeserialization::deserialize(m_frameHeader, clientId);
 165             ProtocolDeserialization::deserialize(m_frameHeader, user);
 166             ProtocolDeserialization::deserialize(m_frameHeader, privilege);
 167             // PolicyResult
 168             ProtocolDeserialization::deserialize(m_frameHeader, policyType);
 169             ProtocolDeserialization::deserialize(m_frameHeader, metadata);
 170
 171             toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
 172                     Policy(PolicyKey(clientId, user, privilege),
 173                     PolicyResult(policyType, metadata)));
 174         }
 175     }
 176
 177     ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedCount);
 178     for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
 179         PolicyBucketId policyBucketId;
 180         ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
 181         ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
 182         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
 183             // PolicyKey
 184             ProtocolDeserialization::deserialize(m_frameHeader, clientId);
 185             ProtocolDeserialization::deserialize(m_frameHeader, user);
 186             ProtocolDeserialization::deserialize(m_frameHeader, privilege);
 187
 188             toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
 189         }
 190     }
 191
 192     LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
 193          "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
 194
 195     return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
 196                                                 toBeRemovedPolicies,
 197                                                 m_frameHeader.sequenceNumber());
 198 }
 199
 200 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
 201     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 202
 203     if (m_frameHeader.isFrameComplete()) {
 204         ProtocolOpCode opCode;
 205
 206         m_frameHeader.resetState();
 207         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 208         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
 209         switch (opCode) {
 210         case OpAdminCheckRequest:
 211             return deserializeAdminCheckRequest();
 212         case OpDescriptionListRequest:
 213             return deserializeDescriptionListRequest();
 214         case OpEraseRequest:
 215             return deserializeEraseRequest();
 216         case OpInsertOrUpdateBucket:
 217             return deserializeInsertOrUpdateBucketRequest();
 218         case OpListRequest:
 219             return deserializeListRequest();
 220         case OpRemoveBucket:
 221             return deserializeRemoveBucketRequest();
 222         case OpSetPolicies:
 223             return deserializeSetPoliciesRequest();
 224         default:
 225             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 226             break;
 227         }
 228     }
 229
 230     return nullptr;
 231 }
 232
 233 ResponsePtr ProtocolAdmin::deserializeAdminCheckResponse(void) {
 234     PolicyType result;
 235     PolicyResult::PolicyMetadata additionalInfo;
 236     bool bucketValid;
 237     bool dbCorrupted;
 238
 239     ProtocolDeserialization::deserialize(m_frameHeader, result);
 240     ProtocolDeserialization::deserialize(m_frameHeader, additionalInfo);
 241     ProtocolDeserialization::deserialize(m_frameHeader, bucketValid);
 242     ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
 243
 244     const PolicyResult policyResult(result, additionalInfo);
 245
 246     LOGD("Deserialized AdminCheckResponse: result [%" PRIu16 "], metadata <%s>, bucketValid [%d], "
 247          "dbCorrupted [%d]", policyResult.policyType(), policyResult.metadata().c_str(),
 248          static_cast<int>(bucketValid), static_cast<int>(dbCorrupted));
 249
 250     return std::make_shared<AdminCheckResponse>(policyResult, bucketValid, dbCorrupted,
 251                                                 m_frameHeader.sequenceNumber());
 252 }
 253
 254 ResponsePtr ProtocolAdmin::deserializeCodeResponse(void) {
 255     ProtocolResponseCode responseCode;
 256     ProtocolDeserialization::deserialize(m_frameHeader, responseCode);
 257
 258     LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
 259
 260     return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
 261                                           m_frameHeader.sequenceNumber());
 262 }
 263
 264 ResponsePtr ProtocolAdmin::deserializeDescriptionListResponse(void) {
 265     ProtocolFrameFieldsCount descriptionsCount;
 266
 267     ProtocolDeserialization::deserialize(m_frameHeader, descriptionsCount);
 268     std::vector<PolicyDescription> descriptions(descriptionsCount,
 269                                                 PolicyDescription(PredefinedPolicyType::NONE));
 270
 271     for (ProtocolFrameFieldsCount fields = 0; fields < descriptionsCount; fields++) {
 272         ProtocolDeserialization::deserialize(m_frameHeader, descriptions[fields].type);
 273         ProtocolDeserialization::deserialize(m_frameHeader, descriptions[fields].name);
 274     }
 275
 276     bool dbCorrupted;
 277     ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
 278
 279     LOGD("Deserialized DescriptionListResponse: number of descriptions [%" PRIu16 "], "
 280          "dbCorrupted [%d]", descriptionsCount, static_cast<int>(dbCorrupted));
 281
 282     return std::make_shared<DescriptionListResponse>(descriptions, dbCorrupted,
 283                                                      m_frameHeader.sequenceNumber());
 284 }
 285
 286 ResponsePtr ProtocolAdmin::deserializeListResponse(void) {
 287     ProtocolFrameFieldsCount policiesCount;
 288     PolicyKeyFeature::ValueType client, user, privilege;
 289     PolicyType policyType;
 290     PolicyResult::PolicyMetadata metadata;
 291     std::vector<Policy> policies;
 292
 293     ProtocolDeserialization::deserialize(m_frameHeader, policiesCount);
 294     policies.reserve(policiesCount);
 295
 296     for (ProtocolFrameFieldsCount p = 0; p < policiesCount; ++p) {
 297         // PolicyKey
 298         ProtocolDeserialization::deserialize(m_frameHeader, client);
 299         ProtocolDeserialization::deserialize(m_frameHeader, user);
 300         ProtocolDeserialization::deserialize(m_frameHeader, privilege);
 301         // PolicyResult
 302         ProtocolDeserialization::deserialize(m_frameHeader, policyType);
 303         ProtocolDeserialization::deserialize(m_frameHeader, metadata);
 304
 305         policies.push_back(Policy(PolicyKey(client, user, privilege),
 306                                         PolicyResult(policyType, metadata)));
 307     }
 308
 309     bool bucketValid;
 310     bool dbCorrupted;
 311     ProtocolDeserialization::deserialize(m_frameHeader, bucketValid);
 312     ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
 313
 314     LOGD("Deserialized ListResponse: number of policies [%" PRIu16 "], bucketValid [%d], "
 315          "dbCorrupted [%d]", policiesCount, static_cast<int>(bucketValid),
 316          static_cast<int>(dbCorrupted));
 317
 318     return std::make_shared<ListResponse>(policies, bucketValid, dbCorrupted,
 319                                           m_frameHeader.sequenceNumber());
 320
 321 }
 322
 323 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
 324     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 325
 326     if (m_frameHeader.isFrameComplete()) {
 327         ProtocolOpCode opCode;
 328
 329         m_frameHeader.resetState();
 330         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 331         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
 332         switch (opCode) {
 333         case OpAdminCheckPolicyResponse:
 334             return deserializeAdminCheckResponse();
 335         case OpCodeResponse:
 336             return deserializeCodeResponse();
 337         case OpDescriptionListResponse:
 338             return deserializeDescriptionListResponse();
 339         case OpListResponse:
 340             return deserializeListResponse();
 341         default:
 342             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 343             break;
 344         }
 345     }
 346
 347     return nullptr;
 348 }
 349
 350 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr request) {
 351     LOGD("Serializing AdminCheckRequest: client <%s>, user <%s>, privilege <%s>, "
 352          "startBucket <%s>, recursive [%d]", request->key().client().value().c_str(),
 353          request->key().user().value().c_str(), request->key().privilege().value().c_str(),
 354          request->startBucket().c_str(), request->recursive());
 355
 356     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 357
 358     ProtocolSerialization::serialize(frame, OpAdminCheckRequest);
 359     ProtocolSerialization::serialize(frame, request->key().client().value());
 360     ProtocolSerialization::serialize(frame, request->key().user().value());
 361     ProtocolSerialization::serialize(frame, request->key().privilege().value());
 362     ProtocolSerialization::serialize(frame, request->startBucket());
 363     ProtocolSerialization::serialize(frame, request->recursive());
 364
 365     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 366 }
 367
 368 void ProtocolAdmin::execute(RequestContextPtr context, DescriptionListRequestPtr request) {
 369     LOGD("Serializing DescriptionListRequest");
 370     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 371
 372     ProtocolSerialization::serialize(frame, OpDescriptionListRequest);
 373
 374     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 375 }
 376
 377 void ProtocolAdmin::execute(RequestContextPtr context, EraseRequestPtr request) {
 378     LOGD("Serializing EraseRequest: sequenceNumber [%" PRIu16 "], startBucket <%s>, "
 379          "recursive [%d], filter client <%s> filter user <%s> filter privilege <%s>",
 380          request->sequenceNumber(), request->startBucket().c_str(),
 381          static_cast<int>(request->recursive()), request->filter().client().value().c_str(),
 382          request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
 383
 384     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 385
 386     ProtocolSerialization::serialize(frame, OpEraseRequest);
 387     ProtocolSerialization::serialize(frame, request->startBucket());
 388     ProtocolSerialization::serialize(frame, request->recursive());
 389     ProtocolSerialization::serialize(frame, request->filter().client().value());
 390     ProtocolSerialization::serialize(frame, request->filter().user().value());
 391     ProtocolSerialization::serialize(frame, request->filter().privilege().value());
 392
 393     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 394 }
 395
 396 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
 397     LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
 398          "result.type [%" PRIu16 "], result.meta <%s>", request->sequenceNumber(),
 399          request->bucketId().c_str(), request->result().policyType(),
 400          request->result().metadata().c_str());
 401
 402     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 403
 404     ProtocolSerialization::serialize(frame, OpInsertOrUpdateBucket);
 405     ProtocolSerialization::serialize(frame, request->bucketId());
 406     ProtocolSerialization::serialize(frame, request->result().policyType());
 407     ProtocolSerialization::serialize(frame, request->result().metadata());
 408
 409     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 410 }
 411
 412 void ProtocolAdmin::execute(RequestContextPtr context, ListRequestPtr request) {
 413     LOGD("Serializing ListRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
 414          "filter client <%s> filter user <%s> filter privilege <%s>", request->sequenceNumber(),
 415          request->bucket().c_str(), request->filter().client().value().c_str(),
 416          request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
 417
 418     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 419
 420     ProtocolSerialization::serialize(frame, OpListRequest);
 421     ProtocolSerialization::serialize(frame, request->bucket());
 422     ProtocolSerialization::serialize(frame, request->filter().client().value());
 423     ProtocolSerialization::serialize(frame, request->filter().user().value());
 424     ProtocolSerialization::serialize(frame, request->filter().privilege().value());
 425
 426     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 427 }
 428
 429 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
 430     LOGD("Serializing RemoveBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>",
 431          request->sequenceNumber(), request->bucketId().c_str());
 432
 433     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 434
 435     ProtocolSerialization::serialize(frame, OpRemoveBucket);
 436     ProtocolSerialization::serialize(frame, request->bucketId());
 437
 438     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 439 }
 440
 441 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
 442     LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%" PRIu16 "], "
 443          "insertOrUpdate count [%zu], remove count [%zu]", request->sequenceNumber(),
 444          request->policiesToBeInsertedOrUpdated().size(), request->policiesToBeRemoved().size());
 445
 446     ProtocolFrame frame =
 447             ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 448
 449     ProtocolSerialization::serialize(frame, OpSetPolicies);
 450
 451     ProtocolSerialization::serialize(frame,
 452             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
 453     for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
 454         ProtocolSerialization::serialize(frame, policyBucket.first);
 455         ProtocolSerialization::serialize(frame,
 456                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 457         for (auto policy : policyBucket.second) {
 458             // PolicyKey
 459             ProtocolSerialization::serialize(frame, policy.key().client().value());
 460             ProtocolSerialization::serialize(frame, policy.key().user().value());
 461             ProtocolSerialization::serialize(frame, policy.key().privilege().value());
 462             // PolicyResult
 463             ProtocolSerialization::serialize(frame, policy.result().policyType());
 464             ProtocolSerialization::serialize(frame, policy.result().metadata());
 465         }
 466     }
 467
 468     ProtocolSerialization::serialize(frame,
 469             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
 470     for (auto policyBucket : request->policiesToBeRemoved()) {
 471         ProtocolSerialization::serialize(frame, policyBucket.first);
 472         ProtocolSerialization::serialize(frame,
 473                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 474         for (auto policyKey : policyBucket.second) {
 475             // PolicyKey
 476             ProtocolSerialization::serialize(frame, policyKey.client().value());
 477             ProtocolSerialization::serialize(frame, policyKey.user().value());
 478             ProtocolSerialization::serialize(frame, policyKey.privilege().value());
 479         }
 480     }
 481
 482     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 483 }
 484
 485 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckResponsePtr response) {
 486     LOGD("Serializing AdminCheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 487          "policyType [%" PRIu16 "], metadata <%s>, bucketValid [%d], dbCorrupted [%d]",
 488          OpAdminCheckPolicyResponse, response->sequenceNumber(), response->result().policyType(),
 489          response->result().metadata().c_str(), static_cast<int>(response->isBucketValid()),
 490          static_cast<int>(response->isDbCorrupted()));
 491
 492     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
 493             response->sequenceNumber());
 494
 495     ProtocolSerialization::serialize(frame, OpAdminCheckPolicyResponse);
 496     ProtocolSerialization::serialize(frame, response->result().policyType());
 497     ProtocolSerialization::serialize(frame, response->result().metadata());
 498     ProtocolSerialization::serialize(frame, response->isBucketValid());
 499     ProtocolSerialization::serialize(frame, response->isDbCorrupted());
 500
 501     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 502 }
 503
 504 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
 505     LOGD("Serializing CodeResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 506          "code [%" PRIu16 "]", OpCodeResponse, response->sequenceNumber(), response->m_code);
 507
 508     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
 509             response->sequenceNumber());
 510
 511     ProtocolSerialization::serialize(frame, OpCodeResponse);
 512     ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
 513
 514     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 515 }
 516
 517 void ProtocolAdmin::execute(RequestContextPtr context, DescriptionListResponsePtr response) {
 518     ProtocolFrameFieldsCount descriptionsSize
 519         = static_cast<ProtocolFrameFieldsCount>(response->descriptions().size());
 520
 521     LOGD("Serializing DescriptionListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 522          "number of descriptions [%" PRIu16 "], dbCorrupted [%d]", OpDescriptionListResponse,
 523          response->sequenceNumber(), descriptionsSize, static_cast<int>(response->isDbCorrupted()));
 524
 525     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
 526
 527     ProtocolSerialization::serialize(frame, OpDescriptionListResponse);
 528     ProtocolSerialization::serialize(frame, descriptionsSize);
 529     for (auto &desc : response->descriptions()) {
 530         ProtocolSerialization::serialize(frame, desc.type);
 531         ProtocolSerialization::serialize(frame, desc.name);
 532     }
 533     ProtocolSerialization::serialize(frame, response->isDbCorrupted());
 534
 535     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 536 }
 537
 538 void ProtocolAdmin::execute(RequestContextPtr context, ListResponsePtr response) {
 539     ProtocolFrameFieldsCount policiesSize
 540         = static_cast<ProtocolFrameFieldsCount>(response->policies().size());
 541
 542     LOGD("Serializing ListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
 543          "number of policies [%" PRIu16 "], bucketValid [%d], dbCorrupted [%d]", OpListResponse,
 544          response->sequenceNumber(), policiesSize, static_cast<int>(response->isBucketValid()),
 545          static_cast<int>(response->isDbCorrupted()));
 546
 547     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
 548
 549     ProtocolSerialization::serialize(frame, OpListResponse);
 550     ProtocolSerialization::serialize(frame, policiesSize);
 551     for (auto &policy : response->policies()) {
 552         // PolicyKey
 553         ProtocolSerialization::serialize(frame, policy.key().client().value());
 554         ProtocolSerialization::serialize(frame, policy.key().user().value());
 555         ProtocolSerialization::serialize(frame, policy.key().privilege().value());
 556         // PolicyResult
 557         ProtocolSerialization::serialize(frame, policy.result().policyType());
 558         ProtocolSerialization::serialize(frame, policy.result().metadata());
 559     }
 560     ProtocolSerialization::serialize(frame, response->isBucketValid());
 561     ProtocolSerialization::serialize(frame, response->isDbCorrupted());
 562
 563     ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 564 }
 565
 566 } // namespace Cynara