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 src/common/protocol/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/ListRequest.h>
34 #include <request/RemoveBucketRequest.h>
35 #include <request/RequestContext.h>
36 #include <request/SetPoliciesRequest.h>
37 #include <response/CheckResponse.h>
38 #include <response/CodeResponse.h>
39 #include <response/ListResponse.h>
40 #include <types/PolicyKey.h>
42 #include "ProtocolAdmin.h"
46 ProtocolAdmin::ProtocolAdmin() {
49 ProtocolAdmin::~ProtocolAdmin() {
52 ProtocolPtr ProtocolAdmin::clone(void) {
53 return std::make_shared<ProtocolAdmin>();
56 RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(void) {
57 std::string clientId, userId, privilegeId;
58 PolicyBucketId startBucket;
61 ProtocolDeserialization::deserialize(m_frameHeader, clientId);
62 ProtocolDeserialization::deserialize(m_frameHeader, userId);
63 ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
64 ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
65 ProtocolDeserialization::deserialize(m_frameHeader, recursive);
67 LOGD("Deserialized AdminCheckRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
68 "startBucket <%s>, recursive [%d]", clientId.c_str(), userId.c_str(),
69 privilegeId.c_str(), startBucket.c_str(), recursive);
71 return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
72 startBucket, recursive,
73 m_frameHeader.sequenceNumber());
76 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(void) {
77 PolicyBucketId policyBucketId;
78 PolicyType policyType;
79 PolicyResult::PolicyMetadata policyMetaData;
81 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
82 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
83 ProtocolDeserialization::deserialize(m_frameHeader, policyMetaData);
85 LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
86 "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
87 policyType, policyMetaData.c_str());
89 return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
90 PolicyResult(policyType, policyMetaData), m_frameHeader.sequenceNumber());
93 RequestPtr ProtocolAdmin::deserializeListRequest(void) {
94 PolicyBucketId bucketId;
95 PolicyKeyFeature::ValueType client, user, privilege;
97 ProtocolDeserialization::deserialize(m_frameHeader, bucketId);
98 ProtocolDeserialization::deserialize(m_frameHeader, client);
99 ProtocolDeserialization::deserialize(m_frameHeader, user);
100 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
102 LOGD("Deserialized ListRequest: bucketId <%s>, filter client <%s> filter user <%s>, filter "
103 "privilege <%s>", bucketId.c_str(), client.c_str(), user.c_str(), privilege.c_str());
105 return std::make_shared<ListRequest>(bucketId, PolicyKey(client, user, privilege),
106 m_frameHeader.sequenceNumber());
109 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(void) {
110 PolicyBucketId policyBucketId;
112 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
114 LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
116 return std::make_shared<RemoveBucketRequest>(policyBucketId, m_frameHeader.sequenceNumber());
119 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(void) {
120 ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
121 ProtocolFrameFieldsCount policyCount;
122 PolicyKeyFeature::ValueType clientId, user, privilege;
123 PolicyType policyType;
124 PolicyResult::PolicyMetadata metadata;
125 std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
126 std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
128 ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedCount);
129 for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
130 PolicyBucketId policyBucketId;
131 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
132 ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
133 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
135 ProtocolDeserialization::deserialize(m_frameHeader, clientId);
136 ProtocolDeserialization::deserialize(m_frameHeader, user);
137 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
139 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
140 ProtocolDeserialization::deserialize(m_frameHeader, metadata);
142 toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
143 Policy(PolicyKey(clientId, user, privilege),
144 PolicyResult(policyType, metadata)));
148 ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedCount);
149 for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
150 PolicyBucketId policyBucketId;
151 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
152 ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
153 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
155 ProtocolDeserialization::deserialize(m_frameHeader, clientId);
156 ProtocolDeserialization::deserialize(m_frameHeader, user);
157 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
159 toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
163 LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
164 "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
166 return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
168 m_frameHeader.sequenceNumber());
171 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
172 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
174 if (m_frameHeader.isFrameComplete()) {
175 ProtocolOpCode opCode;
177 m_frameHeader.resetState();
178 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
179 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
181 case OpAdminCheckRequest:
182 return deserializeAdminCheckRequest();
183 case OpInsertOrUpdateBucket:
184 return deserializeInsertOrUpdateBucketRequest();
186 return deserializeListRequest();
188 return deserializeRemoveBucketRequest();
190 return deserializeSetPoliciesRequest();
192 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
200 ResponsePtr ProtocolAdmin::deserializeCheckResponse(void) {
202 PolicyResult::PolicyMetadata additionalInfo;
204 ProtocolDeserialization::deserialize(m_frameHeader, result);
205 ProtocolDeserialization::deserialize(m_frameHeader, additionalInfo);
207 const PolicyResult policyResult(result, additionalInfo);
209 LOGD("Deserialized CheckResponse: result [%" PRIu16 "], metadata <%s>",
210 policyResult.policyType(), policyResult.metadata().c_str());
212 return std::make_shared<CheckResponse>(policyResult, m_frameHeader.sequenceNumber());
215 ResponsePtr ProtocolAdmin::deserializeCodeResponse(void) {
216 ProtocolResponseCode responseCode;
217 ProtocolDeserialization::deserialize(m_frameHeader, responseCode);
219 LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
221 return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
222 m_frameHeader.sequenceNumber());
225 ResponsePtr ProtocolAdmin::deserializeListResponse(void) {
226 ProtocolFrameFieldsCount policiesCount;
227 PolicyKeyFeature::ValueType client, user, privilege;
228 PolicyType policyType;
229 PolicyResult::PolicyMetadata metadata;
230 std::vector<Policy> policies;
232 ProtocolDeserialization::deserialize(m_frameHeader, policiesCount);
233 policies.reserve(policiesCount);
235 for (ProtocolFrameFieldsCount p = 0; p < policiesCount; ++p) {
237 ProtocolDeserialization::deserialize(m_frameHeader, client);
238 ProtocolDeserialization::deserialize(m_frameHeader, user);
239 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
241 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
242 ProtocolDeserialization::deserialize(m_frameHeader, metadata);
244 policies.push_back(Policy(PolicyKey(client, user, privilege),
245 PolicyResult(policyType, metadata)));
249 ProtocolDeserialization::deserialize(m_frameHeader, isBucketValid);
251 LOGD("Deserialized ListResponse: number of policies [%" PRIu16 "], isBucketValid [%d]",
252 policiesCount, isBucketValid);
254 return std::make_shared<ListResponse>(policies, isBucketValid, m_frameHeader.sequenceNumber());
257 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
258 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
260 if (m_frameHeader.isFrameComplete()) {
261 ProtocolOpCode opCode;
263 m_frameHeader.resetState();
264 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
265 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
267 case OpCheckPolicyResponse:
268 return deserializeCheckResponse();
270 return deserializeCodeResponse();
272 return deserializeListResponse();
274 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
282 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr request) {
283 LOGD("Serializing AdminCheckRequest: client <%s>, user <%s>, privilege <%s>, "
284 "startBucket <%s>, recursive [%d]", request->key().client().value().c_str(),
285 request->key().user().value().c_str(), request->key().privilege().value().c_str(),
286 request->startBucket().c_str(), request->recursive());
288 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
290 ProtocolSerialization::serialize(frame, OpAdminCheckRequest);
291 ProtocolSerialization::serialize(frame, request->key().client().value());
292 ProtocolSerialization::serialize(frame, request->key().user().value());
293 ProtocolSerialization::serialize(frame, request->key().privilege().value());
294 ProtocolSerialization::serialize(frame, request->startBucket());
295 ProtocolSerialization::serialize(frame, request->recursive());
297 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
300 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
301 LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
302 "result.type [%" PRIu16 "], result.meta <%s>", request->sequenceNumber(),
303 request->bucketId().c_str(), request->result().policyType(),
304 request->result().metadata().c_str());
306 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
308 ProtocolSerialization::serialize(frame, OpInsertOrUpdateBucket);
309 ProtocolSerialization::serialize(frame, request->bucketId());
310 ProtocolSerialization::serialize(frame, request->result().policyType());
311 ProtocolSerialization::serialize(frame, request->result().metadata());
313 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
316 void ProtocolAdmin::execute(RequestContextPtr context, ListRequestPtr request) {
317 LOGD("Serializing ListRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
318 "filter client <%s> filter user <%s> filter privilege <%s>", request->sequenceNumber(),
319 request->bucket().c_str(), request->filter().client().value().c_str(),
320 request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
322 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
324 ProtocolSerialization::serialize(frame, OpListRequest);
325 ProtocolSerialization::serialize(frame, request->bucket());
326 ProtocolSerialization::serialize(frame, request->filter().client().value());
327 ProtocolSerialization::serialize(frame, request->filter().user().value());
328 ProtocolSerialization::serialize(frame, request->filter().privilege().value());
330 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
333 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
334 LOGD("Serializing RemoveBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>",
335 request->sequenceNumber(), request->bucketId().c_str());
337 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
339 ProtocolSerialization::serialize(frame, OpRemoveBucket);
340 ProtocolSerialization::serialize(frame, request->bucketId());
342 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
345 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
346 LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%" PRIu16 "], "
347 "insertOrUpdate count [%zu], remove count [%zu]", request->sequenceNumber(),
348 request->policiesToBeInsertedOrUpdated().size(), request->policiesToBeRemoved().size());
350 ProtocolFrame frame =
351 ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
353 ProtocolSerialization::serialize(frame, OpSetPolicies);
355 ProtocolSerialization::serialize(frame,
356 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
357 for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
358 ProtocolSerialization::serialize(frame, policyBucket.first);
359 ProtocolSerialization::serialize(frame,
360 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
361 for (auto policy : policyBucket.second) {
363 ProtocolSerialization::serialize(frame, policy.key().client().value());
364 ProtocolSerialization::serialize(frame, policy.key().user().value());
365 ProtocolSerialization::serialize(frame, policy.key().privilege().value());
367 ProtocolSerialization::serialize(frame, policy.result().policyType());
368 ProtocolSerialization::serialize(frame, policy.result().metadata());
372 ProtocolSerialization::serialize(frame,
373 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
374 for (auto policyBucket : request->policiesToBeRemoved()) {
375 ProtocolSerialization::serialize(frame, policyBucket.first);
376 ProtocolSerialization::serialize(frame,
377 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
378 for (auto policyKey : policyBucket.second) {
380 ProtocolSerialization::serialize(frame, policyKey.client().value());
381 ProtocolSerialization::serialize(frame, policyKey.user().value());
382 ProtocolSerialization::serialize(frame, policyKey.privilege().value());
386 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
389 void ProtocolAdmin::execute(RequestContextPtr context, CheckResponsePtr response) {
390 LOGD("Serializing CheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
391 "policyType [%" PRIu16 "], metadata <%s>", OpCheckPolicyResponse,
392 response->sequenceNumber(), response->m_resultRef.policyType(),
393 response->m_resultRef.metadata().c_str());
395 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
396 response->sequenceNumber());
398 ProtocolSerialization::serialize(frame, OpCheckPolicyResponse);
399 ProtocolSerialization::serialize(frame, response->m_resultRef.policyType());
400 ProtocolSerialization::serialize(frame, response->m_resultRef.metadata());
402 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
405 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
406 LOGD("Serializing CodeResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
407 "code [%" PRIu16 "]", OpCodeResponse, response->sequenceNumber(), response->m_code);
409 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
410 response->sequenceNumber());
412 ProtocolSerialization::serialize(frame, OpCodeResponse);
413 ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
415 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
418 void ProtocolAdmin::execute(RequestContextPtr context, ListResponsePtr response) {
419 ProtocolFrameFieldsCount policiesSize
420 = static_cast<ProtocolFrameFieldsCount>(response->policies().size());
422 LOGD("Serializing ListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
423 "number of policies [%" PRIu16 "], isBucketValid [%d]", OpListResponse,
424 response->sequenceNumber(), policiesSize, response->isBucketValid());
426 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
428 ProtocolSerialization::serialize(frame, OpListResponse);
429 ProtocolSerialization::serialize(frame, policiesSize);
430 for (auto &policy : response->policies()) {
432 ProtocolSerialization::serialize(frame, policy.key().client().value());
433 ProtocolSerialization::serialize(frame, policy.key().user().value());
434 ProtocolSerialization::serialize(frame, policy.key().privilege().value());
436 ProtocolSerialization::serialize(frame, policy.result().policyType());
437 ProtocolSerialization::serialize(frame, policy.result().metadata());
439 ProtocolSerialization::serialize(frame, response->isBucketValid());
441 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
444 } // namespace Cynara