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