1 /*
2 * Copyright (c) 2022 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_observer.h"
17
18 #include "constant.h"
19 #include "netmanager_base_log.h"
20 #include "netpolicy_exec.h"
21 #include "net_manager_constants.h"
22 #include "net_policy_constants.h"
23 #include "net_quota_policy.h"
24 #include "policy_observer_wrapper.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
NetUidPolicyChange(uint32_t uid,uint32_t policy)28 int32_t NetPolicyCallbackObserver::NetUidPolicyChange(uint32_t uid, uint32_t policy)
29 {
30 if (!DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->HasEventListener(
31 EVENT_POLICY_UID_POLICY)) {
32 NETMANAGER_BASE_LOGE("no event listener find %{public}s", EVENT_POLICY_UID_POLICY);
33 return NETMANAGER_SUCCESS;
34 }
35 auto pair = new std::pair<uint32_t, uint32_t>(uid, policy);
36 DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->EmitByUv(EVENT_POLICY_UID_POLICY, pair,
37 NetUidPolicyChangeCallback);
38 return NETMANAGER_SUCCESS;
39 }
40
NetUidRuleChange(uint32_t uid,uint32_t rule)41 int32_t NetPolicyCallbackObserver::NetUidRuleChange(uint32_t uid, uint32_t rule)
42 {
43 if (!DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->HasEventListener(
44 EVENT_POLICY_UID_RULE)) {
45 NETMANAGER_BASE_LOGE("no event listener find %{public}s", EVENT_POLICY_UID_RULE);
46 return NETMANAGER_SUCCESS;
47 }
48 auto pair = new std::pair<uint32_t, uint32_t>(uid, rule);
49 DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->EmitByUv(EVENT_POLICY_UID_RULE, pair,
50 NetUidRuleChangeCallback);
51 return NETMANAGER_SUCCESS;
52 }
53
NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> & quotaPolicies)54 int32_t NetPolicyCallbackObserver::NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> "aPolicies)
55 {
56 if (!DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->HasEventListener(
57 EVENT_POLICY_QUOTA_POLICY)) {
58 NETMANAGER_BASE_LOGE("no event listener find %{public}s", EVENT_POLICY_QUOTA_POLICY);
59 return NETMANAGER_SUCCESS;
60 }
61 auto vec = new std::vector<NetQuotaPolicy>(quotaPolicies.size());
62 vec->assign(quotaPolicies.begin(), quotaPolicies.end());
63 DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->EmitByUv(EVENT_POLICY_QUOTA_POLICY, vec,
64 NetQuotaPolicyChangeCallback);
65 return NETMANAGER_SUCCESS;
66 }
67
NetMeteredIfacesChange(std::vector<std::string> & ifaces)68 int32_t NetPolicyCallbackObserver::NetMeteredIfacesChange(std::vector<std::string> &ifaces)
69 {
70 if (!DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->HasEventListener(
71 EVENT_POLICY_METERED_IFACES)) {
72 NETMANAGER_BASE_LOGE("no event listener find %{public}s", EVENT_POLICY_METERED_IFACES);
73 return NETMANAGER_SUCCESS;
74 }
75 auto vec = new std::vector<std::string>;
76 vec->assign(ifaces.begin(), ifaces.end());
77 DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->EmitByUv(
78 EVENT_POLICY_METERED_IFACES, vec, NetMeteredIfacesChangeCallback);
79 return NETMANAGER_SUCCESS;
80 }
81
NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)82 int32_t NetPolicyCallbackObserver::NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)
83 {
84 if (!DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->HasEventListener(
85 EVENT_POLICY_BACKGROUND_POLICY)) {
86 NETMANAGER_BASE_LOGE("no event listener find %{public}s", EVENT_POLICY_BACKGROUND_POLICY);
87 return NETMANAGER_SUCCESS;
88 }
89 DelayedSingleton<PolicyObserverWrapper>::GetInstance()->GetEventManager()->EmitByUv(
90 EVENT_POLICY_BACKGROUND_POLICY, new bool(isBackgroundPolicyAllow), NetBackgroundPolicyChangeCallback);
91 return NETMANAGER_SUCCESS;
92 }
93
CreateNetUidPolicyChangeParam(napi_env env,void * data)94 napi_value NetPolicyCallbackObserver::CreateNetUidPolicyChangeParam(napi_env env, void *data)
95 {
96 auto pair = static_cast<std::pair<uint32_t, uint32_t> *>(data);
97 napi_value obj = NapiUtils::CreateObject(env);
98 NapiUtils::SetUint32Property(env, obj, KEY_UID, pair->first);
99 NapiUtils::SetUint32Property(env, obj, KEY_POLICY, pair->second);
100 delete pair;
101 return obj;
102 }
103
CreateNetUidRuleChangeParam(napi_env env,void * data)104 napi_value NetPolicyCallbackObserver::CreateNetUidRuleChangeParam(napi_env env, void *data)
105 {
106 auto pair = static_cast<std::pair<uint32_t, uint32_t> *>(data);
107 napi_value obj = NapiUtils::CreateObject(env);
108 NapiUtils::SetUint32Property(env, obj, KEY_UID, pair->first);
109 NapiUtils::SetUint32Property(env, obj, KEY_RULE, pair->second);
110 delete pair;
111 return obj;
112 }
113
CreateNetQuotaPolicyChangeParam(napi_env env,void * data)114 napi_value NetPolicyCallbackObserver::CreateNetQuotaPolicyChangeParam(napi_env env, void *data)
115 {
116 auto quotaPolicies = static_cast<std::vector<NetQuotaPolicy> *>(data);
117 auto arraySize = quotaPolicies->size();
118 napi_value callbackValue = NapiUtils::CreateArray(env, arraySize);
119 for (size_t i = 0; i < arraySize; i++) {
120 const auto item = quotaPolicies->at(i);
121 napi_value elementObject = NetPolicyExec::CreateNetQuotaPolicy(env, item);
122 NapiUtils::SetArrayElement(env, callbackValue, i, elementObject);
123 }
124 delete quotaPolicies;
125 return callbackValue;
126 }
127
CreateMeteredIfacesChangeParam(napi_env env,void * data)128 napi_value NetPolicyCallbackObserver::CreateMeteredIfacesChangeParam(napi_env env, void *data)
129 {
130 auto ifaces = static_cast<std::vector<std::string> *>(data);
131 auto arraySize = ifaces->size();
132 napi_value callbackValue = NapiUtils::CreateArray(env, arraySize);
133 for (size_t i = 0; i < arraySize; i++) {
134 std::string item = ifaces->at(i);
135 napi_value elementObject = NapiUtils::CreateStringUtf8(env, item);
136 NapiUtils::SetArrayElement(env, callbackValue, i, elementObject);
137 }
138 delete ifaces;
139 return callbackValue;
140 }
141
CreateNetBackgroundPolicyChangeParam(napi_env env,void * data)142 napi_value NetPolicyCallbackObserver::CreateNetBackgroundPolicyChangeParam(napi_env env, void *data)
143 {
144 auto isAllow = static_cast<bool *>(data);
145 napi_value jsValue = NapiUtils::GetBoolean(env, isAllow);
146 delete isAllow;
147 return jsValue;
148 }
149
NetUidPolicyChangeCallback(uv_work_t * work,int status)150 void NetPolicyCallbackObserver::NetUidPolicyChangeCallback(uv_work_t *work, int status)
151 {
152 CallbackTemplate<CreateNetUidPolicyChangeParam>(work, status);
153 }
154
NetUidRuleChangeCallback(uv_work_t * work,int status)155 void NetPolicyCallbackObserver::NetUidRuleChangeCallback(uv_work_t *work, int status)
156 {
157 CallbackTemplate<CreateNetUidRuleChangeParam>(work, status);
158 }
159
NetQuotaPolicyChangeCallback(uv_work_t * work,int status)160 void NetPolicyCallbackObserver::NetQuotaPolicyChangeCallback(uv_work_t *work, int status)
161 {
162 CallbackTemplate<CreateNetQuotaPolicyChangeParam>(work, status);
163 }
164
NetMeteredIfacesChangeCallback(uv_work_t * work,int status)165 void NetPolicyCallbackObserver::NetMeteredIfacesChangeCallback(uv_work_t *work, int status)
166 {
167 CallbackTemplate<CreateMeteredIfacesChangeParam>(work, status);
168 }
169
NetBackgroundPolicyChangeCallback(uv_work_t * work,int status)170 void NetPolicyCallbackObserver::NetBackgroundPolicyChangeCallback(uv_work_t *work, int status)
171 {
172 CallbackTemplate<CreateNetBackgroundPolicyChangeParam>(work, status);
173 }
174 } // namespace NetManagerStandard
175 } // namespace OHOS
176