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/EraseRequest.h>
33 #include <request/InsertOrUpdateBucketRequest.h>
34 #include <request/ListRequest.h>
35 #include <request/RemoveBucketRequest.h>
36 #include <request/RequestContext.h>
37 #include <request/SetPoliciesRequest.h>
38 #include <response/AdminCheckResponse.h>
39 #include <response/CodeResponse.h>
40 #include <response/ListResponse.h>
41 #include <types/PolicyKey.h>
43 #include "ProtocolAdmin.h"
47 ProtocolAdmin::ProtocolAdmin() {
50 ProtocolAdmin::~ProtocolAdmin() {
53 ProtocolPtr ProtocolAdmin::clone(void) {
54 return std::make_shared<ProtocolAdmin>();
57 RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(void) {
58 std::string clientId, userId, privilegeId;
59 PolicyBucketId startBucket;
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);
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);
72 return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
73 startBucket, recursive,
74 m_frameHeader.sequenceNumber());
77 RequestPtr ProtocolAdmin::deserializeEraseRequest(void) {
78 PolicyBucketId startBucket;
80 PolicyKeyFeature::ValueType client, user, privilege;
82 ProtocolDeserialization::deserialize(m_frameHeader, startBucket);
83 ProtocolDeserialization::deserialize(m_frameHeader, recursive);
84 ProtocolDeserialization::deserialize(m_frameHeader, client);
85 ProtocolDeserialization::deserialize(m_frameHeader, user);
86 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
88 LOGD("Deserialized EraseRequest: startBucket <%s>, recursive [%d], filter client <%s> "
89 "filter user <%s>, filter privilege <%s>", startBucket.c_str(),
90 static_cast<int>(recursive), client.c_str(), user.c_str(), privilege.c_str());
92 return std::make_shared<EraseRequest>(startBucket, recursive,
93 PolicyKey(client, user, privilege),
94 m_frameHeader.sequenceNumber());
97 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(void) {
98 PolicyBucketId policyBucketId;
99 PolicyType policyType;
100 PolicyResult::PolicyMetadata policyMetaData;
102 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
103 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
104 ProtocolDeserialization::deserialize(m_frameHeader, policyMetaData);
106 LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
107 "result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
108 policyType, policyMetaData.c_str());
110 return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
111 PolicyResult(policyType, policyMetaData), m_frameHeader.sequenceNumber());
114 RequestPtr ProtocolAdmin::deserializeListRequest(void) {
115 PolicyBucketId bucketId;
116 PolicyKeyFeature::ValueType client, user, privilege;
118 ProtocolDeserialization::deserialize(m_frameHeader, bucketId);
119 ProtocolDeserialization::deserialize(m_frameHeader, client);
120 ProtocolDeserialization::deserialize(m_frameHeader, user);
121 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
123 LOGD("Deserialized ListRequest: bucketId <%s>, filter client <%s> filter user <%s>, filter "
124 "privilege <%s>", bucketId.c_str(), client.c_str(), user.c_str(), privilege.c_str());
126 return std::make_shared<ListRequest>(bucketId, PolicyKey(client, user, privilege),
127 m_frameHeader.sequenceNumber());
130 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(void) {
131 PolicyBucketId policyBucketId;
133 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
135 LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
137 return std::make_shared<RemoveBucketRequest>(policyBucketId, m_frameHeader.sequenceNumber());
140 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(void) {
141 ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
142 ProtocolFrameFieldsCount policyCount;
143 PolicyKeyFeature::ValueType clientId, user, privilege;
144 PolicyType policyType;
145 PolicyResult::PolicyMetadata metadata;
146 std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
147 std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
149 ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedCount);
150 for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
151 PolicyBucketId policyBucketId;
152 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
153 ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
154 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
156 ProtocolDeserialization::deserialize(m_frameHeader, clientId);
157 ProtocolDeserialization::deserialize(m_frameHeader, user);
158 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
160 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
161 ProtocolDeserialization::deserialize(m_frameHeader, metadata);
163 toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
164 Policy(PolicyKey(clientId, user, privilege),
165 PolicyResult(policyType, metadata)));
169 ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedCount);
170 for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
171 PolicyBucketId policyBucketId;
172 ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
173 ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
174 for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
176 ProtocolDeserialization::deserialize(m_frameHeader, clientId);
177 ProtocolDeserialization::deserialize(m_frameHeader, user);
178 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
180 toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
184 LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
185 "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
187 return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
189 m_frameHeader.sequenceNumber());
192 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
193 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
195 if (m_frameHeader.isFrameComplete()) {
196 ProtocolOpCode opCode;
198 m_frameHeader.resetState();
199 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
200 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
202 case OpAdminCheckRequest:
203 return deserializeAdminCheckRequest();
205 return deserializeEraseRequest();
206 case OpInsertOrUpdateBucket:
207 return deserializeInsertOrUpdateBucketRequest();
209 return deserializeListRequest();
211 return deserializeRemoveBucketRequest();
213 return deserializeSetPoliciesRequest();
215 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
223 ResponsePtr ProtocolAdmin::deserializeAdminCheckResponse(void) {
225 PolicyResult::PolicyMetadata additionalInfo;
228 ProtocolDeserialization::deserialize(m_frameHeader, result);
229 ProtocolDeserialization::deserialize(m_frameHeader, additionalInfo);
230 ProtocolDeserialization::deserialize(m_frameHeader, bucketValid);
232 const PolicyResult policyResult(result, additionalInfo);
234 LOGD("Deserialized AdminCheckResponse: result [%" PRIu16 "], metadata <%s>, bucketValid [%d]",
235 policyResult.policyType(), policyResult.metadata().c_str(), static_cast<int>(bucketValid));
237 return std::make_shared<AdminCheckResponse>(policyResult, bucketValid,
238 m_frameHeader.sequenceNumber());
241 ResponsePtr ProtocolAdmin::deserializeCodeResponse(void) {
242 ProtocolResponseCode responseCode;
243 ProtocolDeserialization::deserialize(m_frameHeader, responseCode);
245 LOGD("Deserialized CodeResponse: code [%" PRIu16 "], ", responseCode);
247 return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
248 m_frameHeader.sequenceNumber());
251 ResponsePtr ProtocolAdmin::deserializeListResponse(void) {
252 ProtocolFrameFieldsCount policiesCount;
253 PolicyKeyFeature::ValueType client, user, privilege;
254 PolicyType policyType;
255 PolicyResult::PolicyMetadata metadata;
256 std::vector<Policy> policies;
258 ProtocolDeserialization::deserialize(m_frameHeader, policiesCount);
259 policies.reserve(policiesCount);
261 for (ProtocolFrameFieldsCount p = 0; p < policiesCount; ++p) {
263 ProtocolDeserialization::deserialize(m_frameHeader, client);
264 ProtocolDeserialization::deserialize(m_frameHeader, user);
265 ProtocolDeserialization::deserialize(m_frameHeader, privilege);
267 ProtocolDeserialization::deserialize(m_frameHeader, policyType);
268 ProtocolDeserialization::deserialize(m_frameHeader, metadata);
270 policies.push_back(Policy(PolicyKey(client, user, privilege),
271 PolicyResult(policyType, metadata)));
275 ProtocolDeserialization::deserialize(m_frameHeader, isBucketValid);
277 LOGD("Deserialized ListResponse: number of policies [%" PRIu16 "], isBucketValid [%d]",
278 policiesCount, isBucketValid);
280 return std::make_shared<ListResponse>(policies, isBucketValid, m_frameHeader.sequenceNumber());
283 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
284 ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
286 if (m_frameHeader.isFrameComplete()) {
287 ProtocolOpCode opCode;
289 m_frameHeader.resetState();
290 ProtocolDeserialization::deserialize(m_frameHeader, opCode);
291 LOGD("Deserialized opCode [%" PRIu8 "]", opCode);
293 case OpAdminCheckPolicyResponse:
294 return deserializeAdminCheckResponse();
296 return deserializeCodeResponse();
298 return deserializeListResponse();
300 throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
308 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckRequestPtr request) {
309 LOGD("Serializing AdminCheckRequest: client <%s>, user <%s>, privilege <%s>, "
310 "startBucket <%s>, recursive [%d]", request->key().client().value().c_str(),
311 request->key().user().value().c_str(), request->key().privilege().value().c_str(),
312 request->startBucket().c_str(), request->recursive());
314 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
316 ProtocolSerialization::serialize(frame, OpAdminCheckRequest);
317 ProtocolSerialization::serialize(frame, request->key().client().value());
318 ProtocolSerialization::serialize(frame, request->key().user().value());
319 ProtocolSerialization::serialize(frame, request->key().privilege().value());
320 ProtocolSerialization::serialize(frame, request->startBucket());
321 ProtocolSerialization::serialize(frame, request->recursive());
323 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
326 void ProtocolAdmin::execute(RequestContextPtr context, EraseRequestPtr request) {
327 LOGD("Serializing EraseRequest: sequenceNumber [%" PRIu16 "], startBucket <%s>, "
328 "recursive [%d], filter client <%s> filter user <%s> filter privilege <%s>",
329 request->sequenceNumber(), request->startBucket().c_str(),
330 static_cast<int>(request->recursive()), request->filter().client().value().c_str(),
331 request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
333 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
335 ProtocolSerialization::serialize(frame, OpEraseRequest);
336 ProtocolSerialization::serialize(frame, request->startBucket());
337 ProtocolSerialization::serialize(frame, request->recursive());
338 ProtocolSerialization::serialize(frame, request->filter().client().value());
339 ProtocolSerialization::serialize(frame, request->filter().user().value());
340 ProtocolSerialization::serialize(frame, request->filter().privilege().value());
342 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
345 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
346 LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
347 "result.type [%" PRIu16 "], result.meta <%s>", request->sequenceNumber(),
348 request->bucketId().c_str(), request->result().policyType(),
349 request->result().metadata().c_str());
351 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
353 ProtocolSerialization::serialize(frame, OpInsertOrUpdateBucket);
354 ProtocolSerialization::serialize(frame, request->bucketId());
355 ProtocolSerialization::serialize(frame, request->result().policyType());
356 ProtocolSerialization::serialize(frame, request->result().metadata());
358 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
361 void ProtocolAdmin::execute(RequestContextPtr context, ListRequestPtr request) {
362 LOGD("Serializing ListRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>, "
363 "filter client <%s> filter user <%s> filter privilege <%s>", request->sequenceNumber(),
364 request->bucket().c_str(), request->filter().client().value().c_str(),
365 request->filter().user().value().c_str(), request->filter().privilege().value().c_str());
367 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
369 ProtocolSerialization::serialize(frame, OpListRequest);
370 ProtocolSerialization::serialize(frame, request->bucket());
371 ProtocolSerialization::serialize(frame, request->filter().client().value());
372 ProtocolSerialization::serialize(frame, request->filter().user().value());
373 ProtocolSerialization::serialize(frame, request->filter().privilege().value());
375 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
378 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
379 LOGD("Serializing RemoveBucketRequest: sequenceNumber [%" PRIu16 "], bucketId <%s>",
380 request->sequenceNumber(), request->bucketId().c_str());
382 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
384 ProtocolSerialization::serialize(frame, OpRemoveBucket);
385 ProtocolSerialization::serialize(frame, request->bucketId());
387 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
390 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
391 LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%" PRIu16 "], "
392 "insertOrUpdate count [%zu], remove count [%zu]", request->sequenceNumber(),
393 request->policiesToBeInsertedOrUpdated().size(), request->policiesToBeRemoved().size());
395 ProtocolFrame frame =
396 ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
398 ProtocolSerialization::serialize(frame, OpSetPolicies);
400 ProtocolSerialization::serialize(frame,
401 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
402 for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
403 ProtocolSerialization::serialize(frame, policyBucket.first);
404 ProtocolSerialization::serialize(frame,
405 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
406 for (auto policy : policyBucket.second) {
408 ProtocolSerialization::serialize(frame, policy.key().client().value());
409 ProtocolSerialization::serialize(frame, policy.key().user().value());
410 ProtocolSerialization::serialize(frame, policy.key().privilege().value());
412 ProtocolSerialization::serialize(frame, policy.result().policyType());
413 ProtocolSerialization::serialize(frame, policy.result().metadata());
417 ProtocolSerialization::serialize(frame,
418 static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
419 for (auto policyBucket : request->policiesToBeRemoved()) {
420 ProtocolSerialization::serialize(frame, policyBucket.first);
421 ProtocolSerialization::serialize(frame,
422 static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
423 for (auto policyKey : policyBucket.second) {
425 ProtocolSerialization::serialize(frame, policyKey.client().value());
426 ProtocolSerialization::serialize(frame, policyKey.user().value());
427 ProtocolSerialization::serialize(frame, policyKey.privilege().value());
431 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
434 void ProtocolAdmin::execute(RequestContextPtr context, AdminCheckResponsePtr response) {
435 LOGD("Serializing AdminCheckResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
436 "policyType [%" PRIu16 "], metadata <%s>, bucketValid [%d]", OpAdminCheckPolicyResponse,
437 response->sequenceNumber(), response->result().policyType(),
438 response->result().metadata().c_str(), static_cast<int>(response->isBucketValid()));
440 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
441 response->sequenceNumber());
443 ProtocolSerialization::serialize(frame, OpAdminCheckPolicyResponse);
444 ProtocolSerialization::serialize(frame, response->result().policyType());
445 ProtocolSerialization::serialize(frame, response->result().metadata());
446 ProtocolSerialization::serialize(frame, response->isBucketValid());
448 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
451 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
452 LOGD("Serializing CodeResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
453 "code [%" PRIu16 "]", OpCodeResponse, response->sequenceNumber(), response->m_code);
455 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(
456 response->sequenceNumber());
458 ProtocolSerialization::serialize(frame, OpCodeResponse);
459 ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
461 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
464 void ProtocolAdmin::execute(RequestContextPtr context, ListResponsePtr response) {
465 ProtocolFrameFieldsCount policiesSize
466 = static_cast<ProtocolFrameFieldsCount>(response->policies().size());
468 LOGD("Serializing ListResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
469 "number of policies [%" PRIu16 "], isBucketValid [%d]", OpListResponse,
470 response->sequenceNumber(), policiesSize, response->isBucketValid());
472 ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response->sequenceNumber());
474 ProtocolSerialization::serialize(frame, OpListResponse);
475 ProtocolSerialization::serialize(frame, policiesSize);
476 for (auto &policy : response->policies()) {
478 ProtocolSerialization::serialize(frame, policy.key().client().value());
479 ProtocolSerialization::serialize(frame, policy.key().user().value());
480 ProtocolSerialization::serialize(frame, policy.key().privilege().value());
482 ProtocolSerialization::serialize(frame, policy.result().policyType());
483 ProtocolSerialization::serialize(frame, policy.result().metadata());
485 ProtocolSerialization::serialize(frame, response->isBucketValid());
487 ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
490 } // namespace Cynara