1 /*
2  * Copyright (c) 2023-2024 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 
28     napi_value descriptorValue = nullptr;
29     NAPI_CALL(env, napi_create_object(env, &descriptorValue));
30     CreateDescriptorEnum(env, descriptorValue);
31 
32     napi_property_descriptor property[] = {
33         DECLARE_NAPI_PROPERTY("UsbPolicy", policyValue),
34         DECLARE_NAPI_PROPERTY("Descriptor", descriptorValue),
35         DECLARE_NAPI_FUNCTION("setUsbPolicy", SetUsbPolicy),
36         DECLARE_NAPI_FUNCTION("disableUsb", DisableUsb),
37         DECLARE_NAPI_FUNCTION("isUsbDisabled", IsUsbDisabled),
38         DECLARE_NAPI_FUNCTION("addAllowedUsbDevices", AddAllowedUsbDevices),
39         DECLARE_NAPI_FUNCTION("removeAllowedUsbDevices", RemoveAllowedUsbDevices),
40         DECLARE_NAPI_FUNCTION("getAllowedUsbDevices", GetAllowedUsbDevices),
41         DECLARE_NAPI_FUNCTION("setUsbStorageDeviceAccessPolicy", SetUsbStorageDeviceAccessPolicy),
42         DECLARE_NAPI_FUNCTION("getUsbStorageDeviceAccessPolicy", GetUsbStorageDeviceAccessPolicy),
43         DECLARE_NAPI_FUNCTION("addDisallowedUsbDevices", AddDisallowedUsbDevices),
44         DECLARE_NAPI_FUNCTION("removeDisallowedUsbDevices", RemoveDisallowedUsbDevices),
45         DECLARE_NAPI_FUNCTION("getDisallowedUsbDevices", GetDisallowedUsbDevices),
46     };
47     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
48     return exports;
49 }
50 
CreateUsbPolicyEnum(napi_env env,napi_value value)51 void UsbManagerAddon::CreateUsbPolicyEnum(napi_env env, napi_value value)
52 {
53     napi_value readWrite;
54     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_READ_WRITE, &readWrite));
55     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "READ_WRITE", readWrite));
56 
57     napi_value readOnly;
58     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_READ_ONLY, &readOnly));
59     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "READ_ONLY", readOnly));
60 
61     napi_value disabled;
62     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::STORAGE_USB_POLICY_DISABLED, &disabled));
63     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DISABLED", disabled));
64 }
65 
CreateDescriptorEnum(napi_env env,napi_value value)66 void UsbManagerAddon::CreateDescriptorEnum(napi_env env, napi_value value)
67 {
68     napi_value interfaceDescriptor;
69     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::USB_INTERFACE_DESCRIPTOR, &interfaceDescriptor));
70     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INTERFACE", interfaceDescriptor));
71 
72     napi_value deviceDescriptor;
73     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, EdmConstants::USB_DEVICE_DESCRIPTOR, &deviceDescriptor));
74     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DEVICE", deviceDescriptor));
75 }
76 
SetUsbPolicy(napi_env env,napi_callback_info info)77 napi_value UsbManagerAddon::SetUsbPolicy(napi_env env, napi_callback_info info)
78 {
79     EDMLOGI("UsbManagerAddon::SetUsbPolicy called");
80     size_t argc = ARGS_SIZE_THREE;
81     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
82     napi_value thisArg = nullptr;
83     void *data = nullptr;
84     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
85     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
86     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
87     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "type admin error");
88     bool usbPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_number);
89     ASSERT_AND_THROW_PARAM_ERROR(env, usbPolicy, "type usbPolicy error");
90     if (argc > ARGS_SIZE_TWO) {
91         bool hasCallback = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
92         ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "type callback error");
93     }
94 
95     auto asyncCallbackInfo = new (std::nothrow) AsyncSetUsbPolicyCallbackInfo();
96     if (asyncCallbackInfo == nullptr) {
97         return nullptr;
98     }
99     std::unique_ptr<AsyncSetUsbPolicyCallbackInfo> callbackPtr{asyncCallbackInfo};
100     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
101         "element name param error");
102     EDMLOGD(
103         "SetUsbPolicy: asyncCallbackInfo->elementName.bundlename %{public}s, "
104         "asyncCallbackInfo->abilityname:%{public}s",
105         asyncCallbackInfo->elementName.GetBundleName().c_str(),
106         asyncCallbackInfo->elementName.GetAbilityName().c_str());
107     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->policy, argv[ARR_INDEX_ONE]),
108         "policy param error");
109     bool existUsbPolicy = std::any_of(std::begin(USB_POLICY), std::end(USB_POLICY),
110         [&](int item) { return item == asyncCallbackInfo->policy; });
111     ASSERT_AND_THROW_PARAM_ERROR(env, existUsbPolicy, "usb policy value error");
112     if (argc > ARGS_SIZE_TWO) {
113         EDMLOGD("NAPI_SetUsbPolicy argc == ARGS_SIZE_THREE");
114         NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
115     }
116     napi_value asyncWorkReturn =
117         HandleAsyncWork(env, asyncCallbackInfo, "SetUsbPolicy", NativeSetUsbPolicy, NativeVoidCallbackComplete);
118     callbackPtr.release();
119     return asyncWorkReturn;
120 }
121 
NativeSetUsbPolicy(napi_env env,void * data)122 void UsbManagerAddon::NativeSetUsbPolicy(napi_env env, void *data)
123 {
124     EDMLOGI("NAPI_NativeSetUsbPolicy called");
125     if (data == nullptr) {
126         EDMLOGE("data is nullptr");
127         return;
128     }
129     AsyncSetUsbPolicyCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetUsbPolicyCallbackInfo *>(data);
130     switch (asyncCallbackInfo->policy) {
131         case EdmConstants::STORAGE_USB_POLICY_READ_WRITE:
132             asyncCallbackInfo->ret =
133                 UsbManagerProxy::GetUsbManagerProxy()->SetUsbReadOnly(asyncCallbackInfo->elementName, false);
134             break;
135         case EdmConstants::STORAGE_USB_POLICY_READ_ONLY:
136             asyncCallbackInfo->ret =
137                 UsbManagerProxy::GetUsbManagerProxy()->SetUsbReadOnly(asyncCallbackInfo->elementName, true);
138             break;
139         default:
140             asyncCallbackInfo->ret = EdmReturnErrCode::PARAM_ERROR;
141             break;
142     }
143 }
144 
DisableUsb(napi_env env,napi_callback_info info)145 napi_value UsbManagerAddon::DisableUsb(napi_env env, napi_callback_info info)
146 {
147     EDMLOGI("UsbManagerAddon::DisableUsb called");
148     size_t argc = ARGS_SIZE_TWO;
149     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
150     napi_value thisArg = nullptr;
151     void *data = nullptr;
152     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
153     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
154     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
155     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean),
156         "parameter disallow error");
157 
158     OHOS::AppExecFwk::ElementName elementName;
159     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
160         "parameter admin parse error");
161     bool disable = false;
162     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disable, argv[ARR_INDEX_ONE]), "parameter disallow parse error");
163 
164     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
165     if (usbManagerProxy == nullptr) {
166         EDMLOGE("can not get usbManagerProxy");
167         return nullptr;
168     }
169     EDMLOGI("UsbManagerAddon::DisableUsb: %{public}d", disable);
170     int32_t ret = usbManagerProxy->DisableUsb(elementName, disable);
171     if (FAILED(ret)) {
172         napi_throw(env, CreateError(env, ret));
173     }
174     return nullptr;
175 }
176 
IsUsbDisabled(napi_env env,napi_callback_info info)177 napi_value UsbManagerAddon::IsUsbDisabled(napi_env env, napi_callback_info info)
178 {
179     EDMLOGI("UsbManagerAddon::IsUsbDisabled called");
180     size_t argc = ARGS_SIZE_ONE;
181     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
182     napi_value thisArg = nullptr;
183     void *data = nullptr;
184     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
185     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
186     bool hasAdmin = false;
187     OHOS::AppExecFwk::ElementName elementName;
188     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
189         "param admin need be null or want");
190     bool isDisabled = false;
191     int32_t ret = ERR_OK;
192     if (hasAdmin) {
193         ret = UsbManagerProxy::GetUsbManagerProxy()->IsUsbDisabled(&elementName, isDisabled);
194     } else {
195         ret = UsbManagerProxy::GetUsbManagerProxy()->IsUsbDisabled(nullptr, isDisabled);
196     }
197     EDMLOGI("UsbManagerAddon::IsUsbDisabled return: %{public}d", isDisabled);
198     if (FAILED(ret)) {
199         napi_throw(env, CreateError(env, ret));
200         return nullptr;
201     }
202     napi_value result = nullptr;
203     NAPI_CALL(env, napi_get_boolean(env, isDisabled, &result));
204     return result;
205 }
206 
AddAllowedUsbDevices(napi_env env,napi_callback_info info)207 napi_value UsbManagerAddon::AddAllowedUsbDevices(napi_env env, napi_callback_info info)
208 {
209     EDMLOGI("UsbManagerAddon::AddAllowedUsbDevices called");
210     return AddOrRemoveAllowedUsbDevices(env, info, true);
211 }
212 
RemoveAllowedUsbDevices(napi_env env,napi_callback_info info)213 napi_value UsbManagerAddon::RemoveAllowedUsbDevices(napi_env env, napi_callback_info info)
214 {
215     EDMLOGI("UsbManagerAddon::RemoveAllowedUsbDevices called");
216     return AddOrRemoveAllowedUsbDevices(env, info, false);
217 }
218 
AddOrRemoveAllowedUsbDevices(napi_env env,napi_callback_info info,bool isAdd)219 napi_value UsbManagerAddon::AddOrRemoveAllowedUsbDevices(napi_env env, napi_callback_info info, bool isAdd)
220 {
221     size_t argc = ARGS_SIZE_TWO;
222     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
223     napi_value thisArg = nullptr;
224     void *data = nullptr;
225     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
226     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
227     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
228     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
229         "parameter usbDeviceIds error");
230     OHOS::AppExecFwk::ElementName elementName;
231     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
232         "parameter admin parse error");
233     std::vector<UsbDeviceId> usbDeviceIds;
234     ASSERT_AND_THROW_PARAM_ERROR(env, ParseUsbDevicesArray(env, usbDeviceIds, argv[ARR_INDEX_ONE]),
235         "parameter usbDeviceIds error");
236 
237     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
238     if (usbManagerProxy == nullptr) {
239         EDMLOGE("can not get usbManagerProxy");
240         return nullptr;
241     }
242     int32_t ret = ERR_OK;
243     if (isAdd) {
244         ret = usbManagerProxy->AddAllowedUsbDevices(elementName, usbDeviceIds);
245     } else {
246         ret = usbManagerProxy->RemoveAllowedUsbDevices(elementName, usbDeviceIds);
247     }
248     if (FAILED(ret)) {
249         napi_throw(env, CreateError(env, ret));
250     }
251     return nullptr;
252 }
253 
ParseUsbDevicesArray(napi_env env,std::vector<UsbDeviceId> & usbDeviceIds,napi_value object)254 bool UsbManagerAddon::ParseUsbDevicesArray(napi_env env, std::vector<UsbDeviceId> &usbDeviceIds, napi_value object)
255 {
256     bool isArray = false;
257     napi_is_array(env, object, &isArray);
258     if (!isArray) {
259         return false;
260     }
261     uint32_t arrayLength = 0;
262     napi_get_array_length(env, object, &arrayLength);
263     for (uint32_t i = 0; i < arrayLength; i++) {
264         napi_value value = nullptr;
265         napi_get_element(env, object, i, &value);
266         napi_valuetype valueType = napi_undefined;
267         napi_typeof(env, value, &valueType);
268         if (valueType != napi_object) {
269             usbDeviceIds.clear();
270             return false;
271         }
272         UsbDeviceId usbDeviceId;
273         if (!GetUsbDeviceIdFromNAPI(env, value, usbDeviceId)) {
274             usbDeviceIds.clear();
275             return false;
276         }
277         usbDeviceIds.push_back(usbDeviceId);
278     }
279     return true;
280 }
281 
GetUsbDeviceIdFromNAPI(napi_env env,napi_value value,UsbDeviceId & usbDeviceId)282 bool UsbManagerAddon::GetUsbDeviceIdFromNAPI(napi_env env, napi_value value, UsbDeviceId &usbDeviceId)
283 {
284     int32_t vendorId = 0;
285     if (!JsObjectToInt(env, value, "vendorId", true, vendorId)) {
286         EDMLOGE("Add/RemoveAllowedUsbDevices vendorId parse error!");
287         return false;
288     }
289     int32_t productId = 0;
290     if (!JsObjectToInt(env, value, "productId", true, productId)) {
291         EDMLOGE("Add/RemoveAllowedUsbDevices productId parse error!");
292         return false;
293     }
294     usbDeviceId.SetVendorId(vendorId);
295     usbDeviceId.SetProductId(productId);
296     EDMLOGD("GetUsbDeviceIdFromNAPI vendorId: %{public}d, productId: %{public}d", vendorId, productId);
297     return true;
298 }
299 
GetAllowedUsbDevices(napi_env env,napi_callback_info info)300 napi_value UsbManagerAddon::GetAllowedUsbDevices(napi_env env, napi_callback_info info)
301 {
302     EDMLOGI("UsbManagerAddon::GetAllowedUsbDevices called");
303     size_t argc = ARGS_SIZE_ONE;
304     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
305     napi_value thisArg = nullptr;
306     void *data = nullptr;
307     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
308     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
309     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
310     OHOS::AppExecFwk::ElementName elementName;
311     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
312         "parameter admin parse error");
313 
314     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
315     if (usbManagerProxy == nullptr) {
316         EDMLOGE("can not get usbManagerProxy");
317         return nullptr;
318     }
319     std::vector<UsbDeviceId> usbDeviceIds;
320     int32_t ret = usbManagerProxy->GetAllowedUsbDevices(elementName, usbDeviceIds);
321     EDMLOGI("UsbManagerAddon::GetAllowedUsbDevices usbDeviceIds return size: %{public}zu", usbDeviceIds.size());
322     if (FAILED(ret)) {
323         napi_throw(env, CreateError(env, ret));
324         return nullptr;
325     }
326     napi_value jsList = nullptr;
327     NAPI_CALL(env, napi_create_array_with_length(env, usbDeviceIds.size(), &jsList));
328     for (size_t i = 0; i < usbDeviceIds.size(); i++) {
329         napi_value item = UsbDeviceIdToJsObj(env, usbDeviceIds[i]);
330         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
331     }
332     return jsList;
333 }
334 
UsbDeviceIdToJsObj(napi_env env,const UsbDeviceId & usbDeviceId)335 napi_value UsbManagerAddon::UsbDeviceIdToJsObj(napi_env env, const UsbDeviceId &usbDeviceId)
336 {
337     napi_value value = nullptr;
338     NAPI_CALL(env, napi_create_object(env, &value));
339 
340     napi_value vendorId = nullptr;
341     NAPI_CALL(env, napi_create_int32(env, usbDeviceId.GetVendorId(), &vendorId));
342     NAPI_CALL(env, napi_set_named_property(env, value, "vendorId", vendorId));
343 
344     napi_value productId = nullptr;
345     NAPI_CALL(env, napi_create_int32(env, usbDeviceId.GetProductId(), &productId));
346     NAPI_CALL(env, napi_set_named_property(env, value, "productId", productId));
347 
348     return value;
349 }
350 
SetUsbStorageDeviceAccessPolicy(napi_env env,napi_callback_info info)351 napi_value UsbManagerAddon::SetUsbStorageDeviceAccessPolicy(napi_env env, napi_callback_info info)
352 {
353     EDMLOGI("UsbManagerAddon::SetUsbStorageDeviceAccessPolicy called");
354     size_t argc = ARGS_SIZE_TWO;
355     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
356     napi_value thisArg = nullptr;
357     void *data = nullptr;
358     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
359     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
360     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
361     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
362         "parameter usbPolicy error");
363     OHOS::AppExecFwk::ElementName elementName;
364     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
365         "parameter admin parse error");
366     int32_t usbPolicy = EdmConstants::STORAGE_USB_POLICY_READ_WRITE;
367     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, usbPolicy, argv[ARR_INDEX_ONE]), "parameter type parse error");
368     bool existUsbPolicy = std::any_of(std::begin(USB_POLICY), std::end(USB_POLICY),
369         [&](int item) { return item == usbPolicy; });
370     ASSERT_AND_THROW_PARAM_ERROR(env, existUsbPolicy, "parameter usbPolicy value error");
371 
372     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
373     if (usbManagerProxy == nullptr) {
374         EDMLOGE("can not get usbManagerProxy");
375         return nullptr;
376     }
377     EDMLOGI("UsbManagerAddon::SetUsbStorageDeviceAccessPolicy: %{public}d", usbPolicy);
378     int32_t ret = usbManagerProxy->SetUsbStorageDeviceAccessPolicy(elementName, usbPolicy);
379     if (FAILED(ret)) {
380         napi_throw(env, CreateError(env, ret));
381     }
382     return nullptr;
383 }
384 
GetUsbStorageDeviceAccessPolicy(napi_env env,napi_callback_info info)385 napi_value UsbManagerAddon::GetUsbStorageDeviceAccessPolicy(napi_env env, napi_callback_info info)
386 {
387     EDMLOGI("UsbManagerAddon::GetUsbStorageDeviceAccessPolicy called");
388     size_t argc = ARGS_SIZE_ONE;
389     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
390     napi_value thisArg = nullptr;
391     void *data = nullptr;
392     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
393     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
394     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
395     OHOS::AppExecFwk::ElementName elementName;
396     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
397         "parameter admin parse error");
398 
399     int32_t usbPolicy = EdmConstants::STORAGE_USB_POLICY_READ_WRITE;
400     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
401     if (usbManagerProxy == nullptr) {
402         EDMLOGE("can not get usbManagerProxy");
403         return nullptr;
404     }
405     int32_t ret = usbManagerProxy->GetUsbStorageDeviceAccessPolicy(elementName, usbPolicy);
406     EDMLOGI("UsbManagerAddon::GetUsbStorageDeviceAccessPolicy return: %{public}d", usbPolicy);
407     if (FAILED(ret)) {
408         napi_throw(env, CreateError(env, ret));
409         return nullptr;
410     }
411     napi_value result = nullptr;
412     NAPI_CALL(env, napi_create_int32(env, usbPolicy, &result));
413     return result;
414 }
415 
AddDisallowedUsbDevices(napi_env env,napi_callback_info info)416 napi_value UsbManagerAddon::AddDisallowedUsbDevices(napi_env env, napi_callback_info info)
417 {
418     EDMLOGI("UsbManagerAddon::AddDisallowedUsbDevices called");
419     return AddOrRemoveDisallowedUsbDevices(env, info, true);
420 }
421 
RemoveDisallowedUsbDevices(napi_env env,napi_callback_info info)422 napi_value UsbManagerAddon::RemoveDisallowedUsbDevices(napi_env env, napi_callback_info info)
423 {
424     EDMLOGI("UsbManagerAddon::RemoveDisallowedUsbDevices called");
425     return AddOrRemoveDisallowedUsbDevices(env, info, false);
426 }
427 
AddOrRemoveDisallowedUsbDevices(napi_env env,napi_callback_info info,bool isAdd)428 napi_value UsbManagerAddon::AddOrRemoveDisallowedUsbDevices(napi_env env, napi_callback_info info, bool isAdd)
429 {
430     size_t argc = ARGS_SIZE_TWO;
431     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
432     napi_value thisArg = nullptr;
433     void *data = nullptr;
434     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
435     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
436     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
437     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
438         "parameter usbDevices error");
439     OHOS::AppExecFwk::ElementName elementName;
440     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
441         "parameter admin parse error");
442     std::vector<USB::UsbDeviceType> usbDeviceTypes;
443     ASSERT_AND_THROW_PARAM_ERROR(env, ParseUsbDeviceTypesArray(env, usbDeviceTypes, argv[ARR_INDEX_ONE]),
444         "parameter usbDevices error");
445 
446     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
447     if (usbManagerProxy == nullptr) {
448         EDMLOGE("can not get usbManagerProxy");
449         return nullptr;
450     }
451     int32_t ret = usbManagerProxy->AddOrRemoveDisallowedUsbDevices(elementName, usbDeviceTypes, isAdd);
452     if (FAILED(ret)) {
453         napi_throw(env, CreateError(env, ret));
454     }
455     return nullptr;
456 }
457 
GetDisallowedUsbDevices(napi_env env,napi_callback_info info)458 napi_value UsbManagerAddon::GetDisallowedUsbDevices(napi_env env, napi_callback_info info)
459 {
460     EDMLOGI("UsbManagerAddon::GetDisallowedUsbDevices called");
461     size_t argc = ARGS_SIZE_ONE;
462     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
463     napi_value thisArg = nullptr;
464     void *data = nullptr;
465     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
466     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
467     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
468     OHOS::AppExecFwk::ElementName elementName;
469     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
470         "parameter admin parse error");
471 
472     auto usbManagerProxy = UsbManagerProxy::GetUsbManagerProxy();
473     if (usbManagerProxy == nullptr) {
474         EDMLOGE("can not get usbManagerProxy");
475         return nullptr;
476     }
477     std::vector<USB::UsbDeviceType> usbDeviceTypes;
478     int32_t ret = usbManagerProxy->GetDisallowedUsbDevices(elementName, usbDeviceTypes);
479     EDMLOGI("UsbManagerAddon::GetDisallowedUsbDevices usbDeviceTypes return size: %{public}zu", usbDeviceTypes.size());
480     if (FAILED(ret)) {
481         napi_throw(env, CreateError(env, ret));
482         return nullptr;
483     }
484     napi_value jsList = nullptr;
485     NAPI_CALL(env, napi_create_array_with_length(env, usbDeviceTypes.size(), &jsList));
486     for (size_t i = 0; i < usbDeviceTypes.size(); i++) {
487         napi_value item = UsbDeviceTypeToJsObj(env, usbDeviceTypes[i]);
488         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
489     }
490     return jsList;
491 }
492 
493 #ifdef USB_EDM_ENABLE
ParseUsbDeviceTypesArray(napi_env env,std::vector<USB::UsbDeviceType> & usbDeviceTypes,napi_value object)494 bool UsbManagerAddon::ParseUsbDeviceTypesArray(napi_env env, std::vector<USB::UsbDeviceType> &usbDeviceTypes,
495     napi_value object)
496 {
497     bool isArray = false;
498     napi_is_array(env, object, &isArray);
499     if (!isArray) {
500         return false;
501     }
502     uint32_t arrayLength = 0;
503     napi_get_array_length(env, object, &arrayLength);
504     if (arrayLength > EdmConstants::DISALLOWED_USB_DEVICES_TYPES_MAX_SIZE) {
505         EDMLOGE("ParseUsbDeviceTypesArray: arrayLength=[%{public}u] is too large", arrayLength);
506         return false;
507     }
508     for (uint32_t i = 0; i < arrayLength; i++) {
509         napi_value value = nullptr;
510         napi_get_element(env, object, i, &value);
511         napi_valuetype valueType = napi_undefined;
512         napi_typeof(env, value, &valueType);
513         if (valueType != napi_object) {
514             usbDeviceTypes.clear();
515             return false;
516         }
517         USB::UsbDeviceType usbDeviceType;
518         if (!GetUsbDeviceTypeFromNAPI(env, value, usbDeviceType)) {
519             usbDeviceTypes.clear();
520             return false;
521         }
522         usbDeviceTypes.push_back(usbDeviceType);
523     }
524     return true;
525 }
526 
GetUsbDeviceTypeFromNAPI(napi_env env,napi_value value,USB::UsbDeviceType & usbDeviceType)527 bool UsbManagerAddon::GetUsbDeviceTypeFromNAPI(napi_env env, napi_value value, USB::UsbDeviceType &usbDeviceType)
528 {
529     int32_t baseClass = 0;
530     if (!JsObjectToInt(env, value, "baseClass", true, baseClass)) {
531         EDMLOGE("GetUsbDeviceTypeFromNAPI baseClass parse error!");
532         return false;
533     }
534     int32_t subClass = 0;
535     if (!JsObjectToInt(env, value, "subClass", true, subClass)) {
536         EDMLOGE("GetUsbDeviceTypeFromNAPI subClass parse error!");
537         return false;
538     }
539     int32_t protocol = 0;
540     if (!JsObjectToInt(env, value, "protocol", true, protocol)) {
541         EDMLOGE("GetUsbDeviceTypeFromNAPI protocol parse error!");
542         return false;
543     }
544     int32_t descriptor = -1;
545     if (!JsObjectToInt(env, value, "descriptor", true, descriptor)) {
546         EDMLOGE("GetUsbDeviceTypeFromNAPI descriptor parse error!");
547         return false;
548     }
549     if (!std::any_of(std::begin(DESCRIPTOR), std::end(DESCRIPTOR), [&](int item) { return item == descriptor; })) {
550         EDMLOGE("GetUsbDeviceTypeFromNAPI descriptor value error!");
551         return false;
552     }
553     usbDeviceType.baseClass = baseClass;
554     usbDeviceType.subClass = subClass;
555     usbDeviceType.protocol = protocol;
556     usbDeviceType.isDeviceType = descriptor;
557     EDMLOGD("GetUsbDeviceTypeFromNAPI baseClass: %{public}d, subClass: %{public}d, protocol: %{public}d, "
558         "isDeviceType: %{public}d", baseClass, subClass, protocol, descriptor);
559     return true;
560 }
561 
UsbDeviceTypeToJsObj(napi_env env,const USB::UsbDeviceType & usbDeviceType)562 napi_value UsbManagerAddon::UsbDeviceTypeToJsObj(napi_env env, const USB::UsbDeviceType &usbDeviceType)
563 {
564     napi_value value = nullptr;
565     NAPI_CALL(env, napi_create_object(env, &value));
566 
567     napi_value baseClass = nullptr;
568     NAPI_CALL(env, napi_create_int32(env, usbDeviceType.baseClass, &baseClass));
569     NAPI_CALL(env, napi_set_named_property(env, value, "baseClass", baseClass));
570 
571     napi_value subClass = nullptr;
572     NAPI_CALL(env, napi_create_int32(env, usbDeviceType.subClass, &subClass));
573     NAPI_CALL(env, napi_set_named_property(env, value, "subClass", subClass));
574 
575     napi_value protocol = nullptr;
576     NAPI_CALL(env, napi_create_int32(env, usbDeviceType.protocol, &protocol));
577     NAPI_CALL(env, napi_set_named_property(env, value, "protocol", protocol));
578 
579     napi_value descriptor = nullptr;
580     NAPI_CALL(env, napi_create_int32(env, usbDeviceType.isDeviceType, &descriptor));
581     NAPI_CALL(env, napi_set_named_property(env, value, "descriptor", descriptor));
582     return value;
583 }
584 #endif
585 
586 static napi_module g_usbManagerModule = {
587     .nm_version = 1,
588     .nm_flags = 0,
589     .nm_filename = nullptr,
590     .nm_register_func = UsbManagerAddon::Init,
591     .nm_modname = "enterprise.usbManager",
592     .nm_priv = ((void *)0),
593     .reserved = {0},
594 };
595 
UsbManagerRegister()596 extern "C" __attribute__((constructor)) void UsbManagerRegister()
597 {
598     napi_module_register(&g_usbManagerModule);
599 }