openharmony/distributeddatamgr_udmf
1
0
Fork 0
mirror of https://gitee.com/openharmony/distributeddatamgr_udmf synced 2024-10-07 05:43:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

modify buid config

Browse Source 
Signed-off-by: ding_dong_dong <dingdongdong4@huawei.com>
This commit is contained in:
ding_dong_dong 2023-06-28 09:16:25 +08:00
parent a3b5608261
commit 27b45f486a
48 changed files with 6 additions and 3016 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
BUILD.gn
View File

@ -19,7 +19,6 @@ group("udmf_packages") {
"interfaces/innerkits:udmf_client",
"interfaces/jskits:udmf_data_napi",
"interfaces/jskits:udmf_napi",
"service:udmf_server",
]
}
}
@ -36,8 +35,5 @@ group("unittest") {
group("fuzztest") {
testonly = true
deps = [
"framework/innerkitsimpl/test/fuzztest:fuzztest",
"service/test/fuzztest:fuzztest",
]
deps = [ "framework/innerkitsimpl/test/fuzztest:fuzztest" ]
}

38
framework/common/anonymous.cpp
View File

@ -1,38 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "anonymous.h"
namespace OHOS {
namespace UDMF {
constexpr int32_t HEAD_SIZE = 3;
constexpr int32_t END_SIZE = 3;
constexpr int32_t MIN_SIZE = HEAD_SIZE + END_SIZE + 3;
constexpr const char *REPLACE_CHAIN = "***";
constexpr const char *DEFAULT_ANONYMOUS = "******";
std::string Anonymous::Change(const std::string &name)
{
if (name.length() <= HEAD_SIZE) {
return DEFAULT_ANONYMOUS;
}
if (name.length() < MIN_SIZE) {
return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN);
}
return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN + name.substr(name.length() - END_SIZE, END_SIZE));
}
} // namespace UDMF
} // namespace OHOS

29
framework/common/anonymous.h
View File

@ -1,29 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OHOS_UDMF_FRAMEWORKS_COMMON_ANONYMOUS_H
#define OHOS_UDMF_FRAMEWORKS_COMMON_ANONYMOUS_H
#include <string>
namespace OHOS {
namespace UDMF {
class Anonymous {
public:
static std::string Change(const std::string &name);
};
} // namespace UDMF
} // namespace OHOS
#endif // OHOS_UDMF_FRAMEWORKS_COMMON_ANONYMOUS_H

286
framework/common/concurrent_map.h
View File

@ -1,286 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OHOS_UDMF_FRAMEWORKS_COMMON_CONCURRENT_MAP_H
#define OHOS_UDMF_FRAMEWORKS_COMMON_CONCURRENT_MAP_H
#include <functional>
#include <map>
#include <mutex>
namespace OHOS {
template<typename _Key, typename _Tp>
class ConcurrentMap {
template<typename _First, typename... _Rest>
static _First First();
public:
using map_type = typename std::map<_Key, _Tp>;
using filter_type = typename std::function<bool(map_type &)>;
using key_type = typename std::map<_Key, _Tp>::key_type;
using mapped_type = typename std::map<_Key, _Tp>::mapped_type;
using value_type = typename std::map<_Key, _Tp>::value_type;
using size_type = typename std::map<_Key, _Tp>::size_type;
using reference = typename std::map<_Key, _Tp>::reference;
using const_reference = typename std::map<_Key, _Tp>::const_reference;
ConcurrentMap() = default;
~ConcurrentMap()
{
Clear();
}
ConcurrentMap(const ConcurrentMap &other)
{
operator=(std::move(other));
}
ConcurrentMap &operator=(const ConcurrentMap &other) noexcept
{
if (this == &other) {
return *this;
}
auto tmp = other.Clone();
std::lock_guard<decltype(mutex_)> lock(mutex_);
entries_ = std::move(tmp);
return *this;
}
ConcurrentMap(ConcurrentMap &&other) noexcept
{
operator=(std::move(other));
}
ConcurrentMap &operator=(ConcurrentMap &&other) noexcept
{
if (this == &other) {
return *this;
}
auto tmp = other.Steal();
std::lock_guard<decltype(mutex_)> lock(mutex_);
entries_ = std::move(tmp);
return *this;
}
bool Emplace() noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.emplace();
return it.second;
}
template<typename... _Args>
typename std::enable_if<!std::is_convertible_v<decltype(First<_Args...>()), filter_type>, bool>::type
Emplace(_Args &&...__args) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.emplace(std::forward<_Args>(__args)...);
return it.second;
}
template<typename _Filter, typename... _Args>
typename std::enable_if<std::is_convertible_v<_Filter, filter_type>, bool>::type
Emplace(const _Filter &filter, _Args &&...__args) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
if (!filter(entries_)) {
return false;
}
auto it = entries_.emplace(std::forward<_Args>(__args)...);
return it.second;
}
std::pair<bool, mapped_type> Find(const key_type &key) const noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.find(key);
if (it == entries_.end()) {
return std::pair { false, mapped_type() };
}
return std::pair { true, it->second };
}
bool Contains(const key_type &key) const noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return (entries_.find(key) != entries_.end());
}
template <typename _Obj>
bool InsertOrAssign(const key_type &key, _Obj &&obj) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.insert_or_assign(key, std::forward<_Obj>(obj));
return it.second;
}
bool Insert(const key_type &key, const mapped_type &value) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.insert(value_type { key, value });
return it.second;
}
size_type Erase(const key_type &key) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_.erase(key);
}
void Clear() noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_.clear();
}
bool Empty() const noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_.empty();
}
size_type Size() const noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_.size();
}
// The action`s return true means meeting the erase condition
// The action`s return false means not meeting the erase condition
size_type EraseIf(const std::function<bool(const key_type &key, mapped_type &value)> &action) noexcept
{
if (action == nullptr) {
return 0;
}
std::lock_guard<decltype(mutex_)> lock(mutex_);
#if __cplusplus > 201703L
auto count = std::erase_if(entries_,
[&action](value_type &value) -> bool { return action(value.first, value.second); });
#else
auto count = entries_.size();
for (auto it = entries_.begin(); it != entries_.end();) {
if (action((*it).first, (*it).second)) {
it = entries_.erase(it);
} else {
++it;
}
}
count -= entries_.size();
#endif
return count;
}
mapped_type &operator[](const key_type &key) noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_[key];
}
void ForEach(const std::function<bool(const key_type &, mapped_type &)> &action)
{
if (action == nullptr) {
return;
}
std::lock_guard<decltype(mutex_)> lock(mutex_);
for (auto &[key, value] : entries_) {
if (action(key, value)) {
break;
}
}
}
void ForEachCopies(const std::function<bool(const key_type &, mapped_type &)> &action)
{
if (action == nullptr) {
return;
}
auto entries = Clone();
for (auto &[key, value] : entries) {
if (action(key, value)) {
break;
}
}
}
// The action's return value means that the element is keep in map or not; true means keeping, false means removing.
bool Compute(const key_type &key, const std::function<bool(const key_type &, mapped_type &)> &action)
{
if (action == nullptr) {
return false;
}
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.find(key);
if (it == entries_.end()) {
auto result = entries_.emplace(key, mapped_type());
it = result.second ? result.first : entries_.end();
}
if (it == entries_.end()) {
return false;
}
if (!action(it->first, it->second)) {
entries_.erase(key);
}
return true;
}
// The action's return value means that the element is keep in map or not; true means keeping, false means removing.
bool ComputeIfPresent(const key_type &key, const std::function<bool(const key_type &, mapped_type &)> &action)
{
if (action == nullptr) {
return false;
}
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.find(key);
if (it == entries_.end()) {
return false;
}
if (!action(key, it->second)) {
entries_.erase(key);
}
return true;
}
bool ComputeIfAbsent(const key_type &key, const std::function<mapped_type(const key_type &)> &action)
{
if (action == nullptr) {
return false;
}
std::lock_guard<decltype(mutex_)> lock(mutex_);
auto it = entries_.find(key);
if (it != entries_.end()) {
return false;
}
entries_.emplace(key, action(key));
return true;
}
private:
std::map<_Key, _Tp> Steal() noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return std::move(entries_);
}
std::map<_Key, _Tp> Clone() const noexcept
{
std::lock_guard<decltype(mutex_)> lock(mutex_);
return entries_;
}
private:
mutable std::recursive_mutex mutex_;
std::map<_Key, _Tp> entries_;
};
} // namespace OHOS
#endif // OHOS_UDMF_FRAMEWORKS_COMMON_CONCURRENT_MAP_H

