}
RequestPtr ProtocolAdmin::deserializeAdminCheckRequest(void) {
- std::string clientId, userId, privilegeId;
+ PolicyKey key;
PolicyBucketId startBucket;
bool recursive;
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
+ ProtocolDeserialization::deserialize(m_frameHeader, key);
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);
+ "startBucket <%s>, recursive [%d]", key.client().value().c_str(),
+ key.user().value().c_str(), key.privilege().value().c_str(),
+ startBucket.c_str(), recursive);
- return std::make_shared<AdminCheckRequest>(PolicyKey(clientId, userId, privilegeId),
- startBucket, recursive,
+ return std::make_shared<AdminCheckRequest>(key, startBucket, recursive,
m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolAdmin::deserializeEraseRequest(void) {
PolicyBucketId startBucket;
bool recursive;
- PolicyKeyFeature::ValueType client, user, privilege;
+ PolicyKey key;
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);
+ ProtocolDeserialization::deserialize(m_frameHeader, key);
- 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());
+ LOGD("Deserialized EraseRequest: clientId <%s>, userId <%s>, privilegeId <%s>, "
+ "startBucket <%s>, recursive [%d]", key.client().value().c_str(),
+ key.user().value().c_str(), key.privilege().value().c_str(),
+ startBucket.c_str(), recursive);
- return std::make_shared<EraseRequest>(startBucket, recursive,
- PolicyKey(client, user, privilege),
- m_frameHeader.sequenceNumber());
+ return std::make_shared<EraseRequest>(std::move(startBucket), recursive,
+ std::move(key), m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(void) {
PolicyBucketId policyBucketId;
- PolicyType policyType;
- PolicyResult::PolicyMetadata policyMetaData;
+ PolicyResult policyResult;
ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
- ProtocolDeserialization::deserialize(m_frameHeader, policyType);
- ProtocolDeserialization::deserialize(m_frameHeader, policyMetaData);
+ ProtocolDeserialization::deserialize(m_frameHeader, policyResult);
LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
"result.type [%" PRIu16 "], result.meta <%s>", policyBucketId.c_str(),
- policyType, policyMetaData.c_str());
+ policyResult.policyType(), policyResult.metadata().c_str());
- return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
- PolicyResult(policyType, policyMetaData), m_frameHeader.sequenceNumber());
+ return std::make_shared<InsertOrUpdateBucketRequest>(std::move(policyBucketId),
+ std::move(policyResult),
+ m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolAdmin::deserializeListRequest(void) {
PolicyBucketId bucketId;
- PolicyKeyFeature::ValueType client, user, privilege;
+ PolicyKey key;
ProtocolDeserialization::deserialize(m_frameHeader, bucketId);
- ProtocolDeserialization::deserialize(m_frameHeader, client);
- ProtocolDeserialization::deserialize(m_frameHeader, user);
- ProtocolDeserialization::deserialize(m_frameHeader, privilege);
+ ProtocolDeserialization::deserialize(m_frameHeader, key);
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());
+ "privilege <%s>", bucketId.c_str(), key.client().value().c_str(),
+ key.user().value().c_str(), key.privilege().value().c_str());
- return std::make_shared<ListRequest>(bucketId, PolicyKey(client, user, privilege),
+ return std::make_shared<ListRequest>(std::move(bucketId), std::move(key),
m_frameHeader.sequenceNumber());
}
LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
- return std::make_shared<RemoveBucketRequest>(policyBucketId, m_frameHeader.sequenceNumber());
+ return std::make_shared<RemoveBucketRequest>(std::move(policyBucketId),
+ m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(void) {
- ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
- ProtocolFrameFieldsCount policyCount;
- PolicyKeyFeature::ValueType clientId, user, privilege;
- PolicyType policyType;
- PolicyResult::PolicyMetadata metadata;
std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
- ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedCount);
- for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
- PolicyBucketId policyBucketId;
- ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
- ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
- for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
- // PolicyKey
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, user);
- ProtocolDeserialization::deserialize(m_frameHeader, privilege);
- // PolicyResult
- ProtocolDeserialization::deserialize(m_frameHeader, policyType);
- ProtocolDeserialization::deserialize(m_frameHeader, metadata);
-
- toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
- Policy(PolicyKey(clientId, user, privilege),
- PolicyResult(policyType, metadata)));
- }
- }
+ ProtocolDeserialization::deserialize(m_frameHeader, toBeInsertedOrUpdatedPolicies);
+ ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedPolicies);
- ProtocolDeserialization::deserialize(m_frameHeader, toBeRemovedCount);
- for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
- PolicyBucketId policyBucketId;
- ProtocolDeserialization::deserialize(m_frameHeader, policyBucketId);
- ProtocolDeserialization::deserialize(m_frameHeader, policyCount);
- for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
- // PolicyKey
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, user);
- ProtocolDeserialization::deserialize(m_frameHeader, privilege);
-
- toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
- }
- }
-
- LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%" PRIu16 "], "
- "remove count [%" PRIu16 "]", toBeInsertedOrUpdatedCount, toBeRemovedCount);
+ LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%zu], "
+ "remove count [%zu]", toBeInsertedOrUpdatedPolicies.size(),
+ toBeRemovedPolicies.size());
- return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
- toBeRemovedPolicies,
+ return std::make_shared<SetPoliciesRequest>(std::move(toBeInsertedOrUpdatedPolicies),
+ std::move(toBeRemovedPolicies),
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);
- }
+ std::vector<PolicyDescription> descriptions;
bool dbCorrupted;
+
+ ProtocolDeserialization::deserialize(m_frameHeader, descriptions);
ProtocolDeserialization::deserialize(m_frameHeader, dbCorrupted);
- LOGD("Deserialized DescriptionListResponse: number of descriptions [%" PRIu16 "], "
- "dbCorrupted [%d]", descriptionsCount, static_cast<int>(dbCorrupted));
+ LOGD("Deserialized DescriptionListResponse: number of descriptions [%zu], "
+ "dbCorrupted [%d]", descriptions.size(), 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, policies);
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),
+ LOGD("Deserialized ListResponse: number of policies [%zu], bucketValid [%d], "
+ "dbCorrupted [%d]", policies.size(), static_cast<int>(bucketValid),
static_cast<int>(dbCorrupted));
return std::make_shared<ListResponse>(policies, bucketValid, dbCorrupted,
ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request.sequenceNumber());
ProtocolSerialization::serialize(frame, OpAdminCheckRequest);
- ProtocolSerialization::serialize(frame, request.key().client().value());
- ProtocolSerialization::serialize(frame, request.key().user().value());
- ProtocolSerialization::serialize(frame, request.key().privilege().value());
+ ProtocolSerialization::serialize(frame, request.key());
ProtocolSerialization::serialize(frame, request.startBucket());
ProtocolSerialization::serialize(frame, request.recursive());
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());
+ ProtocolSerialization::serialize(frame, request.filter());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
ProtocolSerialization::serialize(frame, OpInsertOrUpdateBucket);
ProtocolSerialization::serialize(frame, request.bucketId());
- ProtocolSerialization::serialize(frame, request.result().policyType());
- ProtocolSerialization::serialize(frame, request.result().metadata());
+ ProtocolSerialization::serialize(frame, request.result());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
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());
+ ProtocolSerialization::serialize(frame, request.filter());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
ProtocolSerialization::serialize(frame, OpSetPolicies);
- ProtocolSerialization::serialize(frame,
- static_cast<ProtocolFrameFieldsCount>(request.policiesToBeInsertedOrUpdated().size()));
- for (auto policyBucket : request.policiesToBeInsertedOrUpdated()) {
- ProtocolSerialization::serialize(frame, policyBucket.first);
- ProtocolSerialization::serialize(frame,
- static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
- for (auto policy : policyBucket.second) {
- // 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,
- static_cast<ProtocolFrameFieldsCount>(request.policiesToBeRemoved().size()));
- for (auto policyBucket : request.policiesToBeRemoved()) {
- ProtocolSerialization::serialize(frame, policyBucket.first);
- ProtocolSerialization::serialize(frame,
- static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
- for (auto policyKey : policyBucket.second) {
- // PolicyKey
- ProtocolSerialization::serialize(frame, policyKey.client().value());
- ProtocolSerialization::serialize(frame, policyKey.user().value());
- ProtocolSerialization::serialize(frame, policyKey.privilege().value());
- }
- }
+ ProtocolSerialization::serialize(frame, request.policiesToBeInsertedOrUpdated());
+ ProtocolSerialization::serialize(frame, request.policiesToBeRemoved());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
response.sequenceNumber());
ProtocolSerialization::serialize(frame, OpAdminCheckPolicyResponse);
- ProtocolSerialization::serialize(frame, response.result().policyType());
- ProtocolSerialization::serialize(frame, response.result().metadata());
+ ProtocolSerialization::serialize(frame, response.result());
ProtocolSerialization::serialize(frame, response.isBucketValid());
ProtocolSerialization::serialize(frame, response.isDbCorrupted());
void ProtocolAdmin::execute(const RequestContext &context, const DescriptionListResponse &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()));
+ "number of descriptions [%zu], dbCorrupted [%d]", OpDescriptionListResponse,
+ response.sequenceNumber(), response.descriptions().size(),
+ 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.descriptions());
ProtocolSerialization::serialize(frame, response.isDbCorrupted());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
void ProtocolAdmin::execute(const RequestContext &context, const ListResponse &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()));
+ "number of policies [%zu], bucketValid [%d], dbCorrupted [%d]", OpListResponse,
+ response.sequenceNumber(), response.policies().size(),
+ 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.policies());
ProtocolSerialization::serialize(frame, response.isBucketValid());
ProtocolSerialization::serialize(frame, response.isDbCorrupted());
}
RequestPtr ProtocolClient::deserializeCheckRequest(void) {
- std::string clientId, userId, privilegeId;
-
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
+ PolicyKey key;
+ ProtocolDeserialization::deserialize(m_frameHeader, key);
LOGD("Deserialized CheckRequest: client <%s>, user <%s>, privilege <%s>",
- clientId.c_str(), userId.c_str(), privilegeId.c_str());
+ key.client().value().c_str(), key.user().value().c_str(),
+ key.privilege().value().c_str());
- return std::make_shared<CheckRequest>(PolicyKey(clientId, userId, privilegeId),
- m_frameHeader.sequenceNumber());
+ return std::make_shared<CheckRequest>(key, m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolClient::deserializeSimpleCheckRequest(void) {
- std::string clientId, userId, privilegeId;
-
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
+ PolicyKey key;
+ ProtocolDeserialization::deserialize(m_frameHeader, key);
LOGD("Deserialized SimpleCheckRequest: client <%s>, user <%s>, privilege <%s>",
- clientId.c_str(), userId.c_str(), privilegeId.c_str());
+ key.client().value().c_str(), key.user().value().c_str(),
+ key.privilege().value().c_str());
- return std::make_shared<SimpleCheckRequest>(PolicyKey(clientId, userId, privilegeId),
- m_frameHeader.sequenceNumber());
+ return std::make_shared<SimpleCheckRequest>(key, m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolClient::deserializeMonitorEntriesPutRequest(void) {
- ProtocolFrameFieldsCount entriesCount;
-
- ProtocolDeserialization::deserialize(m_frameHeader, entriesCount);
std::vector<MonitorEntry> entries;
- entries.reserve(entriesCount);
-
- for (ProtocolFrameFieldsCount fields = 0; fields < entriesCount; fields++) {
- std::string clientId, userId, privilegeId;
- int64_t result, tv_sec, tv_nsec;
-
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
- ProtocolDeserialization::deserialize(m_frameHeader, result);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_sec);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_nsec);
-
- PolicyKey key(clientId, userId, privilegeId);
- struct timespec timestamp;
- timestamp.tv_sec = static_cast<__time_t>(tv_sec);
- timestamp.tv_nsec = static_cast<__syscall_slong_t>(tv_nsec);
- entries.emplace_back(MonitorEntry(key, static_cast<size_t>(result), timestamp));
- }
+ ProtocolDeserialization::deserialize(m_frameHeader, entries);
- LOGD("Deserialized MonitorEntriesPutRequest: number of entries [%" PRIu16 "]", entriesCount);
+ LOGD("Deserialized MonitorEntriesPutRequest: number of entries [%zu]", entries.size());
return std::make_shared<MonitorEntriesPutRequest>(entries, m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolClient::deserializeMonitorEntryPutRequest(void) {
- std::string clientId, userId, privilegeId;
- int64_t result, tv_sec, tv_nsec;
-
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
- ProtocolDeserialization::deserialize(m_frameHeader, result);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_sec);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_nsec);
-
- PolicyKey key(clientId, userId, privilegeId);
- struct timespec timestamp;
- timestamp.tv_sec = static_cast<__time_t>(tv_sec);
- timestamp.tv_nsec = static_cast<__syscall_slong_t>(tv_nsec);
+ MonitorEntry entry;
+ ProtocolDeserialization::deserialize(m_frameHeader, entry);
LOGD("Deserialized MonitorEntryPutRequest: client <%s>, user <%s>, privilege <%s>",
- clientId.c_str(), userId.c_str(), privilegeId.c_str());
+ entry.key().client().value().c_str(), entry.key().user().value().c_str(),
+ entry.key().privilege().value().c_str());
- return std::make_shared<MonitorEntryPutRequest>(MonitorEntry(key, static_cast<size_t>(result),
- timestamp),
- m_frameHeader.sequenceNumber());
+ return std::make_shared<MonitorEntryPutRequest>(entry, m_frameHeader.sequenceNumber());
}
RequestPtr ProtocolClient::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
request.key().privilege().value().c_str());
ProtocolSerialization::serialize(frame, OpCheckPolicyRequest);
- ProtocolSerialization::serialize(frame, request.key().client().value());
- ProtocolSerialization::serialize(frame, request.key().user().value());
- ProtocolSerialization::serialize(frame, request.key().privilege().value());
+ ProtocolSerialization::serialize(frame, request.key());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
request.key().privilege().value().c_str());
ProtocolSerialization::serialize(frame, OpSimpleCheckPolicyRequest);
- ProtocolSerialization::serialize(frame, request.key().client().value());
- ProtocolSerialization::serialize(frame, request.key().user().value());
- ProtocolSerialization::serialize(frame, request.key().privilege().value());
+ ProtocolSerialization::serialize(frame, request.key());
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
void ProtocolClient::execute(const RequestContext &context,
const MonitorEntriesPutRequest &request) {
- ProtocolFrameFieldsCount entriesCount
- = static_cast<ProtocolFrameFieldsCount>(request.monitorEntries().size());
LOGD("Serializing MonitorEntriesPutRequest: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
- "number of entries [%" PRIu16 "]",
- OpMonitorEntriesPutRequest, request.sequenceNumber(), entriesCount);
+ "number of entries [%zu]",
+ OpMonitorEntriesPutRequest, request.sequenceNumber(), request.monitorEntries().size());
ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request.sequenceNumber());
ProtocolSerialization::serialize(frame, OpMonitorEntriesPutRequest);
- ProtocolSerialization::serialize(frame, entriesCount);
- for (const auto &entry : request.monitorEntries()) {
- ProtocolSerialization::serialize(frame, entry.key().client().toString());
- ProtocolSerialization::serialize(frame, entry.key().user().toString());
- ProtocolSerialization::serialize(frame, entry.key().privilege().toString());
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.result()));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_sec));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_nsec));
- }
-
+ ProtocolSerialization::serialize(frame, request.monitorEntries());
ProtocolFrameSerializer::finishSerialization(frame, *context.responseQueue());
}
const auto &entry = request.monitorEntry();
ProtocolSerialization::serialize(frame, OpMonitorEntryPutRequest);
- ProtocolSerialization::serialize(frame, entry.key().client().toString());
- ProtocolSerialization::serialize(frame, entry.key().user().toString());
- ProtocolSerialization::serialize(frame, entry.key().privilege().toString());
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.result()));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_sec));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_nsec));
+ ProtocolSerialization::serialize(frame, entry);
ProtocolFrameSerializer::finishSerialization(frame, *(context.responseQueue()));
}
#include <cinttypes>
#include <memory>
+#include <cynara-limits.h>
#include <exceptions/InvalidProtocolException.h>
#include <log/log.h>
#include <protocol/ProtocolFrameSerializer.h>
}
RequestPtr ProtocolMonitorGet::deserializeMonitorGetEntriesRequest(void) {
- uint64_t bufferSize;
+ ProtocolFrameFieldsCount bufferSize;
ProtocolDeserialization::deserialize(m_frameHeader, bufferSize);
}
ResponsePtr ProtocolMonitorGet::deserializeMonitorGetEntriesResponse(void) {
- ProtocolFrameFieldsCount entriesCount;
-
- ProtocolDeserialization::deserialize(m_frameHeader, entriesCount);
std::vector<MonitorEntry> entries;
- entries.reserve(entriesCount);
-
- for (ProtocolFrameFieldsCount fields = 0; fields < entriesCount; fields++) {
- std::string clientId, userId, privilegeId;
- int64_t result, tv_sec, tv_nsec;
-
- ProtocolDeserialization::deserialize(m_frameHeader, clientId);
- ProtocolDeserialization::deserialize(m_frameHeader, userId);
- ProtocolDeserialization::deserialize(m_frameHeader, privilegeId);
- ProtocolDeserialization::deserialize(m_frameHeader, result);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_sec);
- ProtocolDeserialization::deserialize(m_frameHeader, tv_nsec);
-
- PolicyKey key(clientId, userId, privilegeId);
- struct timespec timestamp;
- timestamp.tv_sec = static_cast<__time_t>(tv_sec);
- timestamp.tv_nsec = static_cast<__syscall_slong_t>(tv_nsec);
- entries.emplace_back(MonitorEntry(key, static_cast<size_t>(result), timestamp));
- }
- LOGD("Deserialized MonitorGetEntriesResponse: number of entries [%" PRIu16 "]", entriesCount);
+ ProtocolDeserialization::deserializeCustomLimit(m_frameHeader, entries,
+ CYNARA_MAX_MONITOR_BUFFER_SIZE);
+
+ LOGD("Deserialized MonitorGetEntriesResponse: number of entries [%zu]",
+ entries.size());
return std::make_shared<MonitorGetEntriesResponse>(entries, m_frameHeader.sequenceNumber());
}
void ProtocolMonitorGet::execute(const RequestContext &context,
const MonitorGetEntriesRequest &request)
{
- LOGD("Serializing MonitorGetEntriesRequest: op [%" PRIu8 "], bufferSize [%" PRIu16 "]",
+ LOGD("Serializing MonitorGetEntriesRequest: op [%" PRIu8 "], bufferSize [%zu]",
OpMonitorGetEntriesRequest, request.bufferSize());
ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(request.sequenceNumber());
ProtocolSerialization::serialize(frame, OpMonitorGetEntriesRequest);
- ProtocolSerialization::serialize(frame, static_cast<uint64_t>(request.bufferSize()));
+ ProtocolSerialization::serialize(frame,
+ static_cast<ProtocolFrameFieldsCount>(request.bufferSize()));
ProtocolFrameSerializer::finishSerialization(frame, *context.responseQueue());
}
void ProtocolMonitorGet::execute(const RequestContext &context,
const MonitorGetEntriesResponse &response)
{
- ProtocolFrameFieldsCount entriesCount
- = static_cast<ProtocolFrameFieldsCount>(response.entries().size());
LOGD("Serializing MonitorGetEntriesResponse: op [%" PRIu8 "], sequenceNumber [%" PRIu16 "], "
- "number of entries [%" PRIu16 "]",
- OpMonitorGetEntriesResponse, response.sequenceNumber(), entriesCount);
+ "number of entries [%zu]",
+ OpMonitorGetEntriesResponse, response.sequenceNumber(), response.entries().size());
ProtocolFrame frame = ProtocolFrameSerializer::startSerialization(response.sequenceNumber());
-
ProtocolSerialization::serialize(frame, OpMonitorGetEntriesResponse);
- ProtocolSerialization::serialize(frame, entriesCount);
- for (const auto &entry : response.entries()) {
- ProtocolSerialization::serialize(frame, entry.key().client().toString());
- ProtocolSerialization::serialize(frame, entry.key().user().toString());
- ProtocolSerialization::serialize(frame, entry.key().privilege().toString());
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.result()));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_sec));
- ProtocolSerialization::serialize(frame, static_cast<int64_t>(entry.timestamp().tv_nsec));
- }
+ ProtocolSerialization::serializeCustomLimit(frame, response.entries(),
+ CYNARA_MAX_MONITOR_BUFFER_SIZE);
ProtocolFrameSerializer::finishSerialization(frame, *context.responseQueue());
}
#include <cynara-limits.h>
#include <exceptions/InvalidProtocolException.h>
#include <protocol/ProtocolOpCode.h>
+#include <types/ProtocolFields.h>
+
+#include <types/Policy.h>
+#include <types/PolicyDescription.h>
+#include <types/PolicyKey.h>
+#include <types/MonitorEntry.h>
namespace Cynara {
// Abstract data stream buffer
virtual ~IStream() {};
};
-struct ProtocolSerialization {
- // char
- static void serialize(IStream &stream, const char value) {
- stream.write(sizeof(value), &value);
- }
+namespace ProtocolSerialization {
- // unsigned char
- static void serialize(IStream &stream, const unsigned char value) {
- stream.write(sizeof(value), &value);
- }
+// char
+inline void serialize(IStream &stream, const char value) {
+ stream.write(sizeof(value), &value);
+}
- // unsigned 16-bit int
- static void serialize(IStream &stream, const uint16_t value) {
- uint16_t _value = htole16(value);
- stream.write(sizeof(value), &_value);
- }
+// unsigned char
+inline void serialize(IStream &stream, const unsigned char value) {
+ stream.write(sizeof(value), &value);
+}
- // 16-bit int
- static void serialize(IStream &stream, const int16_t value) {
- int16_t _value = htole16(value);
- stream.write(sizeof(value), &_value);
- }
+// unsigned 16-bit int
+inline void serialize(IStream &stream, const uint16_t value) {
+ uint16_t _value = htole16(value);
+ stream.write(sizeof(value), &_value);
+}
- // unsigned 32-bit int
- static void serialize(IStream &stream, const uint32_t value) {
- uint32_t _value = htole32(value);
- stream.write(sizeof(value), &_value);
- }
+// 16-bit int
+inline void serialize(IStream &stream, const int16_t value) {
+ int16_t _value = htole16(value);
+ stream.write(sizeof(value), &_value);
+}
- // 32-bit int
- static void serialize(IStream &stream, const int32_t value) {
- int32_t _value = htole32(value);
- stream.write(sizeof(value), &_value);
- }
+// unsigned 32-bit int
+inline void serialize(IStream &stream, const uint32_t value) {
+ uint32_t _value = htole32(value);
+ stream.write(sizeof(value), &_value);
+}
- // unsigned 64-bit int
- static void serialize(IStream &stream, const uint64_t value) {
- uint64_t _value = htole64(value);
- stream.write(sizeof(value), &_value);
- }
+// 32-bit int
+inline void serialize(IStream &stream, const int32_t value) {
+ int32_t _value = htole32(value);
+ stream.write(sizeof(value), &_value);
+}
- // 64-bit int
- static void serialize(IStream &stream, const int64_t value) {
- int64_t _value = htole64(value);
- stream.write(sizeof(value), &_value);
- }
+// unsigned 64-bit int
+inline void serialize(IStream &stream, const uint64_t value) {
+ uint64_t _value = htole64(value);
+ stream.write(sizeof(value), &_value);
+}
- // bool
- static void serialize(IStream &stream, const bool value) {
- uint8_t bVal = static_cast<uint8_t>(value);
- stream.write(sizeof(bVal), &bVal);
- }
+// 64-bit int
+inline void serialize(IStream &stream, const int64_t value) {
+ int64_t _value = htole64(value);
+ stream.write(sizeof(value), &_value);
+}
- // ProtocolOpCode
- static void serialize(IStream &stream, const ProtocolOpCode value) {
- stream.write(sizeof(value), &value);
- }
+// bool
+inline void serialize(IStream &stream, const bool value) {
+ uint8_t bVal = static_cast<uint8_t>(value);
+ stream.write(sizeof(bVal), &bVal);
+}
- // std::string
- static void serialize(IStream &stream, const std::string &str) {
- if (str.size() > CYNARA_MAX_ID_LENGTH)
- throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
- uint32_t length = htole32(static_cast<uint32_t>(str.size()));
- stream.write(sizeof(length), &length);
- stream.write(str.size(), str.c_str());
- }
- static void serializeNoSize(IStream &stream, const std::string &str) {
- int length = str.size();
- stream.write(length, str.c_str());
- }
+// ProtocolOpCode
+inline void serialize(IStream &stream, const ProtocolOpCode value) {
+ stream.write(sizeof(value), &value);
+}
- // std::vector
- template<typename T>
- static void serialize(IStream &stream, const std::vector<T> &vec) {
- if (vec.size() > CYNARA_MAX_VECTOR_SIZE)
- throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
- uint32_t length = htole32(static_cast<uint32_t>(vec.size()));
- stream.write(sizeof(length), &length);
- for (typename std::vector<T>::const_iterator vec_iter = vec.begin();
- vec_iter != vec.end(); vec_iter++) {
- serialize(stream, *vec_iter);
- }
- }
-}; // struct ProtocolSerialization
+// std::string
+inline void serialize(IStream &stream, const std::string &str) {
+ if (str.size() > CYNARA_MAX_ID_LENGTH)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ serialize(stream, static_cast<uint16_t>(str.size()));
+ stream.write(str.size(), str.c_str());
+}
-struct ProtocolDeserialization {
- // char
- static void deserialize(IStream &stream, char &value) {
- stream.read(sizeof(value), &value);
- }
+inline void serializeNoSize(IStream &stream, const std::string &str) {
+ if (str.size() > CYNARA_MAX_ID_LENGTH)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ stream.write(str.size(), str.c_str());
+}
- // unsigned char
- static void deserialize(IStream &stream, unsigned char &value) {
- stream.read(sizeof(value), &value);
- }
+// struct timespec
+inline void serialize(IStream &stream, const struct timespec &t) {
+ serialize(stream, static_cast<int64_t>(t.tv_sec));
+ serialize(stream, static_cast<int64_t>(t.tv_nsec));
+}
- // 16-bit int
- static void deserialize(IStream &stream, int16_t &value) {
- stream.read(sizeof(value), &value);
- value = le16toh(value);
- }
+// Cynara::PolicyKey
+inline void serialize(IStream &stream, const PolicyKey &key) {
+ serialize(stream, key.client().value());
+ serialize(stream, key.user().value());
+ serialize(stream, key.privilege().value());
+}
- // unsigned 16-bit int
- static void deserialize(IStream &stream, uint16_t &value) {
- stream.read(sizeof(value), &value);
- value = le16toh(value);
- }
+// Cynara::PolicyResult
+inline void serialize(IStream &stream, const PolicyResult &result) {
+ serialize(stream, result.policyType());
+ serialize(stream, result.metadata());
+}
- // 32-bit int
- static void deserialize(IStream &stream, int32_t &value) {
- stream.read(sizeof(value), &value);
- value = le32toh(value);
- }
+// Cynara::Policy
+inline void serialize(IStream &stream, const Policy &policy) {
+ serialize(stream, policy.key());
+ serialize(stream, policy.result());
+}
- // unsigned 32-bit int
- static void deserialize(IStream &stream, uint32_t &value) {
- stream.read(sizeof(value), &value);
- value = le32toh(value);
- }
+// Cynara::PolicyDescription
+inline void serialize(IStream &stream, const PolicyDescription &desc) {
+ serialize(stream, desc.type);
+ serialize(stream, desc.name);
+}
- // 64-bit int
- static void deserialize(IStream &stream, int64_t &value) {
- stream.read(sizeof(value), &value);
- value = le64toh(value);
- }
+// Cynara::MonitorEntry
+inline void serialize(IStream &stream, const MonitorEntry &entry) {
+ serialize(stream, entry.key());
+ serialize(stream, static_cast<int64_t>(entry.result()));
+ serialize(stream, entry.timestamp());
+}
- // unsigned 64-bit int
- static void deserialize(IStream &stream, uint64_t &value) {
- stream.read(sizeof(value), &value);
- value = le64toh(value);
+// std::vector
+template<typename T>
+void serializeCustomLimit(IStream &stream, const std::vector<T> &vec,
+ ProtocolFrameFieldsCount limit) {
+ if (vec.size() > limit)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ serialize(stream, static_cast<ProtocolFrameFieldsCount>(vec.size()));
+ for (auto &el : vec) {
+ serialize(stream, el);
}
+}
- // bool
- static void deserialize(IStream &stream, bool &value) {
- uint8_t bVal;
- stream.read(sizeof(bVal), &bVal);
- value = static_cast<bool>(bVal);
- }
+template<typename T>
+void serialize(IStream &stream, const std::vector<T> &vec) {
+ serializeCustomLimit(stream, vec, CYNARA_MAX_VECTOR_SIZE);
+}
- // PrtocolOpCode
- static void deserialize(IStream &stream, ProtocolOpCode &value) {
- stream.read(sizeof(value), &value);
+// std::map
+template<typename K, typename V>
+void serialize(IStream &stream, const std::map<K,V> &map) {
+ if (map.size() > CYNARA_MAX_VECTOR_SIZE)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ serialize(stream, static_cast<ProtocolFrameFieldsCount>(map.size()));
+ for (auto &pair : map) {
+ serialize(stream, pair.first);
+ serialize(stream, pair.second);
}
+}
- // std::string
- static void deserialize(IStream &stream, std::string &str) {
- uint32_t length;
- stream.read(sizeof(length), &length);
- length = le32toh(length);
- if (length > CYNARA_MAX_ID_LENGTH)
- throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
- str.resize(length);
- stream.read(length, &str[0]);
- }
- static void deserialize(IStream &stream, int length, std::string &str) {
- if (length > CYNARA_MAX_ID_LENGTH)
- throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
- str.resize(length);
- stream.read(length, &str[0]);
+}; // namespace ProtocolSerialization
+
+namespace ProtocolDeserialization {
+// char
+inline void deserialize(IStream &stream, char &value) {
+ stream.read(sizeof(value), &value);
+}
+
+// unsigned char
+inline void deserialize(IStream &stream, unsigned char &value) {
+ stream.read(sizeof(value), &value);
+}
+
+// 16-bit int
+inline void deserialize(IStream &stream, int16_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le16toh(value);
+}
+
+// unsigned 16-bit int
+inline void deserialize(IStream &stream, uint16_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le16toh(value);
+}
+
+// 32-bit int
+inline void deserialize(IStream &stream, int32_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le32toh(value);
+}
+
+// unsigned 32-bit int
+inline void deserialize(IStream &stream, uint32_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le32toh(value);
+}
+
+// 64-bit int
+inline void deserialize(IStream &stream, int64_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le64toh(value);
+}
+
+// unsigned 64-bit int
+inline void deserialize(IStream &stream, uint64_t &value) {
+ stream.read(sizeof(value), &value);
+ value = le64toh(value);
+}
+
+// bool
+inline void deserialize(IStream &stream, bool &value) {
+ uint8_t bVal;
+ stream.read(sizeof(bVal), &bVal);
+ value = static_cast<bool>(bVal);
+}
+
+// PrtocolOpCode
+inline void deserialize(IStream &stream, ProtocolOpCode &value) {
+ stream.read(sizeof(value), &value);
+}
+
+// std::string
+inline void deserialize(IStream &stream, int length, std::string &str) {
+ if (length > CYNARA_MAX_ID_LENGTH)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ str.resize(length);
+ stream.read(length, &str[0]);
+}
+
+inline void deserialize(IStream &stream, std::string &str) {
+ uint16_t length;
+ deserialize(stream, length);
+ if (length > CYNARA_MAX_ID_LENGTH)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ deserialize(stream, length, str);
+}
+
+// struct timespec
+inline void deserialize(IStream &stream, struct timespec &t) {
+ int64_t sec, nsec;
+ deserialize(stream, sec);
+ deserialize(stream, nsec);
+ t.tv_sec = static_cast<decltype(t.tv_sec)>(sec);
+ t.tv_nsec = static_cast<decltype(t.tv_nsec)>(nsec);
+}
+
+// Cynara::PolicyKey
+inline void deserialize(IStream &stream, PolicyKey &key) {
+ std::string client, user, privilege;
+ deserialize(stream, client);
+ deserialize(stream, user);
+ deserialize(stream, privilege);
+
+ key = PolicyKey(std::move(client), std::move(user), std::move(privilege));
+}
+
+// Cynara::PolicyResult
+inline void deserialize(IStream &stream, PolicyResult &result) {
+ PolicyType type;
+ PolicyResult::PolicyMetadata metadata;
+
+ deserialize(stream, type);
+ deserialize(stream, metadata);
+
+ result = PolicyResult(type, std::move(metadata));
+}
+
+// Cynara::Policy
+inline void deserialize(IStream &stream, Policy &policy) {
+ PolicyKey key;
+ PolicyResult result;
+
+ deserialize(stream, key);
+ deserialize(stream, result);
+
+ policy = Policy(std::move(key), std::move(result));
+}
+
+// Cynara::PolicyDescription
+inline void deserialize(IStream &stream, PolicyDescription &desc) {
+ deserialize(stream, desc.type);
+ deserialize(stream, desc.name);
+}
+
+// Cynara::MonitorEntry
+inline void deserialize(IStream &stream, MonitorEntry &entry) {
+ PolicyKey key;
+ int64_t result;
+ struct timespec ts;
+
+ deserialize(stream, key);
+ deserialize(stream, result);
+ deserialize(stream, ts);
+
+ entry = MonitorEntry(std::move(key), result, ts);
+}
+
+// std::vector
+template<typename T>
+void deserializeCustomLimit(IStream &stream, std::vector<T> &vec, ProtocolFrameFieldsCount limit) {
+ ProtocolFrameFieldsCount count;
+ deserialize(stream, count);
+ if (count > limit)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ vec.reserve(count);
+
+ for (ProtocolFrameFieldsCount i = 0; i < count; ++i) {
+ T obj;
+ deserialize(stream, obj);
+ vec.push_back(std::move(obj));
}
+}
+
+template<typename T>
+void deserialize(IStream &stream, std::vector<T> &vec) {
+ deserializeCustomLimit(stream, vec, CYNARA_MAX_VECTOR_SIZE);
+}
- // std::vector
- template<typename T>
- static void deserialize(IStream &stream, std::vector<T> &vec) {
- uint32_t length;
- stream.read(sizeof(length), &length);
- length = le32toh(length);
- if (length > CYNARA_MAX_VECTOR_SIZE)
- throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
- for (uint32_t i = 0; i < length; ++i) {
- T obj;
- deserialize(stream, obj);
- vec.push_back(std::move(obj));
- }
+// std::map
+template<typename K, typename V>
+void deserialize(IStream &stream, std::map<K,V> &map) {
+ ProtocolFrameFieldsCount count;
+ deserialize(stream, count);
+ if (count > CYNARA_MAX_VECTOR_SIZE)
+ throw InvalidProtocolException(InvalidProtocolException::IdentifierTooLong);
+ for (ProtocolFrameFieldsCount i = 0; i < count; i++) {
+ K key;
+ V value;
+ deserialize(stream, key);
+ deserialize(stream, value);
+ map.emplace(key, value);
}
-}; // struct ProtocolDeserialization
+}
+
+} // namespace ProtocolDeserialization
} // namespace Cynara
#endif // SRC_COMMON_PROTOCOL_PROTOCOLSERIALIZATION_H_
class MonitorEntry {
public:
- MonitorEntry(const PolicyKey &key, const int &result, const struct timespec ×tamp)
- : m_key(key), m_result(result), m_timestamp(timestamp) {}
+ MonitorEntry() = default;
+ MonitorEntry(PolicyKey key, const int &result, const struct timespec ×tamp)
+ : m_key(std::move(key)), m_result(result), m_timestamp(timestamp) {}
-private:
- PolicyKey m_key;
- int m_result; // CYNARA_API_ACCESS_ALLOWED or CYNARA_API_ACCESS_DENIED
- struct timespec m_timestamp;
-
-public:
const PolicyKey &key(void) const {
return m_key;
}
const struct timespec ×tamp(void) const {
return m_timestamp;
}
+
+private:
+ PolicyKey m_key;
+ int m_result; // CYNARA_API_ACCESS_ALLOWED or CYNARA_API_ACCESS_DENIED
+ struct timespec m_timestamp;
};
} // namespace Cynara
class Policy
{
public:
- Policy(const PolicyKey &key, const PolicyResult &result) :
- m_key(key), m_result(result) {}
+ Policy() = default;
+ Policy(PolicyKey key, PolicyResult result) :
+ m_key(std::move(key)), m_result(std::move(result)) {}
- static PolicyPtr simpleWithKey(const PolicyKey &key, const PolicyType &type) {
- return std::make_shared<Policy>(key, PolicyResult(type));
+ static PolicyPtr simpleWithKey(PolicyKey key, PolicyType type) {
+ return std::make_shared<Policy>(std::move(key), PolicyResult(type));
}
- static PolicyPtr bucketWithKey(const PolicyKey &key, const PolicyBucketId &bucketId) {
- auto result = PolicyResult(PredefinedPolicyType::BUCKET, bucketId);
- return std::make_shared<Policy>(key, result);
+ static PolicyPtr bucketWithKey(PolicyKey key, PolicyBucketId bucketId) {
+ auto result = PolicyResult(PredefinedPolicyType::BUCKET, std::move(bucketId));
+ return std::make_shared<Policy>(std::move(key), std::move(result));
}
bool operator==(const Policy &other) const {
return std::tie(m_key, m_result) == std::tie(other.m_key, other.m_result);
}
-private:
- PolicyKey m_key;
- PolicyResult m_result;
-
-public:
const PolicyKey &key() const {
return m_key;
}
const PolicyResult &result() const {
return m_result;
}
+
+private:
+ PolicyKey m_key;
+ PolicyResult m_result;
};
} // namespace Cynara
namespace Cynara {
struct PolicyDescription {
+ PolicyDescription() : type(PredefinedPolicyType::NONE) {}
PolicyDescription(const PolicyType &pType, const std::string &pName) : type(pType), name(pName)
{};
PolicyDescription(const PolicyType &pType) : type(pType) {};
friend class PolicyKey;
public:
- PolicyKeyFeature(const PolicyKeyFeature &) = default;
- PolicyKeyFeature(PolicyKeyFeature &&) = default;
-
- PolicyKeyFeature& operator=(const PolicyKeyFeature &) = default;
- PolicyKeyFeature& operator=(PolicyKeyFeature &&) = default;
+ PolicyKeyFeature() = default;
typedef std::string ValueType;
const static std::string &anyValue(void);
};
-class PolicyKey
-{
-
+class PolicyKey {
public:
- PolicyKey(const PolicyKeyFeature &clientId, const PolicyKeyFeature &userId,
- const PolicyKeyFeature &privilegeId)
- : m_client(clientId), m_user(userId), m_privilege(privilegeId) {};
-
- PolicyKey(const PolicyKeyFeature::ValueType &clientId,
- const PolicyKeyFeature::ValueType &userId,
- const PolicyKeyFeature::ValueType &privilegeId)
- : m_client(clientId), m_user(userId), m_privilege(privilegeId) {};
-
- PolicyKey(const PolicyKey &) = default;
- PolicyKey(PolicyKey &&) = default;
-
- PolicyKey& operator=(const PolicyKey &) = default;
- PolicyKey& operator=(PolicyKey &&) = default;
+ PolicyKey() = default;
+
+ PolicyKey(PolicyKeyFeature clientId, PolicyKeyFeature userId,
+ PolicyKeyFeature privilegeId)
+ : m_client(std::move(clientId)),
+ m_user(std::move(userId)),
+ m_privilege(std::move(privilegeId))
+ {}
+
+ PolicyKey(PolicyKeyFeature::ValueType clientId,
+ PolicyKeyFeature::ValueType userId,
+ PolicyKeyFeature::ValueType privilegeId)
+ : m_client(std::move(clientId)),
+ m_user(std::move(userId)),
+ m_privilege(std::move(privilegeId))
+ {}
bool operator==(const PolicyKey &other) const {
return std::tie(m_client, m_user, m_privilege)
PolicyResult::PolicyResult(const PolicyType &policyType) : m_type(policyType) {}
-PolicyResult::PolicyResult(const PolicyType &policyType, const PolicyMetadata &metadata)
- : m_type(policyType) , m_metadata(metadata) {}
+PolicyResult::PolicyResult(const PolicyType &policyType, PolicyMetadata metadata)
+ : m_type(policyType) , m_metadata(std::move(metadata)) {}
const PolicyType &PolicyResult::policyType(void) const {
return m_type;
PolicyResult();
PolicyResult(const PolicyType &policyType);
- PolicyResult(const PolicyType &policyType, const PolicyMetadata &metadata);
+ PolicyResult(const PolicyType &policyType, PolicyMetadata metadata);
const PolicyType &policyType(void) const;
const PolicyMetadata &metadata(void) const;
MOCK_METHOD2(write, void(size_t, const void*));
};
-ACTION_P(AssignInt, param) { *static_cast<int*>(arg1) = param; }
+ACTION_P(AssignUInt16, param) {
+ auto hparam = htole16(param);
+ memcpy(arg1, &hparam, sizeof(hparam));
+}
ACTION_P(AssignString, param) { strcpy(static_cast<char*>(arg1), param); }
TEST(Serialization, maxString) {
FakeIStream stream;
std::string string;
- EXPECT_CALL(stream, read(_, _)).WillOnce(AssignInt(CYNARA_MAX_ID_LENGTH + 1));
+ EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, string),
Cynara::InvalidProtocolException);
}
std::string stringInput;
stringInput.resize(CYNARA_MAX_ID_LENGTH, ' ');
-
- EXPECT_CALL(stream, read(_, _)).WillOnce(AssignInt(CYNARA_MAX_ID_LENGTH))
+ EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
.WillOnce(AssignString(stringInput.c_str()));
EXPECT_NO_THROW(Cynara::ProtocolDeserialization::deserialize(stream, string));
}
FakeIStream stream;
std::vector<std::string> vector;
- EXPECT_CALL(stream, read(_, _)).WillOnce(AssignInt(CYNARA_MAX_ID_LENGTH + 1));
+ EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, vector),
Cynara::InvalidProtocolException);
}
vector.resize(CYNARA_MAX_VECTOR_SIZE);
EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
- .WillOnce(AssignInt(CYNARA_MAX_VECTOR_SIZE));
+ .WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE));
for (int i = 0; i < CYNARA_MAX_VECTOR_SIZE; i++) {
EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
- .WillOnce(AssignInt(CYNARA_MAX_ID_LENGTH))
+ .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
.WillOnce(AssignString(stringInput.c_str()));
}
FakeIStream stream;
std::vector<std::string> vector;
- EXPECT_CALL(stream, read(_, _)).WillOnce(AssignInt(1))
- .WillOnce(AssignInt(CYNARA_MAX_ID_LENGTH + 1));
+ EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(1))
+ .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, vector),
Cynara::InvalidProtocolException);
}
projects / platform / core / security / cynara.git / commitdiff