1 /*
2 * Copyright (c) 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 "vpn_monitor_ext.h"
17
18 #include <cstddef>
19 #include <string>
20
21 #include <napi/native_common.h>
22 #include <uv.h>
23
24 #include "module_template.h"
25 #include "napi_utils.h"
26 #include "netmanager_ext_log.h"
27 #include "networkvpn_client.h"
28 #include "want.h"
29 #include "ability_manager_client.h"
30 #include "extension_ability_info.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 namespace {
35 constexpr const char *CONNECT = "connect";
36 constexpr int32_t PARAM_JUST_OPTIONS = 1;
37 constexpr int32_t PARAM_OPTIONS_AND_CALLBACK = 2;
38
EventConnectCallback(uv_work_t * work,int status)39 void EventConnectCallback(uv_work_t *work, int status)
40 {
41 if (work == nullptr) {
42 NETMANAGER_EXT_LOGE("work is nullptr");
43 return;
44 }
45 auto workWrapper = reinterpret_cast<UvWorkWrapper *>(work->data);
46 if (workWrapper == nullptr) {
47 NETMANAGER_EXT_LOGE("workWrapper is nullptr");
48 delete work;
49 return;
50 }
51 bool *data = reinterpret_cast<bool *>(workWrapper->data);
52 if (data == nullptr) {
53 NETMANAGER_EXT_LOGE("isConnected is nullptr");
54 delete workWrapper;
55 delete work;
56 return;
57 }
58
59 napi_env env = workWrapper->env;
60 napi_handle_scope scope = NapiUtils::OpenScope(env);
61 napi_value isConnected = NapiUtils::GetBoolean(env, *data);
62 napi_value result = NapiUtils::CreateObject(env);
63 NapiUtils::SetNamedProperty(env, result, "isConnected", isConnected);
64 workWrapper->manager->Emit(CONNECT, std::make_pair(NapiUtils::GetUndefined(env), result));
65 NapiUtils::CloseScope(env, scope);
66 delete data;
67 delete workWrapper;
68 delete work;
69 }
70
CheckParamType(napi_env env,napi_value * params,size_t paramsCount)71 bool CheckParamType(napi_env env, napi_value *params, size_t paramsCount)
72 {
73 switch (paramsCount) {
74 case PARAM_JUST_OPTIONS:
75 return (NapiUtils::GetValueType(env, params[0]) == napi_string);
76 case PARAM_OPTIONS_AND_CALLBACK:
77 return ((NapiUtils::GetValueType(env, params[0]) == napi_string) &&
78 (NapiUtils::GetValueType(env, params[1]) == napi_function));
79 default:
80 return false;
81 }
82 }
83 } // namespace
84
OnVpnStateChanged(bool isConnected)85 int32_t VpnEventCallback::OnVpnStateChanged(bool isConnected)
86 {
87 auto manager = VpnMonitor::GetInstance().GetManager();
88 bool *data = new bool(isConnected);
89 manager->EmitByUv(CONNECT, reinterpret_cast<void *>(data), EventConnectCallback);
90 return ERR_OK;
91 }
92
GetInstance()93 VpnMonitor &VpnMonitor::GetInstance()
94 {
95 static VpnMonitor instance;
96 return instance;
97 }
98
On(napi_env env,napi_callback_info info)99 napi_value VpnMonitor::On(napi_env env, napi_callback_info info)
100 {
101 if (!ParseParams(env, info)) {
102 NETMANAGER_EXT_LOGE("parse failed");
103 NAPI_CALL(env, napi_throw_error(env, "0", "parse failed"));
104 return NapiUtils::GetUndefined(env);
105 }
106 Register(env);
107 return NapiUtils::GetUndefined(env);
108 }
109
Off(napi_env env,napi_callback_info info)110 napi_value VpnMonitor::Off(napi_env env, napi_callback_info info)
111 {
112 if (!ParseParams(env, info)) {
113 NETMANAGER_EXT_LOGE("parse failed");
114 NAPI_CALL(env, napi_throw_error(env, "0", "parse failed"));
115 return NapiUtils::GetUndefined(env);
116 }
117 Unregister(env);
118 return NapiUtils::GetUndefined(env);
119 }
120
ParseParams(napi_env env,napi_callback_info info)121 bool VpnMonitor::ParseParams(napi_env env, napi_callback_info info)
122 {
123 napi_value jsObject = nullptr;
124 size_t paramsCount = MAX_PARAM_NUM;
125 napi_value params[MAX_PARAM_NUM] = {nullptr};
126 NAPI_CALL_BASE(env, napi_get_cb_info(env, info, ¶msCount, params, &jsObject, nullptr), false);
127
128 if (!CheckParamType(env, params, paramsCount)) {
129 return false;
130 }
131 if (!UnwrapManager(env, jsObject)) {
132 return false;
133 }
134 const std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
135 if (CONNECT != event) {
136 NETMANAGER_EXT_LOGE("%{public}s event is error", event.c_str());
137 return false;
138 }
139 if (paramsCount == PARAM_OPTIONS_AND_CALLBACK) {
140 callback_ = params[1];
141 }
142 return true;
143 }
144
UnwrapManager(napi_env env,napi_value jsObject)145 bool VpnMonitor::UnwrapManager(napi_env env, napi_value jsObject)
146 {
147 NAPI_CALL_BASE(env, napi_unwrap(env, jsObject, reinterpret_cast<void **>(&manager_)), false);
148 if (manager_ == nullptr) {
149 return false;
150 }
151 return true;
152 }
153
Register(napi_env env)154 void VpnMonitor::Register(napi_env env)
155 {
156 auto vpnClient = reinterpret_cast<NetworkVpnClient *>(manager_->GetData());
157 if (vpnClient == nullptr) {
158 NETMANAGER_EXT_LOGE("vpnClient is nullptr");
159 return;
160 }
161 manager_->AddListener(env, CONNECT, callback_, false, false);
162
163 if (eventCallback_ != nullptr) {
164 vpnClient->UnregisterVpnEvent(eventCallback_);
165 }
166 eventCallback_ = new (std::nothrow) VpnEventCallback();
167 if (nullptr == eventCallback_) {
168 NETMANAGER_EXT_LOGE("eventCallback_ is nullptr");
169 return;
170 }
171 vpnClient->RegisterVpnEvent(eventCallback_);
172 }
173
Unregister(napi_env env)174 void VpnMonitor::Unregister(napi_env env)
175 {
176 auto vpnClient = reinterpret_cast<NetworkVpnClient *>(manager_->GetData());
177 if (vpnClient == nullptr) {
178 NETMANAGER_EXT_LOGE("vpnClient is nullptr");
179 return;
180 }
181 manager_->DeleteListener(CONNECT);
182 vpnClient->UnregisterVpnEvent(eventCallback_);
183 }
184
ShowVpnDialog(const std::string & bundleName,const std::string & abilityName,const std::string & appName)185 bool VpnMonitor::ShowVpnDialog(const std::string &bundleName, const std::string &abilityName,
186 const std::string &appName)
187 {
188 auto abmc = AAFwk::AbilityManagerClient::GetInstance();
189 if (abmc == nullptr) {
190 NETMANAGER_EXT_LOGE("GetInstance failed");
191 return false;
192 }
193
194 AAFwk::Want want;
195 want.SetElementName(VPN_DIALOG_BUNDLENAME, "VpnServiceExtAbility");
196 want.SetParam("bundleName", bundleName);
197 want.SetParam("abilityName", abilityName + VPN_DIALOG_POSTFIX);
198 want.SetParam("appName", appName);
199
200 sptr<VpnMonitor::VpnAbilityConn> vpnAbilityConn_ = sptr<VpnMonitor::VpnAbilityConn>::MakeSptr();
201 auto ret = abmc->ConnectAbility(want, vpnAbilityConn_, -1);
202 if (ret != 0) {
203 NETMANAGER_EXT_LOGE("connectAbility failed %{public}d", ret);
204 return false;
205 }
206 /* Waiting for the user to click */
207 NETMANAGER_EXT_LOGI("click done");
208 return true;
209 }
210 } // namespace NetManagerStandard
211 } // namespace OHOS