1 /*
2 * Copyright (c) 2021-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 "net_policy_callback.h"
17
18 #include "net_mgr_log_wrapper.h"
19 #include "net_policy_constants.h"
20 #include "net_policy_inner_define.h"
21
22 namespace OHOS {
23 namespace NetManagerStandard {
24 constexpr const char *NET_ACTIVATE_WORK_THREAD = "POLICY_CALLBACK_WORK_THREAD";
25
NetPolicyCallback()26 NetPolicyCallback::NetPolicyCallback()
27 {
28 policyCallRunner_ = AppExecFwk::EventRunner::Create(NET_ACTIVATE_WORK_THREAD);
29 policyCallHandler_ = std::make_shared<AppExecFwk::EventHandler>(policyCallRunner_);
30 }
31
~NetPolicyCallback()32 NetPolicyCallback::~NetPolicyCallback()
33 {
34 if (policyCallRunner_) {
35 policyCallRunner_->Stop();
36 }
37 }
38
RegisterNetPolicyCallbackAsync(const sptr<INetPolicyCallback> & callback)39 int32_t NetPolicyCallback::RegisterNetPolicyCallbackAsync(const sptr<INetPolicyCallback> &callback)
40 {
41 if (callback == nullptr || callback->AsObject() == nullptr || callback->AsObject().GetRefPtr() == nullptr) {
42 NETMGR_LOG_E("The parameter callback is null");
43 return NETMANAGER_ERR_PARAMETER_ERROR;
44 }
45 int32_t ret = NETMANAGER_SUCCESS;
46 if (policyCallHandler_) {
47 policyCallHandler_->PostSyncTask([this, &callback, &ret]() {
48 ret = this->RegisterNetPolicyCallback(callback);
49 });
50 }
51
52 return ret;
53 }
54
RegisterNetPolicyCallback(const sptr<INetPolicyCallback> & callback)55 int32_t NetPolicyCallback::RegisterNetPolicyCallback(const sptr<INetPolicyCallback> &callback)
56 {
57 uint32_t callbackCounts = callbacks_.size();
58 NETMGR_LOG_D("callback counts [%{public}u]", callbackCounts);
59 if (callbackCounts >= LIMIT_CALLBACK_NUM) {
60 NETMGR_LOG_E("callback counts cannot more than [%{public}u]", LIMIT_CALLBACK_NUM);
61 return NETMANAGER_ERR_PARAMETER_ERROR;
62 }
63
64 for (uint32_t i = 0; i < callbackCounts; i++) {
65 if (callback->AsObject().GetRefPtr() == callbacks_[i]->AsObject().GetRefPtr()) {
66 NETMGR_LOG_W("netPolicyCallback_ had this callback");
67 return NETMANAGER_ERR_PARAMETER_ERROR;
68 }
69 }
70
71 callbacks_.emplace_back(callback);
72 return NETMANAGER_SUCCESS;
73 }
74
UnregisterNetPolicyCallbackAsync(const sptr<INetPolicyCallback> & callback)75 int32_t NetPolicyCallback::UnregisterNetPolicyCallbackAsync(const sptr<INetPolicyCallback> &callback)
76 {
77 if (callback == nullptr || callback->AsObject() == nullptr || callback->AsObject().GetRefPtr() == nullptr) {
78 NETMGR_LOG_E("The parameter of callback is null");
79 return NETMANAGER_ERR_PARAMETER_ERROR;
80 }
81
82 int32_t ret = NETMANAGER_SUCCESS;
83 if (policyCallHandler_) {
84 policyCallHandler_->PostSyncTask([this, &callback, &ret]() {
85 ret = this->UnregisterNetPolicyCallback(callback);
86 });
87 }
88
89 return ret;
90 }
91
UnregisterNetPolicyCallback(const sptr<INetPolicyCallback> & callback)92 int32_t NetPolicyCallback::UnregisterNetPolicyCallback(const sptr<INetPolicyCallback> &callback)
93 {
94 auto it = std::remove_if(callbacks_.begin(), callbacks_.end(),
95 [callback](const sptr<INetPolicyCallback> &tempCallback) -> bool {
96 if (tempCallback == nullptr || tempCallback->AsObject() == nullptr ||
97 tempCallback->AsObject().GetRefPtr() == nullptr) {
98 return true;
99 }
100 return callback->AsObject().GetRefPtr() == tempCallback->AsObject().GetRefPtr();
101 });
102 callbacks_.erase(it, callbacks_.end());
103
104 return NETMANAGER_SUCCESS;
105 }
106
NotifyNetUidPolicyChangeAsync(uint32_t uid,uint32_t policy)107 int32_t NetPolicyCallback::NotifyNetUidPolicyChangeAsync(uint32_t uid, uint32_t policy)
108 {
109 NETMGR_LOG_D("NotifyNetUidPolicyChange uid[%{public}u] policy[%{public}u]", uid, policy);
110 int32_t ret = NETMANAGER_SUCCESS;
111 if (policyCallHandler_) {
112 policyCallHandler_->PostSyncTask([this, uid, policy, &ret]() {
113 ret = this->NotifyNetUidPolicyChange(uid, policy);
114 });
115 }
116
117 return ret;
118 }
119
NotifyNetUidPolicyChange(uint32_t uid,uint32_t policy)120 int32_t NetPolicyCallback::NotifyNetUidPolicyChange(uint32_t uid, uint32_t policy)
121 {
122 for (const auto &callback : callbacks_) {
123 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
124 callback->NetUidPolicyChange(uid, policy);
125 }
126 }
127
128 return NETMANAGER_SUCCESS;
129 }
130
NotifyNetUidRuleChangeAsync(uint32_t uid,uint32_t rule)131 int32_t NetPolicyCallback::NotifyNetUidRuleChangeAsync(uint32_t uid, uint32_t rule)
132 {
133 NETMGR_LOG_D("NotifyNetUidRuleChange uid[%{public}u] rule[%{public}u]", uid, rule);
134
135 int32_t ret = NETMANAGER_SUCCESS;
136 if (policyCallHandler_) {
137 policyCallHandler_->PostSyncTask([this, uid, rule, &ret]() {
138 ret = this->NotifyNetUidRuleChange(uid, rule);
139 });
140 }
141 return ret;
142 }
143
NotifyNetUidRuleChange(uint32_t uid,uint32_t rule)144 int32_t NetPolicyCallback::NotifyNetUidRuleChange(uint32_t uid, uint32_t rule)
145 {
146 for (const auto &callback : callbacks_) {
147 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
148 callback->NetUidRuleChange(uid, rule);
149 }
150 }
151
152 return NETMANAGER_SUCCESS;
153 }
154
NotifyNetBackgroundPolicyChangeAsync(bool isAllowed)155 int32_t NetPolicyCallback::NotifyNetBackgroundPolicyChangeAsync(bool isAllowed)
156 {
157 NETMGR_LOG_D("NotifyNetBackgroundPolicyChange isAllowed[%{public}d]", isAllowed);
158 int32_t ret = NETMANAGER_SUCCESS;
159 if (policyCallHandler_) {
160 policyCallHandler_->PostSyncTask([this, isAllowed, &ret]() {
161 ret = this->NotifyNetBackgroundPolicyChange(isAllowed);
162 });
163 }
164 return ret;
165 }
166
NotifyNetBackgroundPolicyChange(bool isAllowed)167 int32_t NetPolicyCallback::NotifyNetBackgroundPolicyChange(bool isAllowed)
168 {
169 for (const auto &callback : callbacks_) {
170 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
171 callback->NetBackgroundPolicyChange(isAllowed);
172 }
173 }
174
175 return NETMANAGER_SUCCESS;
176 }
177
NotifyNetQuotaPolicyChangeAsync(const std::vector<NetQuotaPolicy> & quotaPolicies)178 int32_t NetPolicyCallback::NotifyNetQuotaPolicyChangeAsync(const std::vector<NetQuotaPolicy> "aPolicies)
179 {
180 if (quotaPolicies.empty()) {
181 NETMGR_LOG_E("NotifyNetQuotaPolicyChange quotaPolicies empty");
182 return POLICY_ERR_QUOTA_POLICY_NOT_EXIST;
183 }
184 NETMGR_LOG_D("NotifyNetQuotaPolicyChange quotaPolicies.size[%{public}zu]", quotaPolicies.size());
185
186 int32_t ret = NETMANAGER_SUCCESS;
187 if (policyCallHandler_) {
188 policyCallHandler_->PostSyncTask([this, "aPolicies, &ret]() {
189 ret = this->NotifyNetQuotaPolicyChange(quotaPolicies);
190 });
191 }
192 return ret;
193 }
194
NotifyNetQuotaPolicyChange(const std::vector<NetQuotaPolicy> & quotaPolicies)195 int32_t NetPolicyCallback::NotifyNetQuotaPolicyChange(const std::vector<NetQuotaPolicy> "aPolicies)
196 {
197 for (const auto &callback : callbacks_) {
198 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
199 callback->NetQuotaPolicyChange(quotaPolicies);
200 }
201 }
202
203 return NETMANAGER_SUCCESS;
204 }
205
NotifyNetMeteredIfacesChangeAsync(std::vector<std::string> & ifaces)206 int32_t NetPolicyCallback::NotifyNetMeteredIfacesChangeAsync(std::vector<std::string> &ifaces)
207 {
208 NETMGR_LOG_D("NotifyNetMeteredIfacesChange iface size[%{public}zu]", ifaces.size());
209 int32_t ret = NETMANAGER_SUCCESS;
210 if (policyCallHandler_) {
211 policyCallHandler_->PostSyncTask([this, &ifaces, &ret]() {
212 ret = this->NotifyNetMeteredIfacesChange(ifaces);
213 });
214 }
215 return ret;
216 }
217
NotifyNetMeteredIfacesChange(std::vector<std::string> & ifaces)218 int32_t NetPolicyCallback::NotifyNetMeteredIfacesChange(std::vector<std::string> &ifaces)
219 {
220 for (const auto &callback : callbacks_) {
221 if (callback != nullptr && callback->AsObject() != nullptr && callback->AsObject().GetRefPtr() != nullptr) {
222 callback->NetMeteredIfacesChange(ifaces);
223 }
224 }
225
226 return NETMANAGER_SUCCESS;
227 }
228 } // namespace NetManagerStandard
229 } // namespace OHOS
230