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