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