43
framework/common/same_process_ipc_guard.h
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_SAMEPROCESSIPCGUARD_H
#define UDMF_SAMEPROCESSIPCGUARD_H
#include <string>
#include "ipc_skeleton.h"
namespace OHOS {
namespace UDMF {
class SameProcessIpcGuard {
public:
SameProcessIpcGuard()
{
identity = IPCSkeleton::ResetCallingIdentity();
}
~SameProcessIpcGuard()
{
IPCSkeleton::SetCallingIdentity(identity);
}
private:
std::string identity;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_SAMEPROCESSIPCGUARD_H

1
framework/common/tlv_object.h
View File

@ -16,7 +16,6 @@
#ifndef UDMF_TLV_OBJECT_H
#define UDMF_TLV_OBJECT_H
#include "logger.h"
#include "securec.h"
#include "error_code.h"
#include "unified_meta.h"

1
framework/common/tlv_util.h
View File

@ -25,7 +25,6 @@
#include "html.h"
#include "image.h"
#include "link.h"
#include "logger.h"
#include "plain_text.h"
#include "system_defined_appitem.h"
#include "system_defined_form.h"

9
framework/innerkitsimpl/test/fuzztest/udmfclient_fuzzer/BUILD.gn
View File

@ -25,10 +25,6 @@ ohos_fuzztest("UdmfClientFuzzTest") {
"${udmf_interfaces_path}/innerkits/common",
"${udmf_interfaces_path}/innerkits/data",
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/container",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/service",
]
@ -44,10 +40,7 @@ ohos_fuzztest("UdmfClientFuzzTest") {
sources = [ "udmf_client_fuzzer.cpp" ]
deps = [
"../../../../../interfaces/innerkits:udmf_client",
"../../../../../service:udmf_server",
]
deps = [ "${udmf_interfaces_path}/innerkits:udmf_client" ]
external_deps = [
"access_token:libaccesstoken_sdk",

6
framework/innerkitsimpl/test/unittest/BUILD.gn
View File

@ -22,11 +22,6 @@ config("module_private_config") {
"${udmf_interfaces_path}/innerkits/common",
"${udmf_interfaces_path}/innerkits/data",
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/container",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/manager/permission",
"${udmf_framework_path}/service",
]
}
@ -35,7 +30,6 @@ common_deps = [
"${aafwk_path}/interfaces/inner_api/uri_permission:uri_permission_mgr",
"${third_party_path}/googletest:gtest_main",
"../../../../interfaces/innerkits:udmf_client",
"../../../../service:udmf_server",
]
common_external_deps = [

347
framework/manager/data_manager.cpp
View File

@ -1,347 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "data_manager.h"
#include "checker_manager.h"
#include "file.h"
#include "lifecycle/lifecycle_manager.h"
#include "logger.h"
#include "preprocess_utils.h"
#include "uri_permission_manager.h"
namespace OHOS {
namespace UDMF {
const std::string MSDP_PROCESS_NAME = "msdp_sa";
const std::string DATA_PREFIX = "udmf://";
DataManager::DataManager()
{
authorizationMap_[UD_INTENTION_MAP.at(UD_INTENTION_DRAG)] = MSDP_PROCESS_NAME;
CheckerManager::GetInstance().LoadCheckers();
}
DataManager::~DataManager()
{
}
DataManager &DataManager::GetInstance()
{
static DataManager instance;
return instance;
}
int32_t DataManager::SaveData(CustomOption &option, UnifiedData &unifiedData, std::string &key)
{
if (unifiedData.IsEmpty()) {
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameters, have no record");
return E_INVALID_PARAMETERS;
}
if (!UnifiedDataUtils::IsValidIntention(option.intention)) {
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameters intention: %{public}d.", option.intention);
return E_INVALID_PARAMETERS;
}
// imput runtime info before put it into store and save one privilege
PreProcessUtils utils = PreProcessUtils::GetInstance();
if (!utils.RuntimeDataImputation(unifiedData, option)) {
LOG_ERROR(UDMF_FRAMEWORK, "Imputation failed, %{public}s", utils.errorStr.c_str());
return E_UNKNOWN;
}
for (const auto &record : unifiedData.GetRecords()) {
record->SetUid(PreProcessUtils::GetInstance().IdGenerator());
}
std::string intention = unifiedData.GetRuntime()->key.intention;
auto store = storeCache_.GetStore(intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
if (!UnifiedDataUtils::IsPersist(intention) && store->Clear() != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Clear store failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
if (store->Put(unifiedData) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Put unified data failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
key = unifiedData.GetRuntime()->key.GetUnifiedKey();
LOG_DEBUG(UDMF_FRAMEWORK, "Put unified data successful, key: %{public}s.", key.c_str());
return E_OK;
}
int32_t DataManager::RetrieveData(const QueryOption &query, UnifiedData &unifiedData)
{
UnifiedKey key(query.key);
if (!key.IsValid()) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s is invalid.", query.key.c_str());
return E_INVALID_PARAMETERS;
}
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
int32_t res = store->Get(query.key, unifiedData);
if (res != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get data from store failed, intention: %{public}s.", key.intention.c_str());
return res;
}
if (unifiedData.IsEmpty()) {
return E_OK;
}
std::shared_ptr<Runtime> runtime = unifiedData.GetRuntime();
CheckerManager::CheckInfo info;
info.tokenId = query.tokenId;
if (!CheckerManager::GetInstance().IsValid(runtime->privileges, info)) {
return E_NO_PERMISSION;
}
std::string bundleName;
if (!PreProcessUtils::GetInstance().GetHapBundleNameByToken(query.tokenId, bundleName)) {
return E_ERROR;
}
if (runtime->createPackage != bundleName) {
auto records = unifiedData.GetRecords();
for (auto record : records) {
auto type = record->GetType();
std::string uri = "";
if (type == UDType::FILE || type == UDType::IMAGE || type == UDType::VIDEO || type == UDType::AUDIO
|| type == UDType::FOLDER) {
auto file = static_cast<File *>(record.get());
uri = file->GetUri();
}
if (!uri.empty() && (UriPermissionManager::GetInstance().GrantUriPermission(uri, bundleName) != E_OK)) {
return E_NO_PERMISSION;
}
}
}
if (LifeCycleManager::GetInstance().DeleteOnGet(key) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Remove data failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::RetrieveBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
{
std::vector<UnifiedData> dataSet;
std::shared_ptr<Store> store;
auto status = QueryDataCommon(query, dataSet, store);
if (status != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "QueryDataCommon failed.");
return status;
}
if (dataSet.empty()) {
LOG_WARN(UDMF_FRAMEWORK, "has no data, key: %{public}s, intention: %{public}d.", query.key.c_str(),
query.intention);
return E_OK;
}
for (const auto &data : dataSet) {
unifiedDataSet.push_back(data);
}
return E_OK;
}
int32_t DataManager::UpdateData(const QueryOption &query, UnifiedData &unifiedData)
{
UnifiedKey key(query.key);
if (!key.IsValid()) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s is invalid.", query.key.c_str());
return E_INVALID_PARAMETERS;
}
if (unifiedData.IsEmpty()) {
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameters, unified data has no record.");
return E_INVALID_PARAMETERS;
}
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
UnifiedData data;
int32_t res = store->Get(query.key, data);
if (res != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get data from store failed, intention: %{public}s.", key.intention.c_str());
return res;
}
if (data.IsEmpty()) {
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameter, unified data has no record; intention: %{public}s.",
key.intention.c_str());
return E_INVALID_PARAMETERS;
}
std::shared_ptr<Runtime> runtime = data.GetRuntime();
runtime->lastModifiedTime = PreProcessUtils::GetInstance().GetTimeStamp();
unifiedData.SetRuntime(*runtime);
for (const auto &record : unifiedData.GetRecords()) {
record->SetUid(PreProcessUtils::GetInstance().IdGenerator());
}
if (store->Update(unifiedData) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Update unified data failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
{
std::vector<UnifiedData> dataSet;
std::shared_ptr<Store> store;
auto status = QueryDataCommon(query, dataSet, store);
if (status != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "QueryDataCommon failed.");
return status;
}
if (dataSet.empty()) {
LOG_WARN(UDMF_FRAMEWORK, "has no data, key: %{public}s, intention: %{public}d.", query.key.c_str(),
query.intention);
return E_OK;
}
std::shared_ptr<Runtime> runtime;
std::vector<std::string> deleteKeys;
for (const auto &data : dataSet) {
runtime = data.GetRuntime();
unifiedDataSet.push_back(data);
deleteKeys.push_back(runtime->key.key);
}
if (store->DeleteBatch(deleteKeys) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Remove data failed.");
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::GetSummary(const QueryOption &query, Summary &summary)
{
UnifiedKey key(query.key);
if (!key.IsValid()) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s is invalid.", query.key.c_str());
return E_INVALID_PARAMETERS;
}
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
if (store->GetSummary(query.key, summary) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Store get summary failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::AddPrivilege(const QueryOption &query, const Privilege &privilege)
{
UnifiedKey key(query.key);
if (!key.IsValid()) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s is invalid.", query.key.c_str());
return E_INVALID_PARAMETERS;
}
std::string processName;
PreProcessUtils utils = PreProcessUtils::GetInstance();
if (!utils.GetNativeProcessNameByToken(query.tokenId, processName)) {
LOG_ERROR(UDMF_FRAMEWORK, "%{public}s", utils.errorStr.c_str());
return E_UNKNOWN;
}
if (processName != authorizationMap_[key.intention]) {
LOG_ERROR(UDMF_FRAMEWORK, "Process: %{public}s have no permission", processName.c_str());
return E_NO_PERMISSION;
}
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
UnifiedData data;
int32_t res = store->Get(query.key, data);
if (res != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get data from store failed, intention: %{public}s.", key.intention.c_str());
return res;
}
if (data.IsEmpty()) {
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameters, unified data has no record, intention: %{public}s.",
key.intention.c_str());
return E_INVALID_PARAMETERS;
}
data.GetRuntime()->privileges.emplace_back(privilege);
if (store->Update(data) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Update unified data failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::Sync(const QueryOption &query, const std::vector<std::string> &devices)
{
UnifiedKey key(query.key);
if (!key.IsValid()) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s is invalid.", query.key.c_str());
return E_INVALID_PARAMETERS;
}
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
if (store->Sync(devices) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Store sync failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
int32_t DataManager::QueryDataCommon(
const QueryOption &query, std::vector<UnifiedData> &dataSet, std::shared_ptr<Store> &store)
{
auto find = UD_INTENTION_MAP.find(query.intention);
std::string intention = find == UD_INTENTION_MAP.end() ? intention : find->second;
if (!UnifiedDataUtils::IsValidOptions(query.key, intention)) {
LOG_ERROR(UDMF_FRAMEWORK, "Unified key: %{public}s and intention: %{public}s is invalid.", query.key.c_str(),
intention.c_str());
return E_INVALID_PARAMETERS;
}
std::string dataPrefix = DATA_PREFIX + intention;
UnifiedKey key(query.key);
key.IsValid();
if (intention.empty()) {
dataPrefix = key.key;
intention = key.intention;
}
LOG_DEBUG(UDMF_FRAMEWORK, "dataPrefix = %{public}s, intention: %{public}s.", dataPrefix.c_str(), intention.c_str());
store = storeCache_.GetStore(intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
if (store->GetBatchData(dataPrefix, dataSet) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get dataSet failed, dataPrefix: %{public}s.", dataPrefix.c_str());
return E_DB_ERROR;
}
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

54
framework/manager/data_manager.h
View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_DATA_MANAGER_H
#define UDMF_DATA_MANAGER_H
#include <map>
#include <memory>
#include <mutex>
#include <vector>
#include "error_code.h"
#include "store_cache.h"
#include "unified_data.h"
#include "unified_types.h"
namespace OHOS {
namespace UDMF {
class DataManager {
public:
virtual ~DataManager();
static DataManager &GetInstance();
int32_t SaveData(CustomOption &option, UnifiedData &unifiedData, std::string &key);
int32_t RetrieveData(const QueryOption &query, UnifiedData &unifiedData);
int32_t RetrieveBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet);
int32_t UpdateData(const QueryOption &query, UnifiedData &unifiedData);
int32_t DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet);
int32_t GetSummary(const QueryOption &query, Summary &summary);
int32_t AddPrivilege(const QueryOption &query, const Privilege &privilege);
int32_t Sync(const QueryOption &query, const std::vector<std::string> &devices);
private:
DataManager();
int32_t QueryDataCommon(const QueryOption &query, std::vector<UnifiedData> &dataSet, std::shared_ptr<Store> &store);
StoreCache storeCache_;
std::map<std::string, std::string> authorizationMap_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_DATA_MANAGER_H

21
framework/manager/lifecycle/clean_after_get.cpp
View File

@ -1,21 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "clean_after_get.h"
namespace OHOS {
namespace UDMF {
} // namespace UDMF
} // namespace OHOS

26
framework/manager/lifecycle/clean_after_get.h
View File

@ -1,26 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_CLEAN_AFTER_GET_H
#define UDMF_CLEAN_AFTER_GET_H
#include "lifecycle_policy.h"
namespace OHOS {
namespace UDMF {
class CleanAfterGet : public LifeCyclePolicy {
public:
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_CLEAN_AFTER_GET_H

30
framework/manager/lifecycle/clean_on_startup.cpp
View File

@ -1,30 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "clean_on_startup.h"
namespace OHOS {
namespace UDMF {
Status CleanOnStartup::DeleteOnTimeout(const std::string &intention)
{
return E_OK;
}
Status CleanOnStartup::DeleteOnGet(const UnifiedKey &key)
{
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

28
framework/manager/lifecycle/clean_on_startup.h
View File

@ -1,28 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_CLEAN_ON_STARTUP_H
#define UDMF_CLEAN_ON_STARTUP_H
#include "lifecycle_policy.h"
namespace OHOS {
namespace UDMF {
class CleanOnStartup : public LifeCyclePolicy {
public:
Status DeleteOnTimeout(const std::string &intention) override;
Status DeleteOnGet(const UnifiedKey &key) override;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_CLEAN_ON_STARTUP_H

30
framework/manager/lifecycle/clean_on_timeout.cpp
View File

@ -1,30 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "clean_on_timeout.h"
namespace OHOS {
namespace UDMF {
Status CleanOnTimeout::DeleteOnStart(const std::string &intention)
{
return LifeCyclePolicy::DeleteOnTimeout(intention);
}
Status CleanOnTimeout::DeleteOnGet(const UnifiedKey &key)
{
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

28
framework/manager/lifecycle/clean_on_timeout.h
View File

@ -1,28 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_CLEAN_ON_TIMEOUT_H
#define UDMF_CLEAN_ON_TIMEOUT_H
#include "lifecycle_policy.h"
namespace OHOS {
namespace UDMF {
class CleanOnTimeout : public LifeCyclePolicy {
public:
Status DeleteOnStart(const std::string &intention) override;
Status DeleteOnGet(const UnifiedKey &key) override;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_CLEAN_ON_TIMEOUT_H

89
framework/manager/lifecycle/lifecycle_manager.cpp
View File

@ -1,89 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lifecycle_manager.h"
#include <algorithm>
#include <cinttypes>
namespace OHOS {
namespace UDMF {
std::shared_ptr<ExecutorPool> LifeCycleManager::executorPool_ = std::make_shared<ExecutorPool>(2, 1);
std::unordered_map<std::string, std::shared_ptr<LifeCyclePolicy>> LifeCycleManager::intentionPolicyMap_ = {
{ UD_INTENTION_MAP.at(UD_INTENTION_DRAG), std::make_shared<CleanAfterGet>() },
};
LifeCycleManager &LifeCycleManager::GetInstance()
{
static LifeCycleManager instance;
return instance;
}
Status LifeCycleManager::DeleteOnGet(const UnifiedKey &key)
{
auto findPolicy = intentionPolicyMap_.find(key.intention);
if (findPolicy == intentionPolicyMap_.end()) {
LOG_ERROR(UDMF_SERVICE, "Invalid intention, intention: %{public}s.", key.intention.c_str());
return E_INVALID_PARAMETERS;
}
auto policy = findPolicy->second;
return policy->DeleteOnGet(key);
}
Status LifeCycleManager::DeleteOnStart()
{
Status status = E_OK;
std::shared_ptr<LifeCyclePolicy> LifeCyclePolicy;
for (const auto &intentionPolicyPair : intentionPolicyMap_) {
LifeCyclePolicy = GetPolicy(intentionPolicyPair.first);
status = status == E_OK ? LifeCyclePolicy->DeleteOnStart(intentionPolicyPair.first) : status;
}
return status;
}
Status LifeCycleManager::DeleteOnSchedule()
{
ExecutorPool::TaskId taskId =
executorPool_->Schedule(&LifeCycleManager::DeleteOnTimeout, LifeCyclePolicy::INTERVAL);
if (taskId == ExecutorPool::INVALID_TASK_ID) {
LOG_ERROR(UDMF_SERVICE, "ExecutorPool Schedule failed.");
return E_ERROR;
}
LOG_INFO(UDMF_SERVICE, "ScheduleTask start, TaskId: %{public}" PRIu64 ".", taskId);
return E_OK;
}
std::shared_ptr<LifeCyclePolicy> LifeCycleManager::GetPolicy(const std::string &intention)
{
auto findPolicy = intentionPolicyMap_.find(intention);
if (findPolicy == intentionPolicyMap_.end()) {
return nullptr;
}
return findPolicy->second;
}
Status LifeCycleManager::DeleteOnTimeout()
{
Status status = E_OK;
std::shared_ptr<LifeCyclePolicy> LifeCyclePolicy;
for (const auto &intentionPolicyPair : intentionPolicyMap_) {
LifeCyclePolicy = LifeCycleManager::GetInstance().GetPolicy(intentionPolicyPair.first);
status = status == E_OK ? LifeCyclePolicy->DeleteOnTimeout(intentionPolicyPair.first) : status;
}
return status;
}
} // namespace UDMF
} // namespace OHOS

47
framework/manager/lifecycle/lifecycle_manager.h
View File

@ -1,47 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_LIFECYCLE_MANAGER_H
#define UDMF_LIFECYCLE_MANAGER_H
#include <chrono>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "clean_after_get.h"
#include "clean_on_startup.h"
#include "clean_on_timeout.h"
#include "executor_pool.h"
#include "lifecycle_policy.h"
namespace OHOS {
namespace UDMF {
class LifeCycleManager {
public:
static LifeCycleManager &GetInstance();
Status DeleteOnGet(const UnifiedKey &key);
Status DeleteOnStart();
Status DeleteOnSchedule();
private:
static std::shared_ptr<ExecutorPool> executorPool_;
static std::unordered_map<std::string, std::shared_ptr<LifeCyclePolicy>> intentionPolicyMap_;
static std::shared_ptr<LifeCyclePolicy> GetPolicy(const std::string &intention);
static Status DeleteOnTimeout();
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_LIFECYCLE_MANAGER_H

97
framework/manager/lifecycle/lifecycle_policy.cpp
View File

@ -1,97 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lifecycle_policy.h"
#include <algorithm>
namespace OHOS {
namespace UDMF {
using namespace std::chrono;
const LifeCyclePolicy::Duration LifeCyclePolicy::INTERVAL = milliseconds(60 * 60 * 1000);
const std::string LifeCyclePolicy::DATA_PREFIX = "udmf://";
Status LifeCyclePolicy::DeleteOnGet(const UnifiedKey &key)
{
auto store = storeCache_.GetStore(key.intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
if (store->Delete(key.key) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Remove data failed, intention: %{public}s.", key.intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
Status LifeCyclePolicy::DeleteOnStart(const std::string &intention)
{
auto store = storeCache_.GetStore(intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
if (store->Clear() != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Remove data failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
Status LifeCyclePolicy::DeleteOnTimeout(const std::string &intention)
{
auto store = storeCache_.GetStore(intention);
if (store == nullptr) {
LOG_ERROR(UDMF_FRAMEWORK, "Get store failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
std::vector<std::string> timeoutKeys;
auto status = GetTimeoutKeys(store, INTERVAL, timeoutKeys);
if (status != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get timeout keys failed.");
return E_DB_ERROR;
}
if (store->DeleteBatch(timeoutKeys) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Remove data failed, intention: %{public}s.", intention.c_str());
return E_DB_ERROR;
}
return E_OK;
}
Status LifeCyclePolicy::GetTimeoutKeys(
const std::shared_ptr<Store> &store, Duration interval, std::vector<std::string> &timeoutKeys)
{
std::vector<UnifiedData> datas;
auto status = store->GetBatchData(DATA_PREFIX, datas);
if (status != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Get datas failed.");
return E_DB_ERROR;
}
if (datas.empty()) {
LOG_DEBUG(UDMF_FRAMEWORK, "entries is empty.");
return E_OK;
}
auto curTime = PreProcessUtils::GetInstance().GetTimeStamp();
for (const auto &data : datas) {
if (curTime > data.GetRuntime()->createTime + duration_cast<milliseconds>(interval).count()
|| curTime < data.GetRuntime()->createTime) {
timeoutKeys.push_back(data.GetRuntime()->key.key);
}
}
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

46
framework/manager/lifecycle/lifecycle_policy.h
View File

@ -1,46 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_LIFECYCLE_POLICY_H
#define UDMF_LIFECYCLE_POLICY_H
#include <chrono>
#include <memory>
#include "logger.h"
#include "preprocess_utils.h"
#include "store_cache.h"
#include "unified_key.h"
namespace OHOS {
namespace UDMF {
class LifeCyclePolicy {
public:
using Duration = std::chrono::steady_clock::duration;
static const Duration INTERVAL;
virtual ~LifeCyclePolicy() = default;
virtual Status DeleteOnGet(const UnifiedKey &key);
virtual Status DeleteOnStart(const std::string &intention);
virtual Status DeleteOnTimeout(const std::string &intention);
virtual Status GetTimeoutKeys(
const std::shared_ptr<Store> &store, Duration interval, std::vector<std::string> &timeoutKeys);
private:
static const std::string DATA_PREFIX;
StoreCache storeCache_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_LIFECYCLE_POLICY_H

58
framework/manager/permission/checker_manager.cpp
View File

@ -1,58 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "checker_manager.h"
namespace OHOS {
namespace UDMF {
const std::string DATA_CHECKER = "DataChecker";
CheckerManager &CheckerManager::GetInstance()
{
static CheckerManager instance;
return instance;
}
void CheckerManager::RegisterChecker(const std::string &checker, std::function<Checker *()> getter)
{
getters_.ComputeIfAbsent(checker, [&getter](const auto &) {
return move(getter);
});
}
void CheckerManager::LoadCheckers()
{
getters_.ForEach([this] (const auto &key, const auto &val) {
if (this->checkers_.find(key) != this->checkers_.end()) {
return false;
}
auto *checker = val();
if (checker == nullptr) {
return false;
}
this->checkers_[key] = checker;
return false;
});
}
bool CheckerManager::IsValid(const std::vector<Privilege> &privileges, const CheckInfo &info)
{
auto it = checkers_.find(DATA_CHECKER);
if (it == checkers_.end()) {
return true;
}
return it->second->IsValid(privileges, info);
}
} // namespace UDMF
} // namespace OHOS

51
framework/manager/permission/checker_manager.h
View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_CHECKER_MANAGER_H
#define UDMF_CHECKER_MANAGER_H
#include <vector>
#include "concurrent_map.h"
#include "unified_types.h"
namespace OHOS {
namespace UDMF {
class CheckerManager {
public:
struct CheckInfo {
uint32_t tokenId;
};
class Checker {
public:
virtual bool IsValid(const std::vector<Privilege> &privileges, const CheckInfo &info) = 0;
protected:
~Checker() = default;
};
static CheckerManager &GetInstance();
void RegisterChecker(const std::string &checker, std::function<Checker *()> getter);
void LoadCheckers();
bool IsValid(const std::vector<Privilege> &privileges, const CheckInfo &info);
private:
std::map<std::string, Checker *> checkers_;
ConcurrentMap<std::string, std::function<Checker *()>> getters_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_CHECKER_MANAGER_H

46
framework/manager/permission/data_checker.cpp
View File

@ -1,46 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "data_checker.h"
#include "logger.h"
#include "anonymous.h"
namespace OHOS {
namespace UDMF {
__attribute__((used)) DataChecker DataChecker::instance_;
DataChecker::DataChecker() noexcept
{
CheckerManager::GetInstance().RegisterChecker(
"DataChecker", [this]() -> auto { return this; });
}
DataChecker::~DataChecker()
{
}
bool DataChecker::IsValid(const std::vector<Privilege> &privileges, const CheckerManager::CheckInfo &info)
{
for (const auto &privilege : privileges) {
if (privilege.tokenId == info.tokenId) {
return true;
}
}
LOG_ERROR(UDMF_FRAMEWORK, "Invalid parameters, %{public}s",
Anonymous::Change(std::to_string(info.tokenId)).c_str());
return false;
}
} // namespace UDMF
} // namespace OHOS

35
framework/manager/permission/data_checker.h
View File

@ -1,35 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_DATA_CHECKER_H
#define UDMF_DATA_CHECKER_H
#include "checker_manager.h"
namespace OHOS {
namespace UDMF {
class DataChecker : public CheckerManager::Checker {
public:
DataChecker() noexcept;
~DataChecker();
bool IsValid(const std::vector<Privilege> &privileges, const CheckerManager::CheckInfo &info) override;
private:
static DataChecker instance_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_DATA_CHECKER_H

45
framework/manager/permission/uri_permission_manager.cpp
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "uri_permission_manager.h"
#include "uri_permission_manager_client.h"
#include "want.h"
#include "uri.h"
#include "logger.h"
namespace OHOS {
namespace UDMF {
UriPermissionManager &UriPermissionManager::GetInstance()
{
static UriPermissionManager instance;
return instance;
}
Status UriPermissionManager::GrantUriPermission(const std::string &path, const std::string &bundleName)
{
Uri uri(path);
int autoRemove = 1;
auto status = AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermission(
uri, AAFwk::Want::FLAG_AUTH_READ_URI_PERMISSION, bundleName, autoRemove);
if (status != ERR_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "GrantUriPermission failed, %{public}d", status);
return E_ERROR;
}
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

33
framework/manager/permission/uri_permission_manager.h
View File

@ -1,33 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_URI_PERMISSION_MANAGER_H
#define UDMF_URI_PERMISSION_MANAGER_H
#include <memory>
#include <string>
#include "error_code.h"
namespace OHOS {
namespace UDMF {
class UriPermissionManager {
public:
static UriPermissionManager &GetInstance();
Status GrantUriPermission(const std::string &path, const std::string &bundleName);
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_URI_PERMISSION_MANAGER_H

104
framework/manager/preprocess/preprocess_utils.cpp
View File

@ -1,104 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "preprocess_utils.h"
#include <sstream>
#include "accesstoken_kit.h"
#include "bundlemgr/bundle_mgr_client_impl.h"
#include "ipc_skeleton.h"
namespace OHOS {
namespace UDMF {
static constexpr int ID_LEN = 32;
const char SPECIAL = '^';
PreProcessUtils &PreProcessUtils::GetInstance()
{
static auto instance = new PreProcessUtils();
return *instance;
}
bool PreProcessUtils::RuntimeDataImputation(UnifiedData &data, CustomOption &option)
{
auto it = UD_INTENTION_MAP.find(option.intention);
if (it == UD_INTENTION_MAP.end()) {
errorStr = "invalid intention";
return false;
}
std::string bundleName;
GetHapBundleNameByToken(option.tokenId, bundleName);
std::string intention = it->second;
UnifiedKey key(intention, bundleName, IdGenerator());
Privilege privilege;
privilege.tokenId = option.tokenId;
Runtime runtime;
runtime.key = key;
runtime.privileges.emplace_back(privilege);
runtime.createTime = GetTimeStamp();
runtime.sourcePackage = bundleName;
runtime.createPackage = bundleName;
data.SetRuntime(runtime);
return true;
}
std::string PreProcessUtils::IdGenerator()
{
std::random_device randomDevice;
int minimum = 48;
int maximum = 121;
std::uniform_int_distribution<int> distribution(minimum, maximum);
std::stringstream idStr;
for (int32_t i = 0; i < ID_LEN; i++) {
auto asc = distribution(randomDevice);
asc = asc >= SPECIAL ? asc + 1 : asc;
idStr << static_cast<uint8_t>(asc);
}
return idStr.str();
}
time_t PreProcessUtils::GetTimeStamp()
{
std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
time_t timestamp = tp.time_since_epoch().count();
return timestamp;
}
bool PreProcessUtils::GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName)
{
Security::AccessToken::HapTokenInfo hapInfo;
if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo)
!= Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) {
errorStr = "get bundle info error";
return false;
}
bundleName = hapInfo.bundleName;
return true;
}
bool PreProcessUtils::GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName)
{
Security::AccessToken::NativeTokenInfo nativeInfo;
if (Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(tokenId, nativeInfo)
!= Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) {
errorStr = "get native info error";
return false;
}
processName = nativeInfo.processName;
return true;
}
} // namespace UDMF
} // namespace OHOS

44
framework/manager/preprocess/preprocess_utils.h
View File

@ -1,44 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_PREPROCESS_UTILS_H
#define UDMF_PREPROCESS_UTILS_H
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include "logger.h"
#include "unified_data.h"
#include "unified_meta.h"
namespace OHOS {
namespace UDMF {
class PreProcessUtils {
public:
static PreProcessUtils &GetInstance();
/*
* Data Imputation
*/
bool RuntimeDataImputation(UnifiedData &data, CustomOption &option);
std::string IdGenerator();
time_t GetTimeStamp();
bool GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName);
bool GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName);
std::string errorStr;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_PREPROCESS_UTILS_H

312
framework/manager/store/runtime_store.cpp
View File

@ -1,312 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "runtime_store.h"
#include <algorithm>
#include <vector>
#include "logger.h"
#include "same_process_ipc_guard.h"
#include "tlv_util.h"
namespace OHOS {
namespace UDMF {
using namespace DistributedKv;
const AppId RuntimeStore::APP_ID = { "distributeddata" };
const std::string RuntimeStore::DATA_PREFIX = "udmf://";
const std::string RuntimeStore::BASE_DIR = "/data/service/el1/public/database/distributeddata";
RuntimeStore::RuntimeStore(const std::string &storeId) : storeId_({ storeId })
{
updateTime();
LOG_INFO(UDMF_SERVICE, "Construct runtimeStore: %{public}s.", storeId_.storeId.c_str());
}
RuntimeStore::~RuntimeStore()
{
LOG_INFO(UDMF_SERVICE, "Destruct runtimeStore: %{public}s.", storeId_.storeId.c_str());
Close();
}
Status RuntimeStore::Put(const UnifiedData &unifiedData)
{
updateTime();
std::vector<Entry> entries;
std::string unifiedKey = unifiedData.GetRuntime()->key.GetUnifiedKey();
// add unified record
for (const auto &record : unifiedData.GetRecords()) {
if (record == nullptr) {
LOG_ERROR(UDMF_SERVICE, "record is nullptr.");
return E_INVALID_PARAMETERS;
}
std::vector<uint8_t> recordBytes;
auto recordTlv = TLVObject(recordBytes);
if (!TLVUtil::Writing(record, recordTlv)) {
LOG_ERROR(UDMF_SERVICE, "Marshall unified record failed.");
return E_WRITE_PARCEL_ERROR;
}
Entry entry = { Key(unifiedKey + "/" + record->GetUid()), Value(recordBytes) };
entries.push_back(entry);
}
// add runtime info
std::vector<uint8_t> runtimeBytes;
auto runtimeTlv = TLVObject(runtimeBytes);
if (!TLVUtil::Writing(*unifiedData.GetRuntime(), runtimeTlv)) {
LOG_ERROR(UDMF_SERVICE, "Marshall runtime info failed.");
return E_WRITE_PARCEL_ERROR;
}
Entry entry = { Key(unifiedKey), Value(runtimeBytes) };
entries.push_back(entry);
auto status = PutEntries(entries);
return status;
}
Status RuntimeStore::Get(const std::string &key, UnifiedData &unifiedData)
{
updateTime();
std::vector<Entry> entries;
if (GetEntries(key, entries) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "GetEntries failed, dataPrefix: %{public}s.", key.c_str());
return E_DB_ERROR;
}
if (entries.empty()) {
LOG_DEBUG(UDMF_FRAMEWORK, "entries is empty.");
return E_OK;
}
return UnMarshalEntries(key, entries, unifiedData);
}
Status RuntimeStore::GetSummary(const std::string &key, Summary &summary)
{
updateTime();
UnifiedData unifiedData;
if (Get(key, unifiedData) != E_OK) {
LOG_ERROR(UDMF_SERVICE, "Get unified data failed.");
return E_DB_ERROR;
}
for (const auto &record : unifiedData.GetRecords()) {
int64_t recordSize = record->GetSize();
auto it = summary.summary.find(UD_TYPE_MAP.at(record->GetType()));
if (it == summary.summary.end()) {
summary.summary[UD_TYPE_MAP.at(record->GetType())] = recordSize;
} else {
summary.summary[UD_TYPE_MAP.at(record->GetType())] += recordSize;
}
summary.totalSize += recordSize;
}
return E_OK;
}
Status RuntimeStore::Update(const UnifiedData &unifiedData)
{
updateTime();
std::string key = unifiedData.GetRuntime()->key.key;
if (Delete(key) != E_OK) {
LOG_ERROR(UDMF_SERVICE, "Delete unified data failed.");
return E_DB_ERROR;
}
if (Put(unifiedData) != E_OK) {
LOG_ERROR(UDMF_SERVICE, "Put unified data failed.");
return E_DB_ERROR;
}
return E_OK;
}
Status RuntimeStore::Delete(const std::string &key)
{
updateTime();
std::vector<Entry> entries;
if (GetEntries(key, entries) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "GetEntries failed, dataPrefix: %{public}s.", key.c_str());
return E_DB_ERROR;
}
if (entries.empty()) {
LOG_DEBUG(UDMF_FRAMEWORK, "entries is empty.");
return E_OK;
}
std::vector<Key> keys;
for (const auto &entry : entries) {
keys.push_back(entry.key);
}
return DeleteEntries(keys);
}
Status RuntimeStore::DeleteBatch(const std::vector<std::string> &unifiedKeys)
{
updateTime();
LOG_DEBUG(UDMF_SERVICE, "called!");
if (unifiedKeys.empty()) {
LOG_DEBUG(UDMF_SERVICE, "No need to delete!");
return E_OK;
}
for (const std::string &unifiedKey : unifiedKeys) {
if (Delete(unifiedKey) != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "Delete failed, key: %{public}s.", unifiedKey.c_str());
return E_DB_ERROR;
}
}
return E_OK;
}
Status RuntimeStore::Sync(const std::vector<std::string> &devices)
{
updateTime();
SameProcessIpcGuard ipcGuard;
DistributedKv::Status status = kvStore_->Sync(devices, SyncMode::PULL);
if (status != DistributedKv::Status::SUCCESS) {
LOG_ERROR(UDMF_SERVICE, "Sync kvStore failed, status: %{public}d.", status);
return E_DB_ERROR;
}
return E_OK;
}
Status RuntimeStore::Clear()
{
updateTime();
return Delete(DATA_PREFIX);
}
Status RuntimeStore::GetBatchData(const std::string &dataPrefix, std::vector<UnifiedData> &unifiedDataSet)
{
updateTime();
std::vector<Entry> entries;
auto status = GetEntries(dataPrefix, entries);
if (status != E_OK) {
LOG_ERROR(UDMF_FRAMEWORK, "GetEntries failed, dataPrefix: %{public}s.", dataPrefix.c_str());
return E_DB_ERROR;
}
if (entries.empty()) {
LOG_DEBUG(UDMF_FRAMEWORK, "entries is empty.");
return E_OK;
}
std::vector<std::string> keySet;
for (const auto &entry : entries) {
std::string keyStr = entry.key.ToString();
if (std::count(keyStr.begin(), keyStr.end(), '/') == SLASH_COUNT_IN_KEY) {
keySet.emplace_back(keyStr);
}
}
for (const std::string &key : keySet) {
UnifiedData data;
if (UnMarshalEntries(key, entries, data) != E_OK) {
return E_READ_PARCEL_ERROR;
}
unifiedDataSet.emplace_back(data);
}
return E_OK;
}
void RuntimeStore::Close()
{
dataManager_.CloseKvStore(APP_ID, storeId_);
}
bool RuntimeStore::Init()
{
Options options;
options.autoSync = false;
options.createIfMissing = true;
options.rebuild = true;
options.backup = false;
options.securityLevel = SecurityLevel::S1;
options.baseDir = BASE_DIR;
options.area = Area::EL1;
options.kvStoreType = KvStoreType::SINGLE_VERSION;
SameProcessIpcGuard ipcGuard;
DistributedKv::Status status = dataManager_.GetSingleKvStore(options, APP_ID, storeId_, kvStore_);
if (status != DistributedKv::Status::SUCCESS) {
LOG_ERROR(UDMF_SERVICE, "GetKvStore: %{public}s failed, status: %{public}d.", storeId_.storeId.c_str(), status);
return false;
}
return true;
}
Status RuntimeStore::GetEntries(const std::string &dataPrefix, std::vector<Entry> &entries)
{
DataQuery query;
query.KeyPrefix(dataPrefix);
query.OrderByWriteTime(true);
auto status = kvStore_->GetEntries(query, entries);
if (status != DistributedKv::Status::SUCCESS) {
LOG_ERROR(UDMF_SERVICE, "KvStore getEntries failed, status: %{public}d.", static_cast<int>(status));
return E_DB_ERROR;
}
return E_OK;
}
Status RuntimeStore::PutEntries(const std::vector<Entry> &entries)
{
size_t size = entries.size();
DistributedKv::Status status;
for (size_t index = 0; index < size; index += MAX_BATCH_SIZE) {
std::vector<Entry> batchEntries(
entries.begin() + index, entries.begin() + std::min(index + MAX_BATCH_SIZE, size));
status = kvStore_->PutBatch(batchEntries);
if (status != DistributedKv::Status::SUCCESS) {
LOG_ERROR(UDMF_SERVICE, "KvStore putBatch failed, status: %{public}d.", status);
return E_DB_ERROR;
}
}
return E_OK;
}
Status RuntimeStore::DeleteEntries(const std::vector<Key> &keys)
{
size_t size = keys.size();
DistributedKv::Status status;
for (size_t index = 0; index < size; index += MAX_BATCH_SIZE) {
std::vector<Key> batchKeys(keys.begin() + index, keys.begin() + std::min(index + MAX_BATCH_SIZE, size));
status = kvStore_->DeleteBatch(batchKeys);
if (status != DistributedKv::Status::SUCCESS) {
LOG_ERROR(UDMF_SERVICE, "KvStore deleteBatch failed, status: %{public}d.", status);
return E_DB_ERROR;
}
}
return E_OK;
}
Status RuntimeStore::UnMarshalEntries(const std::string &key, std::vector<Entry> &entries, UnifiedData &unifiedData)
{
for (const auto &entry : entries) {
std::string keyStr = entry.key.ToString();
if (keyStr == key) {
Runtime runtime;
auto runtimeTlv = TLVObject(const_cast<std::vector<uint8_t> &>(entry.value.Data()));
if (!TLVUtil::Reading(runtime, runtimeTlv)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshall runtime info failed.");
return E_READ_PARCEL_ERROR;
}
unifiedData.SetRuntime(runtime);
break;
}
if (keyStr.find(key) == 0) {
std::shared_ptr<UnifiedRecord> record;
auto recordTlv = TLVObject(const_cast<std::vector<uint8_t> &>(entry.value.Data()));
if (!TLVUtil::Reading(record, recordTlv)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshall unified record failed.");
return E_READ_PARCEL_ERROR;
}
unifiedData.AddRecord(record);
}
}
return E_OK;
}
} // namespace UDMF
} // namespace OHOS

59
framework/manager/store/runtime_store.h
View File

@ -1,59 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_RUNTIMESTORE_H
#define UDMF_RUNTIMESTORE_H
#include "distributed_kv_data_manager.h"
#include "single_kvstore.h"
#include "store.h"
namespace OHOS {
namespace UDMF {
class RuntimeStore final : public Store {
public:
explicit RuntimeStore(const std::string &storeId);
~RuntimeStore();
Status Put(const UnifiedData &unifiedData) override;
Status Get(const std::string &key, UnifiedData &unifiedData) override;
Status GetSummary(const std::string &key, Summary &summary) override;
Status Update(const UnifiedData &unifiedData) override;
Status Delete(const std::string &key) override;
Status DeleteBatch(const std::vector<std::string> &unifiedKeys) override;
Status Sync(const std::vector<std::string> &devices) override;
Status Clear() override;
Status GetBatchData(const std::string &dataPrefix, std::vector<UnifiedData> &unifiedDataSet) override;
void Close() override;
bool Init() override;
private:
static const DistributedKv::AppId APP_ID;
static const std::string DATA_PREFIX;
static const std::string BASE_DIR;
static constexpr std::int32_t SLASH_COUNT_IN_KEY = 4;
static constexpr std::int32_t MAX_BATCH_SIZE = 128;
DistributedKv::DistributedKvDataManager dataManager_;
std::shared_ptr<DistributedKv::SingleKvStore> kvStore_;
DistributedKv::StoreId storeId_;
Status GetEntries(const std::string &dataPrefix, std::vector<DistributedKv::Entry> &entries);
Status PutEntries(const std::vector<DistributedKv::Entry> &entries);
Status DeleteEntries(const std::vector<DistributedKv::Key> &keys);
Status UnMarshalEntries(
const std::string &key, std::vector<DistributedKv::Entry> &entries, UnifiedData &unifiedData);
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_RUNTIMESTORE_H

63
framework/manager/store/store.h
View File

@ -1,63 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_STORE_H
#define UDMF_STORE_H
#include <string>
#include <shared_mutex>
#include "error_code.h"
#include "unified_data.h"
#include "unified_key.h"
#include "unified_types.h"
namespace OHOS {
namespace UDMF {
class Store {
public:
using Time = std::chrono::steady_clock::time_point;
virtual Status Put(const UnifiedData &unifiedData) = 0;
virtual Status Get(const std::string &key, UnifiedData &unifiedData) = 0;
virtual Status GetSummary(const std::string &key, Summary &summary) = 0;
virtual Status Update(const UnifiedData &unifiedData) = 0;
virtual Status Delete(const std::string &key) = 0;
virtual Status DeleteBatch(const std::vector<std::string> &unifiedKeys) = 0;
virtual Status Sync(const std::vector<std::string> &devices) = 0;
virtual Status Clear() = 0;
virtual bool Init() = 0;
virtual void Close() = 0;
virtual Status GetBatchData(const std::string &dataPrefix, std::vector<UnifiedData> &unifiedDataSet) = 0;
bool operator<(const Time &time) const
{
std::shared_lock<decltype(timeMutex_)> lock(timeMutex_);
return time_ < time;
}
void updateTime()
{
std::unique_lock<std::shared_mutex> lock(timeMutex_);
time_ = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL);
}
private:
static constexpr int64_t INTERVAL = 1; // 1 min
mutable Time time_;
mutable std::shared_mutex timeMutex_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_STORE_H

75
framework/manager/store/store_cache.cpp
View File

@ -1,75 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "store_cache.h"
#include <chrono>
#include "logger.h"
#include "runtime_store.h"
#include "unified_meta.h"
namespace OHOS {
namespace UDMF {
std::shared_ptr<ExecutorPool> StoreCache::executorPool_ = std::make_shared<ExecutorPool>(2, 1);
std::shared_ptr<Store> StoreCache::GetStore(std::string intention)
{
std::shared_ptr<Store> store;
stores_.Compute(intention, [&store](const auto &intention, std::shared_ptr<Store> &storePtr) -> bool {
if (storePtr != nullptr) {
store = storePtr;
return true;
}
if (intention == UD_INTENTION_MAP.at(UD_INTENTION_DRAG)
|| intention == UD_INTENTION_MAP.at(UD_INTENTION_DATA_HUB)) {
storePtr = std::make_shared<RuntimeStore>(intention);
if (!storePtr->Init()) {
LOG_ERROR(UDMF_SERVICE, "Init runtime store failed.");
return false;
}
store = storePtr;
return true;
}
return false;
});
std::unique_lock<std::mutex> lock(taskMutex_);
if (taskId_ == ExecutorPool::INVALID_TASK_ID) {
taskId_ = executorPool_->Schedule(std::chrono::minutes(INTERVAL), std::bind(&StoreCache::GarbageCollect, this));
}
return store;
}
void StoreCache::GarbageCollect()
{
auto current = std::chrono::steady_clock::now();
stores_.EraseIf([&current](auto &key, std::shared_ptr<Store> &storePtr) {
if (*storePtr < current) {
LOG_DEBUG(UDMF_SERVICE, "GarbageCollect, stores:%{public}s time limit, will be close.", key.c_str());
return true;
}
return false;
});
std::unique_lock<std::mutex> lock(taskMutex_);
if (!stores_.Empty()) {
LOG_DEBUG(UDMF_SERVICE, "GarbageCollect, stores size:%{public}zu", stores_.Size());
taskId_ = executorPool_->Schedule(std::chrono::minutes(INTERVAL), std::bind(&StoreCache::GarbageCollect, this));
} else {
taskId_ = ExecutorPool::INVALID_TASK_ID;
}
}
} // namespace UDMF
} // namespace OHOS

45
framework/manager/store/store_cache.h
View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_STORE_CACHE_H
#define UDMF_STORE_CACHE_H
#include <memory>
#include <mutex>
#include "concurrent_map.h"
#include "executor_pool.h"
#include "store.h"
#include "unified_meta.h"
namespace OHOS {
namespace UDMF {
class StoreCache {
public:
std::shared_ptr<Store> GetStore(std::string intention);
private:
void GarbageCollect();
ConcurrentMap<std::string, std::shared_ptr<Store>> stores_;
std::mutex taskMutex_;
ExecutorPool::TaskId taskId_ = ExecutorPool::INVALID_TASK_ID;
static constexpr int64_t INTERVAL = 1; // 1 min
static std::shared_ptr<ExecutorPool> executorPool_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_STORE_CACHE_H

2
framework/service/udmf_service_proxy.cpp
View File

@ -17,7 +17,7 @@
#include "ipc_types.h"
#include "preprocess_utils.h"
#include "logger.h"
#include "tlv_util.h"
#include "udmf_types_util.h"

21
interfaces/innerkits/BUILD.gn
View File

@ -20,21 +20,18 @@ config("udmf_client_config") {
"${udmf_interfaces_path}/innerkits/data",
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/manager/permission",
"${udmf_framework_path}/manager/lifecycle",
"${udmf_framework_path}/service",
"${kv_store_path}/frameworks/common",
"//third_party/libuv/include",
"//third_party/node/src",
"${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include",
"${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/src",
"${kv_store_path}/interfaces/innerkits/distributeddata/include",
]
}
ohos_shared_library("udmf_client") {
sources = [
"${udmf_framework_path}/common/anonymous.cpp",
"${udmf_framework_path}/common/tlv_util.cpp",
"${udmf_framework_path}/common/udmf_types_util.cpp",
"${udmf_framework_path}/innerkitsimpl/client/udmf_client.cpp",
@ -56,18 +53,6 @@ ohos_shared_library("udmf_client") {
"${udmf_framework_path}/innerkitsimpl/data/unified_data.cpp",
"${udmf_framework_path}/innerkitsimpl/data/unified_record.cpp",
"${udmf_framework_path}/innerkitsimpl/data/video.cpp",
"${udmf_framework_path}/manager/data_manager.cpp",
"${udmf_framework_path}/manager/lifecycle/clean_after_get.cpp",
"${udmf_framework_path}/manager/lifecycle/clean_on_startup.cpp",
"${udmf_framework_path}/manager/lifecycle/clean_on_timeout.cpp",
"${udmf_framework_path}/manager/lifecycle/lifecycle_manager.cpp",
"${udmf_framework_path}/manager/lifecycle/lifecycle_policy.cpp",
"${udmf_framework_path}/manager/permission/checker_manager.cpp",
"${udmf_framework_path}/manager/permission/data_checker.cpp",
"${udmf_framework_path}/manager/permission/uri_permission_manager.cpp",
"${udmf_framework_path}/manager/preprocess/preprocess_utils.cpp",
"${udmf_framework_path}/manager/store/runtime_store.cpp",
"${udmf_framework_path}/manager/store/store_cache.cpp",
"${udmf_framework_path}/service/udmf_service_client.cpp",
"${udmf_framework_path}/service/udmf_service_proxy.cpp",
]

6
interfaces/jskits/BUILD.gn
View File

@ -22,14 +22,8 @@ config("udmf_napi_config") {
"${udmf_interfaces_path}/jskits/data",
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/manager/permission",
"${udmf_framework_path}/manager/lifecycle",
"${udmf_framework_path}/service",
"${udmf_service_path}/include",
"//third_party/libuv/include",
"//third_party/node/src",

61
service/BUILD.gn
View File

@ -1,61 +0,0 @@
# Copyright (c) 2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/ohos.gni")
import("//foundation/distributeddatamgr/udmf/udmf.gni")
config("udmf_service_config") {
visibility = [ ":*" ]
include_dirs = [ "include" ]
}
ohos_shared_library("udmf_server") {
include_dirs = [
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/manager/permission",
"${udmf_framework_path}/manager/lifecycle",
"${udmf_framework_path}/service",
"${udmf_interfaces_path}/innerkits/client",
"${udmf_interfaces_path}/innerkits/common",
"${udmf_interfaces_path}/innerkits/data",
"${kv_store_path}/frameworks/common",
"${ddms_path}/services/distributeddataservice/framework/include",
"//third_party/libuv/include",
"//third_party/node/src",
]
sources = [
"src/udmf_service_impl.cpp",
"src/udmf_service_stub.cpp",
]
configs = [ ":udmf_service_config" ]
deps = [
"${ddms_path}/services/distributeddataservice/framework:distributeddatasvcfwk",
"../interfaces/innerkits:udmf_client",
]
external_deps = [
"access_token:libaccesstoken_sdk",
"c_utils:utils",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_core",
]
subsystem_name = "distributeddatamgr"
part_name = "udmf"
}

56
service/include/udmf_service_impl.h
View File

@ -1,56 +0,0 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_SERVICE_IMPL_H
#define UDMF_SERVICE_IMPL_H
#include <vector>
#include "udmf_service_stub.h"
namespace OHOS {
namespace UDMF {
/*
* UDMF server implementation
*/
class UdmfServiceImpl final : public UdmfServiceStub {
public:
UdmfServiceImpl() = default;
~UdmfServiceImpl() = default;
int32_t SetData(CustomOption &option, UnifiedData &unifiedData, std::string &key) override;
int32_t GetData(const QueryOption &query, UnifiedData &unifiedData) override;
int32_t GetBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet) override;
int32_t UpdateData(const QueryOption &query, UnifiedData &unifiedData) override;
int32_t DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet) override;
int32_t GetSummary(const QueryOption &query, Summary &summary) override;
int32_t AddPrivilege(const QueryOption &query, Privilege &privilege) override;
int32_t Sync(const QueryOption &query, const std::vector<std::string> &devices) override;
int32_t OnInitialize() override;
private:
class Factory {
public:
Factory();
~Factory();
private:
std::shared_ptr<UdmfServiceImpl> product_;
};
static Factory factory_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_SERVICE_IMPL_H

60
service/include/udmf_service_stub.h
View File

@ -1,60 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_SERVICE_STUB_H
#define UDMF_SERVICE_STUB_H
#include <map>
#include <string>
#include "feature/feature_system.h"
#include "message_parcel.h"
#include "error_code.h"
#include "udmf_service.h"
namespace OHOS {
namespace UDMF {
/*
* UDMF server stub
*/
class UdmfServiceStub : public UdmfService, public DistributedData::FeatureSystem::Feature {
public:
UdmfServiceStub();
virtual ~UdmfServiceStub() override;
int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply) override;
private:
int32_t OnSetData(MessageParcel &data, MessageParcel &reply);
int32_t OnGetData(MessageParcel &data, MessageParcel &reply);
int32_t OnGetBatchData(MessageParcel &data, MessageParcel &reply);
int32_t OnUpdateData(MessageParcel &data, MessageParcel &reply);
int32_t OnDeleteData(MessageParcel &data, MessageParcel &reply);
int32_t OnGetSummary(MessageParcel &data, MessageParcel &reply);
int32_t OnAddPrivilege(MessageParcel &data, MessageParcel &reply);
int32_t OnSync(MessageParcel &data, MessageParcel &reply);
bool VerifyPermission(const std::string &permission);
const std::string READ_PERMISSION = "ohos.permission.READ_UDMF_DATA";
const std::string WRITE_PERMISSION = "ohos.permission.WRITE_UDMF_DATA";
const std::string SYNC_PERMISSION = "ohos.permission.SYNC_UDMF_DATA";
using UdmfServiceFunc = int32_t (UdmfServiceStub::*)(MessageParcel &data, MessageParcel &reply);
std::map<uint32_t, UdmfServiceFunc> memberFuncMap_;
};
} // namespace UDMF
} // namespace OHOS
#endif // UDMF_SERVICE_STUB_H

106
service/src/udmf_service_impl.cpp
View File

@ -1,106 +0,0 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "udmf_service_impl.h"
#include "iservice_registry.h"
#include "data_manager.h"
#include "lifecycle/lifecycle_manager.h"
#include "logger.h"
#include "preprocess_utils.h"
namespace OHOS {
namespace UDMF {
using FeatureSystem = DistributedData::FeatureSystem;
__attribute__((used)) UdmfServiceImpl::Factory UdmfServiceImpl::factory_;
UdmfServiceImpl::Factory::Factory()
{
LOG_ERROR(UDMF_SERVICE, "Register udmf creator!");
FeatureSystem::GetInstance().RegisterCreator("udmf", [this]() {
if (product_ == nullptr) {
product_ = std::make_shared<UdmfServiceImpl>();
}
return product_;
});
}
UdmfServiceImpl::Factory::~Factory()
{
product_ = nullptr;
}
int32_t UdmfServiceImpl::SetData(CustomOption &option, UnifiedData &unifiedData, std::string &key)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().SaveData(option, unifiedData, key);
}
int32_t UdmfServiceImpl::GetData(const QueryOption &query, UnifiedData &unifiedData)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().RetrieveData(query, unifiedData);
}
int32_t UdmfServiceImpl::GetBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().RetrieveBatchData(query, unifiedDataSet);
}
int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifiedData)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().UpdateData(query, unifiedData);
}
int32_t UdmfServiceImpl::DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().DeleteData(query, unifiedDataSet);
}
int32_t UdmfServiceImpl::GetSummary(const QueryOption &query, Summary &summary)
{
LOG_DEBUG(UDMF_SERVICE, "start");
return DataManager::GetInstance().GetSummary(query, summary);
}
int32_t UdmfServiceImpl::AddPrivilege(const QueryOption &query, Privilege &privilege)
{
return DataManager::GetInstance().AddPrivilege(query, privilege);
}
int32_t UdmfServiceImpl::Sync(const QueryOption &query, const std::vector<std::string> &devices)
{
return DataManager::GetInstance().Sync(query, devices);
}
int32_t UdmfServiceImpl::OnInitialize()
{
LOG_DEBUG(UDMF_SERVICE, "start");
Status status = LifeCycleManager::GetInstance().DeleteOnStart();
if (status != E_OK) {
LOG_ERROR(UDMF_SERVICE, "DeleteOnStart execute failed, status: %{public}d", status);
}
status = LifeCycleManager::GetInstance().DeleteOnSchedule();
if (status != E_OK) {
LOG_ERROR(UDMF_SERVICE, "ScheduleTask start failed, status: %{public}d", status);
}
return DistributedData::FeatureSystem::STUB_SUCCESS;
}
} // namespace UDMF
} // namespace OHOS

268
service/src/udmf_service_stub.cpp
View File

@ -1,268 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "udmf_service_stub.h"
#include <vector>
#include "accesstoken_kit.h"
#include "ipc_skeleton.h"
#include "logger.h"
#include "udmf_types_util.h"
#include "unified_data.h"
#include "unified_meta.h"
namespace OHOS {
namespace UDMF {
UdmfServiceStub::UdmfServiceStub()
{
memberFuncMap_[static_cast<uint32_t>(SET_DATA)] = &UdmfServiceStub::OnSetData;
memberFuncMap_[static_cast<uint32_t>(GET_DATA)] = &UdmfServiceStub::OnGetData;
memberFuncMap_[static_cast<uint32_t>(GET_BATCH_DATA)] = &UdmfServiceStub::OnGetBatchData;
memberFuncMap_[static_cast<uint32_t>(UPDATE_DATA)] = &UdmfServiceStub::OnUpdateData;
memberFuncMap_[static_cast<uint32_t>(DELETE_DATA)] = &UdmfServiceStub::OnDeleteData;
memberFuncMap_[static_cast<uint32_t>(GET_SUMMARY)] = &UdmfServiceStub::OnGetSummary;
memberFuncMap_[static_cast<uint32_t>(ADD_PRIVILEGE)] = &UdmfServiceStub::OnAddPrivilege;
memberFuncMap_[static_cast<uint32_t>(SYNC)] = &UdmfServiceStub::OnSync;
}
UdmfServiceStub::~UdmfServiceStub()
{
memberFuncMap_.clear();
}
int UdmfServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start##code = %{public}u", code);
std::u16string myDescripter = UdmfServiceStub::GetDescriptor();
std::u16string remoteDescripter = data.ReadInterfaceToken();
if (myDescripter != remoteDescripter) {
LOG_ERROR(UDMF_SERVICE, "end##descriptor checked fail");
return -1;
}
if (CODE_HEAD > code || code >= CODE_BUTT) {
return -1;
}
auto itFunc = memberFuncMap_.find(code);
if (itFunc != memberFuncMap_.end()) {
auto memberFunc = itFunc->second;
if (memberFunc != nullptr) {
return (this->*memberFunc)(data, reply);
}
}
LOG_INFO(UDMF_SERVICE, "end##ret = -1");
return -1;
}
int32_t UdmfServiceStub::OnSetData(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
CustomOption customOption;
UnifiedData unifiedData;
if (!ITypesUtil::Unmarshal(data, customOption, unifiedData)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal customOption or unifiedData failed!");
return E_READ_PARCEL_ERROR;
}
if (unifiedData.IsEmpty()) {
LOG_ERROR(UDMF_SERVICE, "Empty data without any record!");
return E_INVALID_PARAMETERS;
}
if (unifiedData.GetSize() > UdmfService::MAX_DATA_SIZE) {
LOG_ERROR(UDMF_SERVICE, "Exceeded data limit!");
return E_INVALID_PARAMETERS;
}
for (const auto &record : unifiedData.GetRecords()) {
if (record == nullptr) {
LOG_ERROR(UDMF_SERVICE, "record is nullptr!");
return E_INVALID_PARAMETERS;
}
if (record->GetSize() > UdmfService::MAX_RECORD_SIZE) {
LOG_ERROR(UDMF_SERVICE, "Exceeded record limit!");
return E_INVALID_PARAMETERS;
}
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
customOption.tokenId = token;
std::string key;
int32_t status = SetData(customOption, unifiedData, key);
if (!ITypesUtil::Marshal(reply, status, key)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status or key failed, status: %{public}d, key: %{public}s", status,
key.c_str());
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnGetData(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
if (!ITypesUtil::Unmarshal(data, query)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal queryOption failed!");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
UnifiedData unifiedData;
int32_t status = GetData(query, unifiedData);
if (!ITypesUtil::Marshal(reply, status, unifiedData)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status or unifiedData failed, status: %{public}d", status);
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnGetBatchData(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
if (!ITypesUtil::Unmarshal(data, query)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal queryOption failed!");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
std::vector<UnifiedData> unifiedDataSet;
int32_t status = GetBatchData(query, unifiedDataSet);
if (!ITypesUtil::Marshal(reply, status, unifiedDataSet)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status or unifiedDataSet failed, status: %{public}d", status);
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnUpdateData(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
UnifiedData unifiedData;
if (!ITypesUtil::Unmarshal(data, query, unifiedData)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal queryOption or unifiedData failed!");
return E_READ_PARCEL_ERROR;
}
if (unifiedData.IsEmpty()) {
LOG_ERROR(UDMF_SERVICE, "Empty data without any record!");
return E_INVALID_PARAMETERS;
}
if (unifiedData.GetSize() > UdmfService::MAX_DATA_SIZE) {
LOG_ERROR(UDMF_SERVICE, "Exceeded data limit!");
return E_INVALID_PARAMETERS;
}
for (const auto &record : unifiedData.GetRecords()) {
if (record->GetSize() > UdmfService::MAX_RECORD_SIZE) {
LOG_ERROR(UDMF_SERVICE, "Exceeded record limit!");
return E_INVALID_PARAMETERS;
}
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
int32_t status = UpdateData(query, unifiedData);
if (!ITypesUtil::Marshal(reply, status)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status failed, status: %{public}d", status);
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnDeleteData(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
if (!ITypesUtil::Unmarshal(data, query)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal queryOption failed!");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
std::vector<UnifiedData> unifiedDataSet;
int32_t status = DeleteData(query, unifiedDataSet);
if (!ITypesUtil::Marshal(reply, status, unifiedDataSet)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status or unifiedDataSet failed, status: %{public}d", status);
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnGetSummary(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
if (!ITypesUtil::Unmarshal(data, query)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal query");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
Summary summary;
int32_t status = GetSummary(query, summary);
if (!ITypesUtil::Marshal(reply, status, summary)) {
LOG_ERROR(UDMF_SERVICE, "Marshal summary, key: %{public}s", query.key.c_str());
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnAddPrivilege(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
Privilege privilege;
if (!ITypesUtil::Unmarshal(data, query, privilege)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal query and privilege");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
int32_t status = AddPrivilege(query, privilege);
if (!ITypesUtil::Marshal(reply, status)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status, key: %{public}s", query.key.c_str());
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
int32_t UdmfServiceStub::OnSync(MessageParcel &data, MessageParcel &reply)
{
LOG_INFO(UDMF_SERVICE, "start");
QueryOption query;
std::vector<std::string> devices;
if (!ITypesUtil::Unmarshal(data, query, devices)) {
LOG_ERROR(UDMF_SERVICE, "Unmarshal query and devices");
return E_READ_PARCEL_ERROR;
}
uint32_t token = IPCSkeleton::GetCallingTokenID();
query.tokenId = token;
int32_t status = Sync(query, devices);
if (!ITypesUtil::Marshal(reply, status)) {
LOG_ERROR(UDMF_SERVICE, "Marshal status, key: %{public}s", query.key.c_str());
return E_WRITE_PARCEL_ERROR;
}
return E_OK;
}
/*
* Check whether the caller has the permission to access data.
*/
bool UdmfServiceStub::VerifyPermission(const std::string &permission)
{
#ifdef UDMF_PERMISSION_ENABLED
uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, permission);
return result == Security::AccessToken::TypePermissionState::PERMISSION_GRANTED;
#else
return true;
#endif // UDMF_PERMISSION_ENABLED
}
} // namespace UDMF
} // namespace OHOS

21
service/test/fuzztest/BUILD.gn
View File

@ -1,21 +0,0 @@
# Copyright (c) 2023 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/ohos.gni")
#########################################################################################
group("fuzztest") {
testonly = true
deps = [ "udmfservice_fuzzer:fuzztest" ]
}

73
service/test/fuzztest/udmfservice_fuzzer/BUILD.gn
View File

@ -1,73 +0,0 @@
# Copyright (c) 2023 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##############################hydra-fuzz########################################
import("//build/config/features.gni")
import("//build/test.gni")
import("//foundation/distributeddatamgr/udmf/udmf.gni")
##############################fuzztest##########################################
ohos_fuzztest("UdmfServiceFuzzTest") {
module_out_path = "udmf/service"
include_dirs = [
"${udmf_framework_path}/common",
"${udmf_framework_path}/manager",
"${udmf_framework_path}/manager/store",
"${udmf_framework_path}/manager/preprocess",
"${udmf_framework_path}/manager/permission",
"${udmf_framework_path}/manager/lifecycle",
"${udmf_framework_path}/service",
"${udmf_interfaces_path}/innerkits/client",
"${udmf_interfaces_path}/innerkits/common",
"${udmf_interfaces_path}/innerkits/data",
"${udmf_service_path}/include",
"${kv_store_path}/frameworks/common",
"${ddms_path}/services/distributeddataservice/framework/include",
"//third_party/libuv/include",
"//third_party/node/src",
]
fuzz_config_file = "${udmf_service_path}/test/fuzztest/udmfservice_fuzzer"
cflags = [
"-g",
"-O0",
"-Wno-unused-variable",
"-fno-omit-frame-pointer",
]
sources = [ "udmfservice_fuzzer.cpp" ]
deps = [ "${udmf_root_path}/service:udmf_server" ]
external_deps = [
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"bundle_framework:appexecfwk_core",
"c_utils:utils",
"hiviewdfx_hilog_native:libhilog",
"ipc:ipc_core",
"kv_store:distributeddata_inner",
"os_account:os_account_innerkits",
"samgr:samgr_proxy",
]
}
###############################################################################
group("fuzztest") {
testonly = true
deps = [ ":UdmfServiceFuzzTest" ]
}
###############################################################################

16
service/test/fuzztest/udmfservice_fuzzer/corpus/init
View File

@ -1,16 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
FUZZ

25
service/test/fuzztest/udmfservice_fuzzer/project.xml
View File

@ -1,25 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) 2023 Huawei Device Co., Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<fuzz_config>
<fuzztest>
<!-- maximum length of a test input -->
<max_len>1000</max_len>
<!-- maximum total time in seconds to run the fuzzer -->
<max_total_time>300</max_total_time>
<!-- memory usage limit in Mb -->
<rss_limit_mb>4096</rss_limit_mb>
</fuzztest>
</fuzz_config>

54
service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp
View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "udmfservice_fuzzer.h"
#include <cstddef>
#include <cstdint>
#include "udmf_service_impl.h"
#include "message_parcel.h"
#include "securec.h"
using namespace OHOS::UDMF;
namespace OHOS {
const std::u16string INTERFACE_TOKEN = u"OHOS.UDMF.UdmfService";
bool OnRemoteRequestFuzz(const uint8_t* data, size_t size)
{
uint32_t code = static_cast<uint32_t>(*data);
MessageParcel request;
request.WriteInterfaceToken(INTERFACE_TOKEN);
request.WriteBuffer(data, size);
request.RewindRead(0);
MessageParcel reply;
std::shared_ptr<UdmfServiceStub> udmfServiceStub = std::make_shared<UdmfServiceImpl>();
udmfServiceStub->OnRemoteRequest(code, request, reply);
return true;
}
}
/* Fuzzer entry point */
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
if (data == nullptr) {
return 0;
}
OHOS::OnRemoteRequestFuzz(data, size);
return 0;
}

21
service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.h
View File

@ -1,21 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UDMF_SERVICE_FUZZER_H
#define UDMF_SERVICE_FUZZER_H
#define FUZZ_PROJECT_NAME "udmfservice_fuzzer"
#endif // UDMF_SERVICE_FUZZER_H