X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fcommon%2Fprotocol%2FProtocolAdmin.cpp;h=35eedd8de30db924b2e0e82210efe76548e1ae7e;hb=refs%2Fchanges%2F21%2F36221%2F5;hp=ca17e34e2acc007b80839e0d3b2634891aa5dd6c;hpb=656f1a804ecf28619a0f7ea91ce26b43d27ec075;p=platform%2Fcore%2Fsecurity%2Fcynara.git

diff --git a/src/common/protocol/ProtocolAdmin.cpp b/src/common/protocol/ProtocolAdmin.cpp
index ca17e34..35eedd8 100644
--- a/src/common/protocol/ProtocolAdmin.cpp
+++ b/src/common/protocol/ProtocolAdmin.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd All Rights Reserved
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
  * @file        src/common/protocol/ProtocolAdmin.cpp
  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  * @author      Adam Malinowski <a.malinowsk2@partner.samsung.com>
+ * @author      Pawel Wieczorek <p.wieczorek2@samsung.com>
  * @version     1.0
  * @brief       This file implements protocol class for administration
  */
@@ -29,12 +30,18 @@
 #include <protocol/ProtocolFrame.h>
 #include <protocol/ProtocolFrameSerializer.h>
 #include <request/AdminCheckRequest.h>
+#include <request/DescriptionListRequest.h>
+#include <request/EraseRequest.h>
 #include <request/InsertOrUpdateBucketRequest.h>
+#include <request/ListRequest.h>
 #include <request/RemoveBucketRequest.h>
 #include <request/RequestContext.h>
 #include <request/SetPoliciesRequest.h>
-#include <response/CheckResponse.h>
+#include <response/AdminCheckResponse.h>
 #include <response/CodeResponse.h>
+#include <response/DescriptionListResponse.h>
+#include <response/ListResponse.h>
+#include <types/PolicyKey.h>
 
 #include "ProtocolAdmin.h"
 
@@ -50,53 +57,95 @@ ProtocolPtr ProtocolAdmin::clone(void) {
     return std::make_shared<ProtocolAdmin>();
 }
 
-RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(ProtocolFrameHeader &frame) {
+RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(void) {
     std::string clientId, userId, privilegeId;
     PolicyBucketId startBucket;
     bool recursive;
 
-    ProtocolDeserialization::deserialize(frame, clientId);
-    ProtocolDeserialization::deserialize(frame, userId);
-    ProtocolDeserialization::deserialize(frame, privilegeId);
-    ProtocolDeserialization::deserialize(frame, startBucket);
-    ProtocolDeserialization::deserialize(frame, recursive);
+    ProtocolDeserialization::deserialize(m_frameHeader, clientId);
+    ProtocolDeserialization::deserialize(m_frameHeader, userId);
+    ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
+    ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
+    ProtocolDeserialization::deserialize(m_frameHeader, recursive);
 
     LOGD("Deserialized AdminCheckRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
          "startBucket <%s>, recursive [%d]", clientId.c_str(), userId.c_str(),
          privilegeId.c_str(), startBucket.c_str(), recursive);
 
     return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
-                                               startBucket, recursive, frame.sequenceNumber());
+                                               startBucket, recursive,
+                                               m_frameHeader.sequenceNumber());
 }
 
-RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(ProtocolFrameHeader &frame) {
+RequestPtr ProtocolAdmin::deserializeDescriptionListRequest(void) {
+    LOGD("Deserialized DescriptionListRequest");
+    return std::make_shared<DescriptionListRequest>(m_frameHeader.sequenceNumber());
+}
+
+RequestPtr ProtocolAdmin::deserializeEraseRequest(void) {
+    PolicyBucketId startBucket;
+    bool recursive;
+    PolicyKeyFeature::ValueType client, user, privilege;
+
+    ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
+    ProtocolDeserialization::deserialize(m_frameHeader, recursive);
+    ProtocolDeserialization::deserialize(m_frameHeader, client);
+    ProtocolDeserialization::deserialize(m_frameHeader, user);
+    ProtocolDeserialization::deserialize(m_frameHeader, privilege);
+
+    LOGD("Deserialized EraseRequest: startBucket <%s>, recursive [%d], filter client <%s> "
+         "filter user <%s>, filter privilege <%s>", startBucket.c_str(),
+         static_cast<int>(recursive), client.c_str(), user.c_str(), privilege.c_str());
+
+    return std::make_shared<EraseRequest>(startBucket, recursive,
+                                          PolicyKey(client, user, privilege),
+                                          m_frameHeader.sequenceNumber());
+}
+
+RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(void) {
     PolicyBucketId policyBucketId;
     PolicyType policyType;
     PolicyResult::PolicyMetadata policyMetaData;
 
-    ProtocolDeserialization::deserialize(frame, policyBucketId);
-    ProtocolDeserialization::deserialize(frame, policyType);
-    ProtocolDeserialization::deserialize(frame, policyMetaData);
+    ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
+    ProtocolDeserialization::deserialize(m_frameHeader, policyType);
+    ProtocolDeserialization::deserialize(m_frameHeader, policyMetaData);
 
     LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
          "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
          policyType, policyMetaData.c_str());
 
     return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
-            PolicyResult(policyType, policyMetaData), frame.sequenceNumber());
+            PolicyResult(policyType, policyMetaData), m_frameHeader.sequenceNumber());
+}
+
+RequestPtr ProtocolAdmin::deserializeListRequest(void) {
+    PolicyBucketId bucketId;
+    PolicyKeyFeature::ValueType client, user, privilege;
+
+    ProtocolDeserialization::deserialize(m_frameHeader, bucketId);
+    ProtocolDeserialization::deserialize(m_frameHeader, client);
+    ProtocolDeserialization::deserialize(m_frameHeader, user);
+    ProtocolDeserialization::deserialize(m_frameHeader, privilege);
+
+    LOGD("Deserialized ListRequest: bucketId <%s>, filter client <%s> filter user <%s>, filter "
+         "privilege <%s>", bucketId.c_str(), client.c_str(), user.c_str(), privilege.c_str());
+
+    return std::make_shared<ListRequest>(bucketId, PolicyKey(client, user, privilege),
+                                         m_frameHeader.sequenceNumber());
 }
 
-RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(ProtocolFrameHeader &frame) {
+RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(void) {
     PolicyBucketId policyBucketId;
 
-    ProtocolDeserialization::deserialize(frame, policyBucketId);
+    ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
 
     LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
 
-    return std::make_shared<RemoveBucketRequest>(policyBucketId, frame.sequenceNumber());
+    return std::make_shared<RemoveBucketRequest>(policyBucketId, m_frameHeader.sequenceNumber());
 }
 
-RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &frame) {
+RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(void) {
     ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
     ProtocolFrameFieldsCount policyCount;
     PolicyKeyFeature::ValueType clientId, user, privilege;
@@ -105,19 +154,19 @@ RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &fra
     std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
     std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
 
-    ProtocolDeserialization::deserialize(frame, toBeInsertedOrUpdatedCount);
+    ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedCount);
     for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
         PolicyBucketId policyBucketId;
-        ProtocolDeserialization::deserialize(frame, policyBucketId);
-        ProtocolDeserialization::deserialize(frame, policyCount);
+        ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
+        ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
             // PolicyKey
-            ProtocolDeserialization::deserialize(frame, clientId);
-            ProtocolDeserialization::deserialize(frame, user);
-            ProtocolDeserialization::deserialize(frame, privilege);
+            ProtocolDeserialization::deserialize(m_frameHeader, clientId);
+            ProtocolDeserialization::deserialize(m_frameHeader, user);
+            ProtocolDeserialization::deserialize(m_frameHeader, privilege);
             // PolicyResult
-            ProtocolDeserialization::deserialize(frame, policyType);
-            ProtocolDeserialization::deserialize(frame, metadata);
+            ProtocolDeserialization::deserialize(m_frameHeader, policyType);
+            ProtocolDeserialization::deserialize(m_frameHeader, metadata);
 
             toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
                     Policy(PolicyKey(clientId, user, privilege),
@@ -125,16 +174,16 @@ RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &fra
         }
     }
 
-    ProtocolDeserialization::deserialize(frame, toBeRemovedCount);
+    ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedCount);
     for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
         PolicyBucketId policyBucketId;
-        ProtocolDeserialization::deserialize(frame, policyBucketId);
-        ProtocolDeserialization::deserialize(frame, policyCount);
+        ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
+        ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
             // PolicyKey
-            ProtocolDeserialization::deserialize(frame, clientId);
-            ProtocolDeserialization::deserialize(frame, user);
-            ProtocolDeserialization::deserialize(frame, privilege);
+            ProtocolDeserialization::deserialize(m_frameHeader, clientId);
+            ProtocolDeserialization::deserialize(m_frameHeader, user);
+            ProtocolDeserialization::deserialize(m_frameHeader, privilege);
 
             toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
         }
