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