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