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 #include "usb_manager_addon.h"
16
17 #include "edm_log.h"
18 #include "usb_manager_proxy.h"
19
20 using namespace OHOS::EDM;
21
Init(napi_env env,napi_value exports)22 napi_value UsbManagerAddon::Init(napi_env env, napi_value exports)
23 {
24 napi_value policyValue = nullptr;
25 NAPI_CALL(env, napi_create_object(env, &policyValue));
26 CreateUsbPolicyEnum(env, policyValue);
27 napi_property_descriptor property[] = {
28 DECLARE_NAPI_PROPERTY("UsbPolicy", policyValue),
29 DECLARE_NAPI_FUNCTION("setUsbPolicy", SetUsbPolicy),
30 DECLARE_NAPI_FUNCTION("disableUsb", DisableUsb),
31 DECLARE_NAPI_FUNCTION("isUsbDisabled", IsUsbDisabled),
32 DECLARE_NAPI_FUNCTION("addAllowedUsbDevices", AddAllowedUsbDevices),
33 DECLARE_NAPI_FUNCTION("removeAllowedUsbDevices", RemoveAllowedUsbDevices),
34 DECLARE_NAPI_FUNCTION("getAllowedUsbDevices", GetAllowedUsbDevices),
35 DECLARE_NAPI_FUNCTION("setUsbStorageDeviceAccessPolicy", SetUsbStorageDeviceAccessPolicy),
36 DECLARE_NAPI_FUNCTION("getUsbStorageDeviceAccessPolicy", GetUsbStorageDeviceAccessPolicy),
37 };
38 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
39 return exports;
40 }
41
CreateUsbPolicyEnum(napi_env env,napi_value value)42 void UsbManagerAddon::CreateUsbPolicyEnum(napi_env env, napi_value value)
43 {
44 napi_value readWrite;
45 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_READ_WRITE, &readWrite));
46 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "READ_WRITE", readWrite));
47
48 napi_value readOnly;
49 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_READ_ONLY, &readOnly));
50 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "READ_ONLY", readOnly));
51
52 napi_value disabled;
53 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_DISABLED, &disabled));
54 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DISABLED", disabled));
55 }
56
SetUsbPolicy(napi_env env,napi_callback_info info)57 napi_value UsbManagerAddon::SetUsbPolicy(napi_env env, napi_callback_info info)
58 {
59 EDMLOGI("UsbManagerAddon::SetUsbPolicy called");
60 size_t argc = ARGS_SIZE_THREE;
61 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
62 napi_value thisArg = nullptr;
63 void *data = nullptr;
64 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
65 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
66 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
67 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "type admin error");
68 bool usbPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
69 ASSERT_AND_THROW_PARAM_ERROR(env, usbPolicy, "type usbPolicy error");
70 if (argc > ARGS_SIZE_TWO) {
71 bool hasCallback = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
72 ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "type callback error");
73 }
74
75 auto asyncCallbackInfo = new (std::nothrow) AsyncSetUsbPolicyCallbackInfo();
76 if (asyncCallbackInfo == nullptr) {
77 return nullptr;
78 }
79 std::unique_ptr<AsyncSetUsbPolicyCallbackInfo> callbackPtr{asyncCallbackInfo};
80 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
81 "element name param error");
82 EDMLOGD(
83 "SetUsbPolicy: asyncCallbackInfo->elementName.bundlename %{public}s, "
84 "asyncCallbackInfo->abilityname:%{public}s",
85 asyncCallbackInfo->elementName.GetBundleName().c_str(),
86 asyncCallbackInfo->elementName.GetAbilityName().c_str());
87 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->policy, argv[ARR_INDEX_ONE]),
88 "wifiProfile param error");
89 if (argc > ARGS_SIZE_TWO) {
90 EDMLOGD("NAPI_SetUsbPolicy argc == ARGS_SIZE_THREE");
91 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
92 }
93 bool existUsbPolicy = std::any_of(std::begin(USB_POLICY), std::end(USB_POLICY),
94 [&](int item) { return item == asyncCallbackInfo->policy; });
95 ASSERT_AND_THROW_PARAM_ERROR(env, existUsbPolicy, "usb policy value error");
96 napi_value asyncWorkReturn =
97 HandleAsyncWork(env, asyncCallbackInfo, "SetUsbPolicy", NativeSetUsbPolicy, NativeVoidCallbackComplete);
98 callbackPtr.release();
99 return asyncWorkReturn;
100 }
101
NativeSetUsbPolicy(napi_env env,void * data)102 void UsbManagerAddon::NativeSetUsbPolicy(napi_env env, void *data)
103 {
104 EDMLOGI("NAPI_NativeSetUsbPolicy called");
105 if (data == nullptr) {
106 EDMLOGE("data is nullptr");
107 return;
108 }
109 AsyncSetUsbPolicyCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetUsbPolicyCallbackInfo *>(data);
110 switch (asyncCallbackInfo->policy) {
111 case EdmConstants::STORAGE_USB_POLICY_READ_WRITE:
112 asyncCallbackInfo->ret =
113 UsbManagerProxy::GetUsbManagerProxy()->SetUsbReadOnly(asyncCallbackInfo->elementName, false);
114 break;
115 case EdmConstants::STORAGE_USB_POLICY_READ_ONLY:
116 asyncCallbackInfo->ret =
117 UsbManagerProxy::GetUsbManagerProxy()->SetUsbReadOnly(asyncCallbackInfo->elementName, true);
118 break;
119 default:
120 asyncCallbackInfo->ret = EdmReturnErrCode::PARAM_ERROR;
121 break;
122 }
123 }
124
DisableUsb(napi_env env,napi_callback_info info)125 napi_value UsbManagerAddon::DisableUsb(napi_env env, napi_callback_info info)
126 {
127 EDMLOGI("UsbManagerAddon::DisableUsb called");
128 size_t argc = ARGS_SIZE_TWO;
129 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
130 napi_value thisArg = nullptr;
131 void *data = nullptr;
132 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
133 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
134 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
135 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean),
136 "parameter disallow error");
137
138 OHOS::AppExecFwk::ElementName elementName;
139 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
140 "parameter admin parse error");
141 bool disable = false;
142 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disable, argv[ARR_INDEX_ONE]), "parameter disallow parse error");
143
144 auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
145 if (usbManagerProxy == nullptr) {
146 EDMLOGE("can not get usbManagerProxy");
147 return nullptr;
148 }
149 EDMLOGI("UsbManagerAddon::DisableUsb: %{public}d", disable);
150 int32_t ret = usbManagerProxy->DisableUsb(elementName, disable);
151 if (FAILED(ret)) {
152 napi_throw(env, CreateError(env, ret));
153 }
154 return nullptr;
155 }
156
IsUsbDisabled(napi_env env,napi_callback_info info)157 napi_value UsbManagerAddon::IsUsbDisabled(napi_env env, napi_callback_info info)
158 {
159 EDMLOGI("UsbManagerAddon::IsUsbDisabled called");
160 size_t argc = ARGS_SIZE_ONE;
161 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
162 napi_value thisArg = nullptr;
163 void *data = nullptr;
164 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
165 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
166 bool hasAdmin = false;
167 OHOS::AppExecFwk::ElementName elementName;
168 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
169 "param admin need be null or want");
170 bool isDisabled = false;
171 int32_t ret = ERR_OK;
172 if (hasAdmin) {
173 ret = UsbManagerProxy::GetUsbManagerProxy()->IsUsbDisabled(&elementName, isDisabled);
174 } else {
175 ret = UsbManagerProxy::GetUsbManagerProxy()->IsUsbDisabled(nullptr, isDisabled);
176 }
177 EDMLOGI("UsbManagerAddon::IsUsbDisabled return: %{public}d", isDisabled);
178 if (FAILED(ret)) {
179 napi_throw(env, CreateError(env, ret));
180 return nullptr;
181 }
182 napi_value result = nullptr;
183 napi_get_boolean(env, isDisabled, &result);
184 return result;
185 }
186
AddAllowedUsbDevices(napi_env env,napi_callback_info info)187 napi_value UsbManagerAddon::AddAllowedUsbDevices(napi_env env, napi_callback_info info)
188 {
189 EDMLOGI("UsbManagerAddon::AddAllowedUsbDevices called");
190 return AddOrRemoveAllowedUsbDevices(env, info, true);
191 }
192
RemoveAllowedUsbDevices(napi_env env,napi_callback_info info)193 napi_value UsbManagerAddon::RemoveAllowedUsbDevices(napi_env env, napi_callback_info info)
194 {
195 EDMLOGI("UsbManagerAddon::RemoveAllowedUsbDevices called");
196 return AddOrRemoveAllowedUsbDevices(env, info, false);
197 }
198
AddOrRemoveAllowedUsbDevices(napi_env env,napi_callback_info info,bool isAdd)199 napi_value UsbManagerAddon::AddOrRemoveAllowedUsbDevices(napi_env env, napi_callback_info info, bool isAdd)
200 {
201 size_t argc = ARGS_SIZE_TWO;
202 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
203 napi_value thisArg = nullptr;
204 void *data = nullptr;
205 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
206 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
207 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
208 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
209 "parameter usbDeviceIds error");
210 OHOS::AppExecFwk::ElementName elementName;
211 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
212 "parameter admin parse error");
213 std::vector<UsbDeviceId> usbDeviceIds;
214 ASSERT_AND_THROW_PARAM_ERROR(env, ParseUsbDevicesArray(env, usbDeviceIds, argv[ARR_INDEX_ONE]),
215 "parameter usbDeviceIds error");
216
217 auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
218 if (usbManagerProxy == nullptr) {
219 EDMLOGE("can not get usbManagerProxy");
220 return nullptr;
221 }
222 int32_t ret = ERR_OK;
223 if (isAdd) {
224 ret = usbManagerProxy->AddAllowedUsbDevices(elementName, usbDeviceIds);
225 } else {
226 ret = usbManagerProxy->RemoveAllowedUsbDevices(elementName, usbDeviceIds);
227 }
228 if (FAILED(ret)) {
229 napi_throw(env, CreateError(env, ret));
230 }
231 return nullptr;
232 }
233
ParseUsbDevicesArray(napi_env env,std::vector<UsbDeviceId> & usbDeviceIds,napi_value object)234 bool UsbManagerAddon::ParseUsbDevicesArray(napi_env env, std::vector<UsbDeviceId> &usbDeviceIds, napi_value object)
235 {
236 bool isArray = false;
237 napi_is_array(env, object, &isArray);
238 if (!isArray) {
239 return false;
240 }
241 uint32_t arrayLength = 0;
242 napi_get_array_length(env, object, &arrayLength);
243 for (uint32_t i = 0; i < arrayLength; i++) {
244 napi_value value = nullptr;
245 napi_get_element(env, object, i, &value);
246 napi_valuetype valueType = napi_undefined;
247 napi_typeof(env, value, &valueType);
248 if (valueType != napi_object) {
249 usbDeviceIds.clear();
250 return false;
251 }
252 UsbDeviceId usbDeviceId;
253 if (!GetUsbDeviceIdFromNAPI(env, value, usbDeviceId)) {
254 usbDeviceIds.clear();
255 return false;
256 }
257 usbDeviceIds.push_back(usbDeviceId);
258 }
259 return true;
260 }
261
GetUsbDeviceIdFromNAPI(napi_env env,napi_value value,UsbDeviceId & usbDeviceId)262 bool UsbManagerAddon::GetUsbDeviceIdFromNAPI(napi_env env, napi_value value, UsbDeviceId &usbDeviceId)
263 {
264 int32_t vendorId = 0;
265 if (!JsObjectToInt(env, value, "vendorId", true, vendorId)) {
266 EDMLOGE("Add/RemoveAllowedUsbDevices vendorId parse error!");
267 return false;
268 }
269 int32_t productId = 0;
270 if (!JsObjectToInt(env, value, "productId", true, productId)) {
271 EDMLOGE("Add/RemoveAllowedUsbDevices productId parse error!");
272 return false;
273 }
274 usbDeviceId.SetVendorId(vendorId);
275 usbDeviceId.SetProductId(productId);
276 EDMLOGD("GetUsbDeviceIdFromNAPI vendorId: %{public}d, productId: %{public}d", vendorId, productId);
277 return true;
278 }
279
GetAllowedUsbDevices(napi_env env,napi_callback_info info)280 napi_value UsbManagerAddon::GetAllowedUsbDevices(napi_env env, napi_callback_info info)
281 {
282 EDMLOGI("UsbManagerAddon::GetAllowedUsbDevices called");
283 size_t argc = ARGS_SIZE_ONE;
284 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
285 napi_value thisArg = nullptr;
286 void *data = nullptr;
287 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
288 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
289 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
290 OHOS::AppExecFwk::ElementName elementName;
291 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
292 "parameter admin parse error");
293
294 auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
295 if (usbManagerProxy == nullptr) {
296 EDMLOGE("can not get usbManagerProxy");
297 return nullptr;
298 }
299 std::vector<UsbDeviceId> usbDeviceIds;
300 int32_t ret = usbManagerProxy->GetAllowedUsbDevices(elementName, usbDeviceIds);
301 EDMLOGI("UsbManagerAddon::GetAllowedUsbDevices usbDeviceIds return size: %{public}zu", usbDeviceIds.size());
302 if (FAILED(ret)) {
303 napi_throw(env, CreateError(env, ret));
304 return nullptr;
305 }
306 napi_value jsList = nullptr;
307 NAPI_CALL(env, napi_create_array_with_length(env, usbDeviceIds.size(), &jsList));
308 for (size_t i = 0; i < usbDeviceIds.size(); i++) {
309 napi_value item = UsbDeviceIdToJsObj(env, usbDeviceIds[i]);
310 NAPI_CALL(env, napi_set_element(env, jsList, i, item));
311 }
312 return jsList;
313 }
314
UsbDeviceIdToJsObj(napi_env env,const UsbDeviceId & usbDeviceId)315 napi_value UsbManagerAddon::UsbDeviceIdToJsObj(napi_env env, const UsbDeviceId &usbDeviceId)
316 {
317 napi_value value = nullptr;
318 NAPI_CALL(env, napi_create_object(env, &value));
319
320 napi_value vendorId = nullptr;
321 NAPI_CALL(env, napi_create_int32(env, usbDeviceId.GetVendorId(), &vendorId));
322 NAPI_CALL(env, napi_set_named_property(env, value, "vendorId", vendorId));
323
324 napi_value productId = nullptr;
325 NAPI_CALL(env, napi_create_int32(env, usbDeviceId.GetProductId(), &productId));
326 NAPI_CALL(env, napi_set_named_property(env, value, "productId", productId));
327
328 return value;
329 }
330
SetUsbStorageDeviceAccessPolicy(napi_env env,napi_callback_info info)331 napi_value UsbManagerAddon::SetUsbStorageDeviceAccessPolicy(napi_env env, napi_callback_info info)
332 {
333 EDMLOGI("UsbManagerAddon::SetUsbStorageDeviceAccessPolicy called");
334 size_t argc = ARGS_SIZE_TWO;
335 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
336 napi_value thisArg = nullptr;
337 void *data = nullptr;
338 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
339 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
340 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
341 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
342 "parameter usbPolicy error");
343 OHOS::AppExecFwk::ElementName elementName;
344 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
345 "parameter admin parse error");
346 int32_t usbPolicy = EdmConstants::STORAGE_USB_POLICY_READ_WRITE;
347 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, usbPolicy, argv[ARR_INDEX_ONE]), "parameter type parse error");
348 bool existUsbPolicy = std::any_of(std::begin(USB_POLICY), std::end(USB_POLICY),
349 [&](int item) { return item == usbPolicy; });
350 ASSERT_AND_THROW_PARAM_ERROR(env, existUsbPolicy, "parameter usbPolicy value error");
351
352 auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
353 if (usbManagerProxy == nullptr) {
354 EDMLOGE("can not get usbManagerProxy");
355 return nullptr;
356 }
357 EDMLOGI("UsbManagerAddon::SetUsbStorageDeviceAccessPolicy: %{public}d", usbPolicy);
358 int32_t ret = usbManagerProxy->SetUsbStorageDeviceAccessPolicy(elementName, usbPolicy);
359 if (FAILED(ret)) {
360 napi_throw(env, CreateError(env, ret));
361 }
362 return nullptr;
363 }
364
GetUsbStorageDeviceAccessPolicy(napi_env env,napi_callback_info info)365 napi_value UsbManagerAddon::GetUsbStorageDeviceAccessPolicy(napi_env env, napi_callback_info info)
366 {
367 EDMLOGI("UsbManagerAddon::SetUsbStorageDeviceAccessPolicy called");
368 size_t argc = ARGS_SIZE_ONE;
369 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
370 napi_value thisArg = nullptr;
371 void *data = nullptr;
372 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
373 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
374 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
375 OHOS::AppExecFwk::ElementName elementName;
376 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
377 "parameter admin parse error");
378
379 int32_t usbPolicy = EdmConstants::STORAGE_USB_POLICY_READ_WRITE;
380 auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
381 if (usbManagerProxy == nullptr) {
382 EDMLOGE("can not get usbManagerProxy");
383 return nullptr;
384 }
385 int32_t ret = usbManagerProxy->GetUsbStorageDeviceAccessPolicy(elementName, usbPolicy);
386 EDMLOGI("UsbManagerAddon::GetUsbStorageDeviceAccessPolicy return: %{public}d", usbPolicy);
387 if (FAILED(ret)) {
388 napi_throw(env, CreateError(env, ret));
389 return nullptr;
390 }
391 napi_value result = nullptr;
392 napi_create_int32(env, usbPolicy, &result);
393 return result;
394 }
395
396 static napi_module g_usbManagerModule = {
397 .nm_version = 1,
398 .nm_flags = 0,
399 .nm_filename = nullptr,
400 .nm_register_func = UsbManagerAddon::Init,
401 .nm_modname = "enterprise.usbManager",
402 .nm_priv = ((void *)0),
403 .reserved = {0},
404 };
405
UsbManagerRegister()406 extern "C" __attribute__((constructor)) void UsbManagerRegister()
407 {
408 napi_module_register(&g_usbManagerModule);
409 }