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 <napi/native_api.h>
17 #include <napi/native_common.h>
18
19 #include "constant.h"
20 #include "get_net_quota_policies_context.h"
21 #include "get_policy_by_uid_context.h"
22 #include "get_uids_by_policy_context.h"
23 #include "is_uid_net_allowed_context.h"
24 #include "module_template.h"
25 #include "napi_utils.h"
26 #include "net_mgr_log_wrapper.h"
27 #include "net_policy_constants.h"
28 #include "netmanager_base_log.h"
29 #include "netpolicy_async_work.h"
30 #include "policy_observer_wrapper.h"
31 #include "restore_all_policies_context.h"
32 #include "set_bg_policy_context.h"
33 #include "set_device_idle_allow_list_context.h"
34 #include "set_net_quota_policies_context.h"
35 #include "set_policy_by_uid_context.h"
36 #include "set_power_save_allow_list_context.h"
37 #include "update_remind_policy_context.h"
38
39 #define DEFINE_REMIND(REMIND) \
40 DECLARE_NAPI_STATIC_PROPERTY(#REMIND, NapiUtils::CreateUint32(env, static_cast<uint32_t>(RemindType::REMIND)))
41
42 #define DEFINE_UID_POLICY(POLICY) \
43 DECLARE_NAPI_STATIC_PROPERTY(#POLICY, NapiUtils::CreateInt32(env, static_cast<int32_t>(NetUidPolicy::POLICY)))
44
45 #define DEFINE_NET_UID_RULE(RULE) \
46 DECLARE_NAPI_STATIC_PROPERTY(#RULE, NapiUtils::CreateInt32(env, static_cast<int32_t>(NetUidRule::RULE)))
47
48 #define DEFINE_METERING_MODE(METERING_MODE) \
49 DECLARE_NAPI_STATIC_PROPERTY(#METERING_MODE, \
50 NapiUtils::CreateInt32(env, static_cast<int32_t>(MeteringMode::METERING_MODE)))
51
52 #define DEFINE_BACKGROUND_POLICY(BACKGROUND_POLICY) \
53 DECLARE_NAPI_STATIC_PROPERTY( \
54 #BACKGROUND_POLICY, NapiUtils::CreateInt32(env, static_cast<int32_t>(NetBackgroundPolicy::BACKGROUND_POLICY)))
55
56 #define DEFINE_LIMIT_ACTION(ACTION) \
57 DECLARE_NAPI_STATIC_PROPERTY(#ACTION, NapiUtils::CreateInt32(env, static_cast<int32_t>(LimitAction::ACTION)))
58
59 namespace OHOS {
60 namespace NetManagerStandard {
61 namespace {
62 constexpr const char *NETPOLICY_MODULE_NAME = "net.policy";
63
64 constexpr const char *FUNCTION_SET_POLICY_BY_UID = "setPolicyByUid";
65 constexpr const char *FUNCTION_GET_POLICY_BY_UID = "getPolicyByUid";
66 constexpr const char *FUNCTION_GET_UID_BY_POLICY = "getUidsByPolicy";
67 constexpr const char *FUNCTION_SET_NET_QUOTA_POLICIES = "setNetQuotaPolicies";
68 constexpr const char *FUNCTION_GET_NET_QUOTA_POLICIES = "getNetQuotaPolicies";
69 constexpr const char *FUNCTION_RESTORE_ALL_POLICIES = "restoreAllPolicies";
70 constexpr const char *FUNCTION_SET_BACKGROUND_POLICY = "setBackgroundAllowed";
71 constexpr const char *FUNCTION_GET_BACKGROUND_POLICY = "isBackgroundAllowed";
72 constexpr const char *FUNCTION_IS_UID_NET_ACCESS = "isUidNetAllowed";
73 constexpr const char *FUNCTION_SET_DEVICE_IDLE_ALLOWLIST = "setDeviceIdleTrustlist";
74 constexpr const char *FUNCTION_GET_DEVICE_IDLE_ALLOWLIST = "getDeviceIdleTrustlist";
75 constexpr const char *FUNCTION_GET_BACKGROUND_POLICY_BY_UID = "getBackgroundPolicyByUid";
76 constexpr const char *FUNCTION_RESET_POLICIES = "resetPolicies";
77 constexpr const char *FUNCTION_UPDATE_REMIND_POLICY = "updateRemindPolicy";
78 constexpr const char *FUNCTION_SET_POWER_SAVE_ALLOWLIST = "setPowerSaveTrustlist";
79 constexpr const char *FUNCTION_GET_POWER_SAVE_ALLOWLIST = "getPowerSaveTrustlist";
80 constexpr const char *FUNCTION_ON = "on";
81 constexpr const char *FUNCTION_OFF = "off";
82 constexpr const char *REMIND_TYPE = "RemindType";
83 constexpr const char *METERING_MODE = "MeteringMode";
84 constexpr const char *NET_UID_RULE = "NetUidRule";
85 constexpr const char *NET_UID_POLICY = "NetUidPolicy";
86 constexpr const char *NET_LIMIT_ACTION = "LimitAction";
87 constexpr const char *NET_BACKGROUND_POLICY = "NetBackgroundPolicy";
88
89 enum MeteringMode {
90 /* non metering */
91 UN_METERED = 0,
92 /* metering */
93 METERED,
94 };
95
96 enum ApplicationType {
97 /* common application */
98 COMMON = 0,
99 /* system application */
100 SYSTEM,
101 };
102 } // namespace
103
SetPolicyByUid(napi_env env,napi_callback_info info)104 napi_value SetPolicyByUid(napi_env env, napi_callback_info info)
105 {
106 return ModuleTemplate::Interface<SetPolicyByUidContext>(env, info, FUNCTION_SET_POLICY_BY_UID, nullptr,
107 NetPolicyAsyncWork::ExecSetPolicyByUid,
108 NetPolicyAsyncWork::SetPolicyByUidCallback);
109 }
110
GetPolicyByUid(napi_env env,napi_callback_info info)111 napi_value GetPolicyByUid(napi_env env, napi_callback_info info)
112 {
113 return ModuleTemplate::Interface<GetPolicyByUidContext>(env, info, FUNCTION_GET_POLICY_BY_UID, nullptr,
114 NetPolicyAsyncWork::ExecGetPolicyByUid,
115 NetPolicyAsyncWork::GetPolicyByUidCallback);
116 }
117
GetUidsByPolicy(napi_env env,napi_callback_info info)118 napi_value GetUidsByPolicy(napi_env env, napi_callback_info info)
119 {
120 return ModuleTemplate::Interface<GetUidsByPolicyContext>(env, info, FUNCTION_GET_UID_BY_POLICY, nullptr,
121 NetPolicyAsyncWork::ExecGetUidsByPolicy,
122 NetPolicyAsyncWork::GetUidsByPolicyCallback);
123 }
124
SetNetQuotaPolicies(napi_env env,napi_callback_info info)125 napi_value SetNetQuotaPolicies(napi_env env, napi_callback_info info)
126 {
127 return ModuleTemplate::Interface<SetNetQuotaPoliciesContext>(env, info, FUNCTION_SET_NET_QUOTA_POLICIES, nullptr,
128 NetPolicyAsyncWork::ExecSetNetQuotaPolicies,
129 NetPolicyAsyncWork::SetNetQuotaPoliciesCallback);
130 }
131
GetNetQuotaPolicies(napi_env env,napi_callback_info info)132 napi_value GetNetQuotaPolicies(napi_env env, napi_callback_info info)
133 {
134 return ModuleTemplate::Interface<GetNetQuotaPoliciesContext>(env, info, FUNCTION_GET_NET_QUOTA_POLICIES, nullptr,
135 NetPolicyAsyncWork::ExecGetNetQuotaPolicies,
136 NetPolicyAsyncWork::GetNetQuotaPoliciesCallback);
137 }
138
RestoreAllPolicies(napi_env env,napi_callback_info info)139 napi_value RestoreAllPolicies(napi_env env, napi_callback_info info)
140 {
141 return ModuleTemplate::Interface<RestoreAllPoliciesContext>(env, info, FUNCTION_RESTORE_ALL_POLICIES, nullptr,
142 NetPolicyAsyncWork::ExecRestoreAllPolicies,
143 NetPolicyAsyncWork::RestoreAllPoliciesCallback);
144 }
145
SetBackgroundPolicy(napi_env env,napi_callback_info info)146 napi_value SetBackgroundPolicy(napi_env env, napi_callback_info info)
147 {
148 return ModuleTemplate::Interface<SetBackgroundPolicyContext>(env, info, FUNCTION_SET_BACKGROUND_POLICY, nullptr,
149 NetPolicyAsyncWork::ExecSetBackgroundPolicy,
150 NetPolicyAsyncWork::SetBackgroundPolicyCallback);
151 }
152
GetBackgroundPolicy(napi_env env,napi_callback_info info)153 napi_value GetBackgroundPolicy(napi_env env, napi_callback_info info)
154 {
155 return ModuleTemplate::Interface<GetBackgroundPolicyContext>(env, info, FUNCTION_GET_BACKGROUND_POLICY, nullptr,
156 NetPolicyAsyncWork::ExecGetBackgroundPolicy,
157 NetPolicyAsyncWork::GetBackgroundPolicyCallback);
158 }
159
IsUidNetAllowed(napi_env env,napi_callback_info info)160 napi_value IsUidNetAllowed(napi_env env, napi_callback_info info)
161 {
162 return ModuleTemplate::Interface<IsUidNetAllowedContext>(env, info, FUNCTION_IS_UID_NET_ACCESS, nullptr,
163 NetPolicyAsyncWork::ExecIsUidNetAllowed,
164 NetPolicyAsyncWork::IsUidNetAllowedCallback);
165 }
166
SetDeviceIdleTrustlist(napi_env env,napi_callback_info info)167 napi_value SetDeviceIdleTrustlist(napi_env env, napi_callback_info info)
168 {
169 return ModuleTemplate::Interface<SetDeviceIdleTrustlistContext>(
170 env, info, FUNCTION_SET_DEVICE_IDLE_ALLOWLIST, nullptr, NetPolicyAsyncWork::ExecSetDeviceIdleTrustlist,
171 NetPolicyAsyncWork::SetDeviceIdleTrustlistCallback);
172 }
173
GetDeviceIdleTrustlist(napi_env env,napi_callback_info info)174 napi_value GetDeviceIdleTrustlist(napi_env env, napi_callback_info info)
175 {
176 return ModuleTemplate::Interface<GetDeviceIdleTrustlistContext>(
177 env, info, FUNCTION_GET_DEVICE_IDLE_ALLOWLIST, nullptr, NetPolicyAsyncWork::ExecGetDeviceIdleTrustlist,
178 NetPolicyAsyncWork::GetDeviceIdleTrustlistCallback);
179 }
180
GetBackgroundPolicyByUid(napi_env env,napi_callback_info info)181 napi_value GetBackgroundPolicyByUid(napi_env env, napi_callback_info info)
182 {
183 return ModuleTemplate::Interface<GetBackgroundPolicyByUidContext>(
184 env, info, FUNCTION_GET_BACKGROUND_POLICY_BY_UID, nullptr, NetPolicyAsyncWork::ExecGetBackgroundPolicyByUid,
185 NetPolicyAsyncWork::GetBackgroundPolicyByUidCallback);
186 }
187
ResetPolicies(napi_env env,napi_callback_info info)188 napi_value ResetPolicies(napi_env env, napi_callback_info info)
189 {
190 return ModuleTemplate::Interface<ResetPoliciesContext>(env, info, FUNCTION_RESET_POLICIES, nullptr,
191 NetPolicyAsyncWork::ExecResetPolicies,
192 NetPolicyAsyncWork::ResetPoliciesCallback);
193 }
194
UpdateRemindPolicy(napi_env env,napi_callback_info info)195 napi_value UpdateRemindPolicy(napi_env env, napi_callback_info info)
196 {
197 return ModuleTemplate::Interface<UpdateRemindPolicyContext>(env, info, FUNCTION_UPDATE_REMIND_POLICY, nullptr,
198 NetPolicyAsyncWork::ExecUpdateRemindPolicy,
199 NetPolicyAsyncWork::UpdateRemindPolicyCallback);
200 }
201
SetPowerSaveTrustlist(napi_env env,napi_callback_info info)202 napi_value SetPowerSaveTrustlist(napi_env env, napi_callback_info info)
203 {
204 return ModuleTemplate::Interface<SetPowerSaveTrustlistContext>(
205 env, info, FUNCTION_SET_POWER_SAVE_ALLOWLIST, nullptr, NetPolicyAsyncWork::ExecSetPowerSaveTrustlist,
206 NetPolicyAsyncWork::SetPowerSaveTrustlistCallback);
207 }
208
GetPowerSaveTrustlist(napi_env env,napi_callback_info info)209 napi_value GetPowerSaveTrustlist(napi_env env, napi_callback_info info)
210 {
211 return ModuleTemplate::Interface<GetPowerSaveTrustlistContext>(
212 env, info, FUNCTION_GET_POWER_SAVE_ALLOWLIST, nullptr, NetPolicyAsyncWork::ExecGetPowerSaveTrustlist,
213 NetPolicyAsyncWork::GetPowerSaveTrustlistCallback);
214 }
215
On(napi_env env,napi_callback_info info)216 napi_value On(napi_env env, napi_callback_info info)
217 {
218 return PolicyObserverWrapper::GetInstance().On(env, info,
219 {EVENT_POLICY_UID_POLICY, EVENT_POLICY_UID_RULE,
220 EVENT_POLICY_METERED_IFACES, EVENT_POLICY_QUOTA_POLICY,
221 EVENT_POLICY_BACKGROUND_POLICY, EVENT_POLICY_STRATEGY_SWITCH},
222 false);
223 }
224
Off(napi_env env,napi_callback_info info)225 napi_value Off(napi_env env, napi_callback_info info)
226 {
227 return PolicyObserverWrapper::GetInstance().Off(env, info,
228 {EVENT_POLICY_UID_POLICY, EVENT_POLICY_UID_RULE,
229 EVENT_POLICY_METERED_IFACES, EVENT_POLICY_QUOTA_POLICY,
230 EVENT_POLICY_BACKGROUND_POLICY, EVENT_POLICY_STRATEGY_SWITCH},
231 false);
232 }
233
CreateBackgroundPolicy(napi_env env,napi_value exports)234 static void CreateBackgroundPolicy(napi_env env, napi_value exports)
235 {
236 napi_value result = NapiUtils::CreateObject(env);
237 NapiUtils::DefineProperties(env, result,
238 {
239 DEFINE_BACKGROUND_POLICY(NET_BACKGROUND_POLICY_NONE),
240 DEFINE_BACKGROUND_POLICY(NET_BACKGROUND_POLICY_ENABLE),
241 DEFINE_BACKGROUND_POLICY(NET_BACKGROUND_POLICY_DISABLE),
242 DEFINE_BACKGROUND_POLICY(NET_BACKGROUND_POLICY_TRUSTLIST),
243 });
244 NapiUtils::SetNamedProperty(env, exports, NET_BACKGROUND_POLICY, result);
245 }
246
CreateMeteringMode(napi_env env,napi_value exports)247 static void CreateMeteringMode(napi_env env, napi_value exports)
248 {
249 napi_value result = NapiUtils::CreateObject(env);
250 NapiUtils::DefineProperties(env, result,
251 {
252 DEFINE_METERING_MODE(UN_METERED),
253 DEFINE_METERING_MODE(METERED),
254 });
255 NapiUtils::SetNamedProperty(env, exports, METERING_MODE, result);
256 }
257
CreateRemindType(napi_env env,napi_value exports)258 static void CreateRemindType(napi_env env, napi_value exports)
259 {
260 napi_value type = NapiUtils::CreateObject(env);
261 NapiUtils::DefineProperties(env, type,
262 {
263 DEFINE_REMIND(REMIND_TYPE_WARNING),
264 DEFINE_REMIND(REMIND_TYPE_LIMIT),
265 });
266 NapiUtils::SetNamedProperty(env, exports, REMIND_TYPE, type);
267 }
268
CreateNetUidRule(napi_env env,napi_value exports)269 static void CreateNetUidRule(napi_env env, napi_value exports)
270 {
271 napi_value result = NapiUtils::CreateObject(env);
272 NapiUtils::DefineProperties(env, result,
273 {
274 DEFINE_NET_UID_RULE(NET_RULE_NONE),
275 DEFINE_NET_UID_RULE(NET_RULE_ALLOW_METERED_FOREGROUND),
276 DEFINE_NET_UID_RULE(NET_RULE_ALLOW_METERED),
277 DEFINE_NET_UID_RULE(NET_RULE_REJECT_METERED),
278 DEFINE_NET_UID_RULE(NET_RULE_ALLOW_ALL),
279 DEFINE_NET_UID_RULE(NET_RULE_REJECT_ALL),
280 });
281 NapiUtils::SetNamedProperty(env, exports, NET_UID_RULE, result);
282 }
283
CreateNetUidPolicy(napi_env env,napi_value exports)284 static void CreateNetUidPolicy(napi_env env, napi_value exports)
285 {
286 napi_value result = NapiUtils::CreateObject(env);
287 NapiUtils::DefineProperties(env, result,
288 {
289 DEFINE_UID_POLICY(NET_POLICY_NONE),
290 DEFINE_UID_POLICY(NET_POLICY_ALLOW_METERED_BACKGROUND),
291 DEFINE_UID_POLICY(NET_POLICY_REJECT_METERED_BACKGROUND),
292 });
293 NapiUtils::SetNamedProperty(env, exports, NET_UID_POLICY, result);
294 }
295
CreateLimitAction(napi_env env,napi_value exports)296 static void CreateLimitAction(napi_env env, napi_value exports)
297 {
298 napi_value result = NapiUtils::CreateObject(env);
299 NapiUtils::DefineProperties(env, result,
300 {
301 DEFINE_LIMIT_ACTION(LIMIT_ACTION_NONE),
302 DEFINE_LIMIT_ACTION(LIMIT_ACTION_ACCESS_DISABLED),
303 DEFINE_LIMIT_ACTION(LIMIT_ACTION_ALERT_ONLY),
304 });
305 NapiUtils::SetNamedProperty(env, exports, NET_LIMIT_ACTION, result);
306 }
307
InitPolicyModule(napi_env env,napi_value exports)308 napi_value InitPolicyModule(napi_env env, napi_value exports)
309 {
310 NapiUtils::DefineProperties(
311 env, exports,
312 {
313 DECLARE_NAPI_FUNCTION(FUNCTION_SET_POLICY_BY_UID, SetPolicyByUid),
314 DECLARE_NAPI_FUNCTION(FUNCTION_GET_POLICY_BY_UID, GetPolicyByUid),
315 DECLARE_NAPI_FUNCTION(FUNCTION_GET_UID_BY_POLICY, GetUidsByPolicy),
316 DECLARE_NAPI_FUNCTION(FUNCTION_SET_NET_QUOTA_POLICIES, SetNetQuotaPolicies),
317 DECLARE_NAPI_FUNCTION(FUNCTION_GET_NET_QUOTA_POLICIES, GetNetQuotaPolicies),
318 DECLARE_NAPI_FUNCTION(FUNCTION_RESTORE_ALL_POLICIES, RestoreAllPolicies),
319 DECLARE_NAPI_FUNCTION(FUNCTION_SET_BACKGROUND_POLICY, SetBackgroundPolicy),
320 DECLARE_NAPI_FUNCTION(FUNCTION_GET_BACKGROUND_POLICY, GetBackgroundPolicy),
321 DECLARE_NAPI_FUNCTION(FUNCTION_IS_UID_NET_ACCESS, IsUidNetAllowed),
322 DECLARE_NAPI_FUNCTION(FUNCTION_SET_DEVICE_IDLE_ALLOWLIST, SetDeviceIdleTrustlist),
323 DECLARE_NAPI_FUNCTION(FUNCTION_GET_DEVICE_IDLE_ALLOWLIST, GetDeviceIdleTrustlist),
324 DECLARE_NAPI_FUNCTION(FUNCTION_GET_BACKGROUND_POLICY_BY_UID, GetBackgroundPolicyByUid),
325 DECLARE_NAPI_FUNCTION(FUNCTION_RESET_POLICIES, ResetPolicies),
326 DECLARE_NAPI_FUNCTION(FUNCTION_UPDATE_REMIND_POLICY, UpdateRemindPolicy),
327 DECLARE_NAPI_FUNCTION(FUNCTION_RESET_POLICIES, ResetPolicies),
328 DECLARE_NAPI_FUNCTION(FUNCTION_UPDATE_REMIND_POLICY, UpdateRemindPolicy),
329 DECLARE_NAPI_FUNCTION(FUNCTION_SET_POWER_SAVE_ALLOWLIST, SetPowerSaveTrustlist),
330 DECLARE_NAPI_FUNCTION(FUNCTION_GET_POWER_SAVE_ALLOWLIST, GetPowerSaveTrustlist),
331 DECLARE_NAPI_FUNCTION(FUNCTION_ON, On),
332 DECLARE_NAPI_FUNCTION(FUNCTION_OFF, Off),
333 });
334 CreateRemindType(env, exports);
335 CreateLimitAction(env, exports);
336 CreateNetUidPolicy(env, exports);
337 CreateBackgroundPolicy(env, exports);
338 CreateMeteringMode(env, exports);
339 CreateNetUidRule(env, exports);
340 return exports;
341 }
342
343 static napi_module g_policyModule = {
344 .nm_version = 1,
345 .nm_flags = 0,
346 .nm_filename = nullptr,
347 .nm_register_func = InitPolicyModule,
348 .nm_modname = NETPOLICY_MODULE_NAME,
349 .nm_priv = nullptr,
350 .reserved = {nullptr},
351 };
352
RegisterNetPolicyModule(void)353 extern "C" __attribute__((constructor)) void RegisterNetPolicyModule(void)
354 {
355 napi_module_register(&g_policyModule);
356 }
357 } // namespace NetManagerStandard
358 } // namespace OHOS
359