1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "policy_manager.h"
17 #include <algorithm>
18 #include <ctime>
19 #include <fstream>
20 #include <unistd.h>
21 #include "directory_ex.h"
22 #include "edm_log.h"
23
24 namespace OHOS {
25 namespace EDM {
26
PolicyManager(int32_t userId)27 PolicyManager::PolicyManager(int32_t userId)
28 {
29 EDMLOGD("PolicyManager::PolicyManager\n");
30 userIdState_ = userId;
31 }
32
~PolicyManager()33 PolicyManager::~PolicyManager()
34 {
35 EDMLOGD("PolicyManager::~PolicyManager\n");
36 }
37
GetAdminByPolicyName(const std::string & policyName,AdminValueItemsMap & adminValueItems)38 ErrCode PolicyManager::GetAdminByPolicyName(const std::string &policyName, AdminValueItemsMap &adminValueItems)
39 {
40 auto iter = policyAdmins_.find(policyName);
41 if (iter != policyAdmins_.end()) {
42 adminValueItems = iter->second;
43 return ERR_OK;
44 }
45 return ERR_EDM_POLICY_NOT_FOUND;
46 }
47
GetAllPolicyByAdmin(const std::string & adminName,PolicyItemsMap & allAdminPolicy)48 ErrCode PolicyManager::GetAllPolicyByAdmin(const std::string &adminName, PolicyItemsMap &allAdminPolicy)
49 {
50 auto iter = adminPolicies_.find(adminName);
51 if (iter != adminPolicies_.end()) {
52 allAdminPolicy = iter->second;
53 return ERR_OK;
54 }
55 return ERR_EDM_POLICY_NOT_FIND;
56 }
57
GetAdminPolicy(const std::string & adminName,const std::string & policyName,std::string & policyValue)58 ErrCode PolicyManager::GetAdminPolicy(const std::string &adminName, const std::string &policyName,
59 std::string &policyValue)
60 {
61 auto iter = adminPolicies_.find(adminName);
62 if (iter != adminPolicies_.end()) {
63 PolicyItemsMap &policyItem = iter->second;
64 auto it = policyItem.find(policyName);
65 if (it != policyItem.end()) {
66 policyValue = it->second;
67 return ERR_OK;
68 }
69 }
70 return ERR_EDM_POLICY_NOT_FIND;
71 }
72
GetCombinedPolicy(const std::string & policyName,std::string & policyValue)73 ErrCode PolicyManager::GetCombinedPolicy(const std::string &policyName, std::string &policyValue)
74 {
75 auto it = combinedPolicies_.find(policyName);
76 if (it != combinedPolicies_.end()) {
77 policyValue = it->second;
78 return ERR_OK;
79 }
80 return ERR_EDM_POLICY_NOT_FIND;
81 }
82
GetPolicy(const std::string & adminName,const std::string & policyName,std::string & policyValue)83 ErrCode PolicyManager::GetPolicy(const std::string &adminName, const std::string &policyName,
84 std::string &policyValue)
85 {
86 if (adminName.empty()) {
87 return GetCombinedPolicy(policyName, policyValue);
88 } else {
89 return GetAdminPolicy(adminName, policyName, policyValue);
90 }
91 }
92
SetAdminList(const std::string & adminName,const std::string & policyName,const std::string & policyValue)93 void PolicyManager::SetAdminList(const std::string &adminName, const std::string &policyName,
94 const std::string &policyValue)
95 {
96 auto iter = policyAdmins_.find(policyName);
97 if (iter == policyAdmins_.end()) {
98 /* policy first added into map */
99 AdminValueItemsMap adminValueItem;
100 adminValueItem.insert(std::pair<std::string, std::string>(adminName, policyValue));
101 policyAdmins_.insert(std::pair<std::string, AdminValueItemsMap>(policyName, adminValueItem));
102 return;
103 }
104
105 AdminValueItemsMap &adminValueRef = iter->second;
106 auto it = adminValueRef.find(adminName);
107 if (it != adminValueRef.end()) {
108 it->second = policyValue;
109 } else {
110 adminValueRef.insert(std::pair<std::string, std::string>(adminName, policyValue));
111 }
112 }
113
SetAdminPolicy(const std::string & adminName,const std::string & policyName,const std::string & policyValue)114 ErrCode PolicyManager::SetAdminPolicy(const std::string &adminName, const std::string &policyName,
115 const std::string &policyValue)
116 {
117 auto devicePoliciesStorageRdb = DevicePoliciesStorageRdb::GetInstance();
118 if (devicePoliciesStorageRdb == nullptr) {
119 EDMLOGE("PolicyManager::SetAdminPolicy get devicePoliciesStorageRdb failed.");
120 return ERR_GET_STORAGE_RDB_FAILED;
121 }
122 SetAdminList(adminName, policyName, policyValue);
123 auto iter = adminPolicies_.find(adminName);
124 if (iter == adminPolicies_.end()) {
125 if (devicePoliciesStorageRdb->InsertAdminPolicy(userIdState_, adminName, policyName, policyValue)) {
126 PolicyItemsMap itemMap;
127 itemMap.insert(std::pair<std::string, std::string>(policyName, policyValue));
128 adminPolicies_.insert(std::pair<std::string, PolicyItemsMap>(adminName, itemMap));
129 return ERR_OK;
130 }
131 EDMLOGE("PolicyManager::SetAdminPolicy failed.");
132 return ERR_EDM_POLICY_SET_FAILED;
133 }
134
135 PolicyItemsMap &policyItem = iter->second;
136 auto it = policyItem.find(policyName);
137 if (it != policyItem.end() &&
138 devicePoliciesStorageRdb->UpdateAdminPolicy(userIdState_, adminName, policyName, policyValue)) {
139 it->second = policyValue;
140 return ERR_OK;
141 } else if (it == policyItem.end() &&
142 devicePoliciesStorageRdb->InsertAdminPolicy(userIdState_, adminName, policyName, policyValue)) {
143 policyItem.insert(std::pair<std::string, std::string>(policyName, policyValue));
144 return ERR_OK;
145 }
146 EDMLOGE("PolicyManager::SetAdminPolicy failed.");
147 return ERR_EDM_POLICY_SET_FAILED;
148 }
149
SetCombinedPolicy(const std::string & policyName,const std::string & policyValue)150 ErrCode PolicyManager::SetCombinedPolicy(const std::string &policyName, const std::string &policyValue)
151 {
152 auto devicePoliciesStorageRdb = DevicePoliciesStorageRdb::GetInstance();
153 if (devicePoliciesStorageRdb == nullptr) {
154 EDMLOGE("PolicyManager::SetCombinedPolicy get devicePoliciesStorageRdb failed.");
155 return ERR_GET_STORAGE_RDB_FAILED;
156 }
157 auto it = combinedPolicies_.find(policyName);
158 if (it != combinedPolicies_.end() &&
159 devicePoliciesStorageRdb->UpdateCombinedPolicy(userIdState_, policyName, policyValue)) {
160 it->second = policyValue;
161 return ERR_OK;
162 } else if (it == combinedPolicies_.end() &&
163 devicePoliciesStorageRdb->InsertCombinedPolicy(userIdState_, policyName, policyValue)) {
164 combinedPolicies_.insert(std::pair<std::string, std::string>(policyName, policyValue));
165 return ERR_OK;
166 }
167 EDMLOGE("PolicyManager::SetCombinedPolicy failed.");
168 return ERR_EDM_POLICY_SET_FAILED;
169 }
170
DeleteAdminList(const std::string & adminName,const std::string & policyName)171 void PolicyManager::DeleteAdminList(const std::string &adminName, const std::string &policyName)
172 {
173 auto iter = policyAdmins_.find(policyName);
174 if (iter == policyAdmins_.end()) {
175 return;
176 }
177
178 AdminValueItemsMap &adminValueRef = iter->second;
179 auto it = adminValueRef.find(adminName);
180 if (it == adminValueRef.end()) {
181 return;
182 }
183
184 adminValueRef.erase(it);
185 if (adminValueRef.empty()) {
186 policyAdmins_.erase(iter);
187 }
188 }
189
DeleteAdminPolicy(const std::string & adminName,const std::string & policyName)190 ErrCode PolicyManager::DeleteAdminPolicy(const std::string &adminName, const std::string &policyName)
191 {
192 auto devicePoliciesStorageRdb = DevicePoliciesStorageRdb::GetInstance();
193 if (devicePoliciesStorageRdb == nullptr) {
194 EDMLOGE("PolicyManager::DeleteAdminPolicy get devicePoliciesStorageRdb failed.");
195 return ERR_GET_STORAGE_RDB_FAILED;
196 }
197 if (!devicePoliciesStorageRdb->DeleteAdminPolicy(userIdState_, adminName, policyName)) {
198 EDMLOGE("PolicyManager DeleteAdminPolicy failed.");
199 return ERR_EDM_POLICY_DEL_FAILED;
200 }
201 auto iter = adminPolicies_.find(adminName);
202 if (iter != adminPolicies_.end()) {
203 PolicyItemsMap &policyItem = iter->second;
204 auto it = policyItem.find(policyName);
205 if (it != policyItem.end()) {
206 policyItem.erase(it);
207 }
208
209 if (iter->second.empty()) {
210 adminPolicies_.erase(iter);
211 }
212
213 DeleteAdminList(adminName, policyName);
214 }
215 return ERR_OK;
216 }
217
DeleteCombinedPolicy(const std::string & policyName)218 ErrCode PolicyManager::DeleteCombinedPolicy(const std::string &policyName)
219 {
220 auto devicePoliciesStorageRdb = DevicePoliciesStorageRdb::GetInstance();
221 if (devicePoliciesStorageRdb == nullptr) {
222 EDMLOGE("PolicyManager::DeleteCombinedPolicy get devicePoliciesStorageRdb failed.");
223 return ERR_GET_STORAGE_RDB_FAILED;
224 }
225 if (!devicePoliciesStorageRdb->DeleteCombinedPolicy(userIdState_, policyName)) {
226 EDMLOGE("PolicyManager DeleteCombinedPolicy failed.");
227 return ERR_EDM_POLICY_DEL_FAILED;
228 }
229 auto it = combinedPolicies_.find(policyName);
230 if (it != combinedPolicies_.end()) {
231 combinedPolicies_.erase(it);
232 }
233 return ERR_OK;
234 }
235
DumpAdminPolicy()236 void PolicyManager::DumpAdminPolicy()
237 {
238 std::for_each(adminPolicies_.begin(), adminPolicies_.end(), [](auto iter) {
239 EDMLOGD("AdminName: %{public}s\n", iter.first.c_str());
240 std::unordered_map<std::string, std::string> map = iter.second;
241 std::for_each(map.begin(), map.end(),
242 [](auto subIter) { EDMLOGD("%{public}s : %{public}s\n", subIter.first.c_str(), subIter.second.c_str()); });
243 });
244 }
245
DumpAdminList()246 void PolicyManager::DumpAdminList()
247 {
248 std::for_each(policyAdmins_.begin(), policyAdmins_.end(), [](auto iter) {
249 EDMLOGD("PolicyName: %{public}s\n", iter.first.c_str());
250 std::unordered_map<std::string, std::string> map = iter.second;
251 std::for_each(map.begin(), map.end(),
252 [](auto subIter) { EDMLOGD("%{public}s : %{public}s\n", subIter.first.c_str(), subIter.second.c_str()); });
253 });
254 }
255
DumpCombinedPolicy()256 void PolicyManager::DumpCombinedPolicy()
257 {
258 std::for_each(combinedPolicies_.begin(), combinedPolicies_.end(),
259 [](auto iter) { EDMLOGD("%{public}s : %{public}s\n", iter.first.c_str(), iter.second.c_str()); });
260 }
261
SetPolicy(const std::string & adminName,const std::string & policyName,const std::string & adminPolicy,const std::string & mergedPolicy)262 ErrCode PolicyManager::SetPolicy(const std::string &adminName, const std::string &policyName,
263 const std::string &adminPolicy, const std::string &mergedPolicy)
264 {
265 if (policyName.empty()) {
266 return ERR_EDM_POLICY_SET_FAILED;
267 }
268
269 ErrCode err;
270 if (mergedPolicy.empty()) {
271 err = DeleteCombinedPolicy(policyName);
272 } else {
273 err = SetCombinedPolicy(policyName, mergedPolicy);
274 }
275 if (FAILED(err)) {
276 EDMLOGW("Set or delete combined policy failed:%{public}d, merged policy:%{public}s\n",
277 err, mergedPolicy.c_str());
278 }
279
280 if (!adminName.empty()) {
281 if (adminPolicy.empty()) {
282 err = DeleteAdminPolicy(adminName, policyName);
283 } else {
284 err = SetAdminPolicy(adminName, policyName, adminPolicy);
285 }
286 }
287 if (FAILED(err)) {
288 EDMLOGW("Set or delete admin policy failed:%{public}d, admin policy:%{public}s\n",
289 err, adminPolicy.c_str());
290 }
291 return err;
292 }
293
Init()294 void PolicyManager::Init()
295 {
296 auto devicePoliciesStorageRdb = DevicePoliciesStorageRdb::GetInstance();
297 if (devicePoliciesStorageRdb != nullptr &&
298 devicePoliciesStorageRdb->QueryAdminPolicy(userIdState_, adminPolicies_, policyAdmins_) &&
299 devicePoliciesStorageRdb->QueryCombinedPolicy(userIdState_, combinedPolicies_)) {
300 EDMLOGI("PolicyManager init success.");
301 } else {
302 EDMLOGE("PolicyManager init failed.");
303 }
304 }
305 } // namespace EDM
306 } // namespace OHOS
307