@@ -144,10 +193,11 @@ RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &fra
          "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
 
     return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
-                                                toBeRemovedPolicies, frame.sequenceNumber());
+                                                toBeRemovedPolicies,
+                                                m_frameHeader.sequenceNumber());
 }
 
-RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
+RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 
     if (m_frameHeader.isFrameComplete()) {
@@ -158,13 +208,19 @@ RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
         switch (opCode) {
         case OpAdminCheckRequest:
-            return deserializeAdminCheckRequest(m_frameHeader);
+            return deserializeAdminCheckRequest();
+        case OpDescriptionListRequest:
+            return deserializeDescriptionListRequest();
+        case OpEraseRequest:
+            return deserializeEraseRequest();
         case OpInsertOrUpdateBucket:
-            return deserializeInsertOrUpdateBucketRequest(m_frameHeader);
+            return deserializeInsertOrUpdateBucketRequest();
+        case OpListRequest:
+            return deserializeListRequest();
         case OpRemoveBucket:
-            return deserializeRemoveBucketRequest(m_frameHeader);
+            return deserializeRemoveBucketRequest();
         case OpSetPolicies:
-            return deserializeSetPoliciesRequest(m_frameHeader);
+            return deserializeSetPoliciesRequest();
         default:
             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
             break;
@@ -174,32 +230,97 @@ RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
     return nullptr;
 }
 
-ResponsePtr ProtocolAdmin::deserializeCheckResponse(ProtocolFrameHeader &frame) {
+ResponsePtr ProtocolAdmin::deserializeAdminCheckResponse(void) {
     PolicyType result;
     PolicyResult::PolicyMetadata additionalInfo;
+    bool bucketValid;
+    bool dbCorrupted;
 
-    ProtocolDeserialization::deserialize(frame, result);
-    ProtocolDeserialization::deserialize(frame, additionalInfo);
+    ProtocolDeserialization::deserialize(m_frameHeader, result);
+    ProtocolDeserialization::deserialize(m_frameHeader, additionalInfo);
+    ProtocolDeserialization::deserialize(m_frameHeader, bucketValid);
+    ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
 
     const PolicyResult policyResult(result, additionalInfo);
 
-    LOGD("Deserialized CheckResponse: result [%" PRIu16 "], metadata <%s>",
-         policyResult.policyType(), policyResult.metadata().c_str());
+    LOGD("Deserialized AdminCheckResponse: result [%" PRIu16 "], metadata <%s>, bucketValid [%d], "
+         "dbCorrupted [%d]", policyResult.policyType(), policyResult.metadata().c_str(),
+         static_cast<int>(bucketValid), static_cast<int>(dbCorrupted));
 
-    return std::make_shared<CheckResponse>(policyResult, frame.sequenceNumber());
+    return std::make_shared<AdminCheckResponse>(policyResult, bucketValid, dbCorrupted,
+                                                m_frameHeader.sequenceNumber());
 }
 
-ResponsePtr ProtocolAdmin::deserializeCodeResponse(ProtocolFrameHeader &frame) {
+ResponsePtr ProtocolAdmin::deserializeCodeResponse(void) {
     ProtocolResponseCode responseCode;
-    ProtocolDeserialization::deserialize(frame, responseCode);
+    ProtocolDeserialization::deserialize(m_frameHeader, responseCode);
 
     LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
 
     return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
-                                          frame.sequenceNumber());
+                                          m_frameHeader.sequenceNumber());
+}
+
+ResponsePtr ProtocolAdmin::deserializeDescriptionListResponse(void) {
+    ProtocolFrameFieldsCount descriptionsCount;
+
+    ProtocolDeserialization::deserialize(m_frameHeader, descriptionsCount);
+    std::vector<PolicyDescription> descriptions(descriptionsCount,
+                                                PolicyDescription(PredefinedPolicyType::NONE));
+
+    for (ProtocolFrameFieldsCount fields = 0; fields < descriptionsCount; fields++) {
+        ProtocolDeserialization::deserialize(m_frameHeader, descriptions[fields].type);
+        ProtocolDeserialization::deserialize(m_frameHeader, descriptions[fields].name);
+    }
+
+    bool dbCorrupted;
+    ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
+
+    LOGD("Deserialized DescriptionListResponse: number of descriptions [%" PRIu16 "], "
+         "dbCorrupted [%d]", descriptionsCount, static_cast<int>(dbCorrupted));
+
+    return std::make_shared<DescriptionListResponse>(descriptions, dbCorrupted,
+                                                     m_frameHeader.sequenceNumber());
+}
+
+ResponsePtr ProtocolAdmin::deserializeListResponse(void) {
+    ProtocolFrameFieldsCount policiesCount;
+    PolicyKeyFeature::ValueType client, user, privilege;
+    PolicyType policyType;
+    PolicyResult::PolicyMetadata metadata;
+    std::vector<Policy> policies;
+
+    ProtocolDeserialization::deserialize(m_frameHeader, policiesCount);
+    policies.reserve(policiesCount);
+
+    for (ProtocolFrameFieldsCount p = 0; p < policiesCount; ++p) {
+        // PolicyKey
+        ProtocolDeserialization::deserialize(m_frameHeader, client);
+        ProtocolDeserialization::deserialize(m_frameHeader, user);
+        ProtocolDeserialization::deserialize(m_frameHeader, privilege);
+        // PolicyResult
+        ProtocolDeserialization::deserialize(m_frameHeader, policyType);
+        ProtocolDeserialization::deserialize(m_frameHeader, metadata);
+
+        policies.push_back(Policy(PolicyKey(client, user, privilege),
+                                        PolicyResult(policyType, metadata)));
+    }
+
+    bool bucketValid;
+    bool dbCorrupted;
+    ProtocolDeserialization::deserialize(m_frameHeader, bucketValid);
+    ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
+
+    LOGD("Deserialized ListResponse: number of policies [%" PRIu16 "], bucketValid [%d], "
+         "dbCorrupted [%d]", policiesCount, static_cast<int>(bucketValid),
+         static_cast<int>(dbCorrupted));
+
+    return std::make_shared<ListResponse>(policies, bucketValid, dbCorrupted,
+                                          m_frameHeader.sequenceNumber());
+
 }
 
-ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
+ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 
     if (m_frameHeader.isFrameComplete()) {
@@ -209,10 +330,14 @@ ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
         LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
         switch (opCode) {
-        case OpCheckPolicyResponse:
-            return deserializeCheckResponse(m_frameHeader);
+        case OpAdminCheckPolicyResponse:
+            return deserializeAdminCheckResponse();
         case OpCodeResponse:
-            return deserializeCodeResponse(m_frameHeader);
+            return deserializeCodeResponse();
+        case OpDescriptionListResponse:
+            return deserializeDescriptionListResponse();
+        case OpListResponse:
+            return deserializeListResponse();
         default:
             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
             break;
@@ -237,7 +362,35 @@ void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr requ
     ProtocolSerialization::serialize(frame, request->startBucket());
     ProtocolSerialization::serialize(frame, request->recursive());
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
+}
+
+void ProtocolAdmin::execute(RequestContextPtr context, DescriptionListRequestPtr request) {
+    LOGD("Serializing DescriptionListRequest");
+    ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
+
+    ProtocolSerialization::serialize(frame, OpDescriptionListRequest);
+
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
+}
+
+void ProtocolAdmin::execute(RequestContextPtr context, EraseRequestPtr request) {
+    LOGD("Serializing EraseRequest: sequenceNumber [%" PRIu16 "], startBucket <%s>, "
+         "recursive [%d], filter client <%s> filter user <%s> filter privilege <%s>",
+         request->sequenceNumber(), request->startBucket().c_str(),
+         static_cast<int>(request->recursive()), request->filter().client().value().c_str(),
+         request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
+
+    ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
+
+    ProtocolSerialization::serialize(frame, OpEraseRequest);
+    ProtocolSerialization::serialize(frame, request->startBucket());
+    ProtocolSerialization::serialize(frame, request->recursive());
+    ProtocolSerialization::serialize(frame, request->filter().client().value());
+    ProtocolSerialization::serialize(frame, request->filter().user().value());
+    ProtocolSerialization::serialize(frame, request->filter().privilege().value());
+
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
@@ -253,7 +406,24 @@ void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketReque
     ProtocolSerialization::serialize(frame, request->result().policyType());
     ProtocolSerialization::serialize(frame, request->result().metadata());
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
+}
+
+void ProtocolAdmin::execute(RequestContextPtr context, ListRequestPtr request) {
+    LOGD("Serializing ListRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
+         "filter client <%s> filter user <%s> filter privilege <%s>", request->sequenceNumber(),
+         request->bucket().c_str(), request->filter().client().value().c_str(),
+         request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
+
+    ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
+
+    ProtocolSerialization::serialize(frame, OpListRequest);
+    ProtocolSerialization::serialize(frame, request->bucket());
+    ProtocolSerialization::serialize(frame, request->filter().client().value());
+    ProtocolSerialization::serialize(frame, request->filter().user().value());
+    ProtocolSerialization::serialize(frame, request->filter().privilege().value());
+
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
@@ -265,7 +435,7 @@ void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr re
     ProtocolSerialization::serialize(frame, OpRemoveBucket);
     ProtocolSerialization::serialize(frame, request->bucketId());
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
@@ -309,23 +479,26 @@ void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr req
         }
     }
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
-void ProtocolAdmin::execute(RequestContextPtr context, CheckResponsePtr response) {
-    LOGD("Serializing CheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
-         "policyType [%" PRIu16 "], metadata <%s>", OpCheckPolicyResponse,
-         response->sequenceNumber(), response->m_resultRef.policyType(),
-         response->m_resultRef.metadata().c_str());
+void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckResponsePtr response) {
+    LOGD("Serializing AdminCheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
+         "policyType [%" PRIu16 "], metadata <%s>, bucketValid [%d], dbCorrupted [%d]",
+         OpAdminCheckPolicyResponse, response->sequenceNumber(), response->result().policyType(),
+         response->result().metadata().c_str(), static_cast<int>(response->isBucketValid()),
+         static_cast<int>(response->isDbCorrupted()));
 
     ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
             response->sequenceNumber());
 
-    ProtocolSerialization::serialize(frame, OpCheckPolicyResponse);
-    ProtocolSerialization::serialize(frame, response->m_resultRef.policyType());
-    ProtocolSerialization::serialize(frame, response->m_resultRef.metadata());
+    ProtocolSerialization::serialize(frame, OpAdminCheckPolicyResponse);
+    ProtocolSerialization::serialize(frame, response->result().policyType());
+    ProtocolSerialization::serialize(frame, response->result().metadata());
+    ProtocolSerialization::serialize(frame, response->isBucketValid());
+    ProtocolSerialization::serialize(frame, response->isDbCorrupted());
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
@@ -338,7 +511,56 @@ void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response)
     ProtocolSerialization::serialize(frame, OpCodeResponse);
     ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
 
-    ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
+}
+
+void ProtocolAdmin::execute(RequestContextPtr context, DescriptionListResponsePtr response) {
+    ProtocolFrameFieldsCount descriptionsSize
+        = static_cast<ProtocolFrameFieldsCount>(response->descriptions().size());
+
+    LOGD("Serializing DescriptionListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
+         "number of descriptions [%" PRIu16 "], dbCorrupted [%d]", OpDescriptionListResponse,
+         response->sequenceNumber(), descriptionsSize, static_cast<int>(response->isDbCorrupted()));
+
+    ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
+
+    ProtocolSerialization::serialize(frame, OpDescriptionListResponse);
+    ProtocolSerialization::serialize(frame, descriptionsSize);
+    for (auto &desc : response->descriptions()) {
+        ProtocolSerialization::serialize(frame, desc.type);
+        ProtocolSerialization::serialize(frame, desc.name);
+    }
+    ProtocolSerialization::serialize(frame, response->isDbCorrupted());
+
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
+}
+
+void ProtocolAdmin::execute(RequestContextPtr context, ListResponsePtr response) {
+    ProtocolFrameFieldsCount policiesSize
+        = static_cast<ProtocolFrameFieldsCount>(response->policies().size());
+
+    LOGD("Serializing ListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
+         "number of policies [%" PRIu16 "], bucketValid [%d], dbCorrupted [%d]", OpListResponse,
+         response->sequenceNumber(), policiesSize, static_cast<int>(response->isBucketValid()),
+         static_cast<int>(response->isDbCorrupted()));
+
+    ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
+
+    ProtocolSerialization::serialize(frame, OpListResponse);
+    ProtocolSerialization::serialize(frame, policiesSize);
+    for (auto &policy : response->policies()) {
+        // PolicyKey
+        ProtocolSerialization::serialize(frame, policy.key().client().value());
+        ProtocolSerialization::serialize(frame, policy.key().user().value());
+        ProtocolSerialization::serialize(frame, policy.key().privilege().value());
+        // PolicyResult
+        ProtocolSerialization::serialize(frame, policy.result().policyType());
+        ProtocolSerialization::serialize(frame, policy.result().metadata());
+    }
+    ProtocolSerialization::serialize(frame, response->isBucketValid());
+    ProtocolSerialization::serialize(frame, response->isDbCorrupted());
+
+    ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
 }
 
 } // namespace Cynara