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