2 * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * @file ProtocolAdmin.cpp
18 * @author Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
19 * @author Adam Malinowski <a.malinowsk2@partner.samsung.com>
21 * @brief This file implements protocol class for administration
27 #include <exceptions/InvalidProtocolException.h>
29 #include <protocol/ProtocolFrame.h>
30 #include <protocol/ProtocolFrameSerializer.h>
31 #include <request/AdminCheckRequest.h>
32 #include <request/InsertOrUpdateBucketRequest.h>
33 #include <request/RemoveBucketRequest.h>
34 #include <request/RequestContext.h>
35 #include <request/SetPoliciesRequest.h>
36 #include <response/CheckResponse.h>
37 #include <response/CodeResponse.h>
39 #include "ProtocolAdmin.h"
43 ProtocolAdmin::ProtocolAdmin() {
46 ProtocolAdmin::~ProtocolAdmin() {
49 ProtocolPtr ProtocolAdmin::clone(void) {
50 return std::make_shared<ProtocolAdmin>();
53 RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(ProtocolFrameHeader &frame) {
54 std::string clientId, userId, privilegeId;
55 PolicyBucketId startBucket;
58 ProtocolDeserialization::deserialize(frame, clientId);
59 ProtocolDeserialization::deserialize(frame, userId);
60 ProtocolDeserialization::deserialize(frame, privilegeId);
61 ProtocolDeserialization::deserialize(frame, startBucket);
62 ProtocolDeserialization::deserialize(frame, recursive);
64 LOGD("Deserialized AdminCheckRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
65 "startBucket <%s>, recursive [%d]", clientId.c_str(), userId.c_str(),
66 privilegeId.c_str(), startBucket.c_str(), recursive);
68 return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
69 startBucket, recursive, frame.sequenceNumber());
72 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(ProtocolFrameHeader &frame) {
73 PolicyBucketId policyBucketId;
74 PolicyType policyType;
75 PolicyResult::PolicyMetadata policyMetaData;
77 ProtocolDeserialization::deserialize(frame, policyBucketId);
78 ProtocolDeserialization::deserialize(frame, policyType);
79 ProtocolDeserialization::deserialize(frame, policyMetaData);
81 LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
82 "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
83 policyType, policyMetaData.c_str());
85 return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
86 PolicyResult(policyType, policyMetaData), frame.sequenceNumber());
89 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(ProtocolFrameHeader &frame) {
90 PolicyBucketId policyBucketId;
92 ProtocolDeserialization::deserialize(frame, policyBucketId);
94 LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
96 return std::make_shared<RemoveBucketRequest>(policyBucketId, frame.sequenceNumber());
99 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &frame) {
100 ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
101 ProtocolFrameFieldsCount policyCount;
102 PolicyKeyFeature::ValueType clientId, user, privilege;
103 PolicyType policyType;
104 PolicyResult::PolicyMetadata metadata;
105 std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
106 std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
108 ProtocolDeserialization::deserialize(frame, toBeInsertedOrUpdatedCount);
109 for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
110 PolicyBucketId policyBucketId;
111 ProtocolDeserialization::deserialize(frame, policyBucketId);
112 ProtocolDeserialization::deserialize(frame, policyCount);
113 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
115 ProtocolDeserialization::deserialize(frame, clientId);
116 ProtocolDeserialization::deserialize(frame, user);
117 ProtocolDeserialization::deserialize(frame, privilege);
119 ProtocolDeserialization::deserialize(frame, policyType);
120 ProtocolDeserialization::deserialize(frame, metadata);
122 toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
123 Policy(PolicyKey(clientId, user, privilege),
124 PolicyResult(policyType, metadata)));
128 ProtocolDeserialization::deserialize(frame, toBeRemovedCount);
129 for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
130 PolicyBucketId policyBucketId;
131 ProtocolDeserialization::deserialize(frame, policyBucketId);
132 ProtocolDeserialization::deserialize(frame, policyCount);
133 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
135 ProtocolDeserialization::deserialize(frame, clientId);
136 ProtocolDeserialization::deserialize(frame, user);
137 ProtocolDeserialization::deserialize(frame, privilege);
139 toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
143 LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
144 "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
146 return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
147 toBeRemovedPolicies, frame.sequenceNumber());
150 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
151 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
153 if (m_frameHeader.isFrameComplete()) {
154 ProtocolOpCode opCode;
156 m_frameHeader.resetState();
157 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
158 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
160 case OpAdminCheckRequest:
161 return deserializeAdminCheckRequest(m_frameHeader);
162 case OpInsertOrUpdateBucket:
163 return deserializeInsertOrUpdateBucketRequest(m_frameHeader);
165 return deserializeRemoveBucketRequest(m_frameHeader);
167 return deserializeSetPoliciesRequest(m_frameHeader);
169 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
177 ResponsePtr ProtocolAdmin::deserializeCheckResponse(ProtocolFrameHeader &frame) {
179 PolicyResult::PolicyMetadata additionalInfo;
181 ProtocolDeserialization::deserialize(frame, result);
182 ProtocolDeserialization::deserialize(frame, additionalInfo);
184 const PolicyResult policyResult(result, additionalInfo);
186 LOGD("Deserialized CheckResponse: result [%" PRIu16 "], metadata <%s>",
187 policyResult.policyType(), policyResult.metadata().c_str());
189 return std::make_shared<CheckResponse>(policyResult, frame.sequenceNumber());
192 ResponsePtr ProtocolAdmin::deserializeCodeResponse(ProtocolFrameHeader &frame) {
193 ProtocolResponseCode responseCode;
194 ProtocolDeserialization::deserialize(frame, responseCode);
196 LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
198 return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
199 frame.sequenceNumber());
202 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
203 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
205 if (m_frameHeader.isFrameComplete()) {
206 ProtocolOpCode opCode;
208 m_frameHeader.resetState();
209 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
210 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
212 case OpCheckPolicyResponse:
213 return deserializeCheckResponse(m_frameHeader);
215 return deserializeCodeResponse(m_frameHeader);
217 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
225 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr request) {
226 LOGD("Serializing AdminCheckRequest: client <%s>, user <%s>, privilege <%s>, "
227 "startBucket <%s>, recursive [%d]", request->key().client().value().c_str(),
228 request->key().user().value().c_str(), request->key().privilege().value().c_str(),
229 request->startBucket().c_str(), request->recursive());
231 ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
233 ProtocolSerialization::serialize(*frame, OpAdminCheckRequest);
234 ProtocolSerialization::serialize(*frame, request->key().client().value());
235 ProtocolSerialization::serialize(*frame, request->key().user().value());
236 ProtocolSerialization::serialize(*frame, request->key().privilege().value());
237 ProtocolSerialization::serialize(*frame, request->startBucket());
238 ProtocolSerialization::serialize(*frame, request->recursive());
240 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
243 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
244 LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
245 "result.type [%" PRIu16 "], result.meta <%s>", request->sequenceNumber(),
246 request->bucketId().c_str(), request->result().policyType(),
247 request->result().metadata().c_str());
249 ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
251 ProtocolSerialization::serialize(*frame, OpInsertOrUpdateBucket);
252 ProtocolSerialization::serialize(*frame, request->bucketId());
253 ProtocolSerialization::serialize(*frame, request->result().policyType());
254 ProtocolSerialization::serialize(*frame, request->result().metadata());
256 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
259 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
260 LOGD("Serializing RemoveBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>",
261 request->sequenceNumber(), request->bucketId().c_str());
263 ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
265 ProtocolSerialization::serialize(*frame, OpRemoveBucket);
266 ProtocolSerialization::serialize(*frame, request->bucketId());
268 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
271 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
272 LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%" PRIu16 "], "
273 "insertOrUpdate count [%zu], remove count [%zu]", request->sequenceNumber(),
274 request->policiesToBeInsertedOrUpdated().size(), request->policiesToBeRemoved().size());
276 ProtocolFramePtr frame =
277 ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
279 ProtocolSerialization::serialize(*frame, OpSetPolicies);
281 ProtocolSerialization::serialize(*frame,
282 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
283 for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
284 ProtocolSerialization::serialize(*frame, policyBucket.first);
285 ProtocolSerialization::serialize(*frame,
286 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
287 for (auto policy : policyBucket.second) {
289 ProtocolSerialization::serialize(*frame, policy.key().client().value());
290 ProtocolSerialization::serialize(*frame, policy.key().user().value());
291 ProtocolSerialization::serialize(*frame, policy.key().privilege().value());
293 ProtocolSerialization::serialize(*frame, policy.result().policyType());
294 ProtocolSerialization::serialize(*frame, policy.result().metadata());
298 ProtocolSerialization::serialize(*frame,
299 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
300 for (auto policyBucket : request->policiesToBeRemoved()) {
301 ProtocolSerialization::serialize(*frame, policyBucket.first);
302 ProtocolSerialization::serialize(*frame,
303 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
304 for (auto policyKey : policyBucket.second) {
306 ProtocolSerialization::serialize(*frame, policyKey.client().value());
307 ProtocolSerialization::serialize(*frame, policyKey.user().value());
308 ProtocolSerialization::serialize(*frame, policyKey.privilege().value());
312 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
315 void ProtocolAdmin::execute(RequestContextPtr context, CheckResponsePtr response) {
316 LOGD("Serializing CheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
317 "policyType [%" PRIu16 "], metadata <%s>", OpCheckPolicyResponse,
318 response->sequenceNumber(), response->m_resultRef.policyType(),
319 response->m_resultRef.metadata().c_str());
321 ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(
322 response->sequenceNumber());
324 ProtocolSerialization::serialize(*frame, OpCheckPolicyResponse);
325 ProtocolSerialization::serialize(*frame, response->m_resultRef.policyType());
326 ProtocolSerialization::serialize(*frame, response->m_resultRef.metadata());
328 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
331 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
332 LOGD("Serializing CodeResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
333 "code [%" PRIu16 "]", OpCodeResponse, response->sequenceNumber(), response->m_code);
335 ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(
336 response->sequenceNumber());
338 ProtocolSerialization::serialize(*frame, OpCodeResponse);
339 ProtocolSerialization::serialize(*frame, static_cast<ProtocolResponseCode>(response->m_code));
341 ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
344 } // namespace Cynara