1 /*
2 * Copyright (c) 2021-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 <iostream>
16 #include <sstream>
17 #include <iomanip>
18 #include <map>
19 #include <string>
20 #include <set>
21 #include <thread>
22 #include <ipc_skeleton.h>
23 #include <codecvt>
24
25 #include "usb_host_manager.h"
26 #include "common_event_data.h"
27 #include "common_event_manager.h"
28 #include "common_event_support.h"
29 #include "hilog_wrapper.h"
30 #include "hisysevent.h"
31 #include "cJSON.h"
32 #include "usb_serial_reader.h"
33 #include "usb_device.h"
34 #include "usb_config.h"
35 #include "usb_interface.h"
36 #include "usb_errors.h"
37 #include "if_system_ability_manager.h"
38 #include "iservice_registry.h"
39 #include "parameters.h"
40 #include "usbd_bulkcallback_impl.h"
41 #include "usb_descriptor_parser.h"
42 #include "usbd_transfer_callback_impl.h"
43 #include "usb_napi_errors.h"
44 #include "accesstoken_kit.h"
45
46 using namespace OHOS::AAFwk;
47 using namespace OHOS::EventFwk;
48 using namespace OHOS::HiviewDFX;
49 using namespace OHOS::HDI::Usb::V1_2;
50
51 namespace OHOS {
52 namespace USB {
53 constexpr int32_t CLASS_PRINT_LENGTH = 2;
54 constexpr int32_t USAGE_IN_INTERFACE_CLASS = 0;
55 constexpr uint8_t DES_USAGE_IN_INTERFACE = 0x02;
56 constexpr int32_t BCD_HEX_DIGITS = 4;
57 constexpr int LAST_FIVE = 5;
58 std::map<int32_t, DeviceClassUsage> deviceUsageMap = {
59 {0x00, {DeviceClassUsage(2, "Use class information in the Interface Descriptors")}},
60 {0x01, {DeviceClassUsage(2, "Audio")}},
61 {0x02, {DeviceClassUsage(3, "Communications and CDC Control")}},
62 {0x03, {DeviceClassUsage(2, "HID(Human Interface Device)")}},
63 {0x05, {DeviceClassUsage(2, "Physical")}},
64 {0x06, {DeviceClassUsage(2, "Image")}},
65 {0x07, {DeviceClassUsage(2, "Printer")}},
66 {0x08, {DeviceClassUsage(2, "Mass Storage")}},
67 {0x09, {DeviceClassUsage(1, "Hub")}},
68 {0x0a, {DeviceClassUsage(2, "CDC-Data")}},
69 {0x0b, {DeviceClassUsage(2, "Smart Card")}},
70 {0x0d, {DeviceClassUsage(2, "Content Security")}},
71 {0x0e, {DeviceClassUsage(2, "Video")}},
72 {0x0f, {DeviceClassUsage(2, "Personal Healthcare")}},
73 {0x10, {DeviceClassUsage(2, "Audio/Video Device")}},
74 {0x11, {DeviceClassUsage(1, "Billboard Device Class")}},
75 {0x12, {DeviceClassUsage(2, "USB Type-C Bridge Class")}}
76 };
77
78 std::map<UsbDeviceType, std::string> interfaceUsageMap = {
79 {{UsbDeviceType(0x03, 0x01, 0x01, 0)}, "KeyBoard"},
80 {{UsbDeviceType(0x03, 0x01, 0x02, 0)}, "Mouse/Table/Touch screen"},
81 };
82 constexpr uint32_t CURSOR_INIT = 18;
83 constexpr int32_t DESCRIPTOR_TYPE_STRING = 3;
84 constexpr int32_t DESCRIPTOR_VALUE_START_OFFSET = 2;
85 constexpr int32_t HALF = 2;
86 constexpr uint32_t MANAGE_INTERFACE_INTERVAL = 100;
87 constexpr uint32_t EDM_SA_MAX_TIME_OUT = 5000;
88 constexpr uint32_t EDM_SYSTEM_ABILITY_ID = 1601;
89 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
90 constexpr uint32_t WITHOUT_USERID = 0;
91 constexpr uint32_t WITHOUT_ADMIN = 1;
92 constexpr uint32_t EMD_MASK_CODE = 20;
93 constexpr uint32_t DISABLE_USB = 1043;
94 constexpr uint32_t ALLOWED_USB_DEVICES = 1044;
95 constexpr uint32_t USB_STORAGE_DEVICE_ACCESS_POLICY = 1026;
96 constexpr uint32_t USB_DEVICE_ACCESS_POLICY = 1059;
97 constexpr int32_t WHITELIST_POLICY_MAX_DEVICES = 1000;
98 constexpr uint32_t EDM_SA_TIME_OUT_CODE = 9200007;
99 constexpr int32_t BASECLASS_INDEX = 0;
100 constexpr int32_t SUBCLASS_INDEX = 1;
101 constexpr int32_t PROTOCAL_INDEX = 2;
102 constexpr int32_t STORAGE_BASE_CLASS = 8;
103 constexpr int32_t GET_EDM_STORAGE_DISABLE_TYPE = 2;
104 constexpr int32_t RANDOM_VALUE_INDICATE = -1;
105 constexpr int32_t BASE_CLASS_HUB = 0x09;
106 constexpr int32_t RETRY_NUM = 6;
107 constexpr uint32_t RETRY_INTERVAL = 50;
108
109 #ifdef USB_MANAGER_PASS_THROUGH
110 const std::string SERVICE_NAME = "usb_host_interface_service";
111 #endif // USB_MANAGER_PASS_THROUGH
UsbHostManager(SystemAbility * systemAbility)112 UsbHostManager::UsbHostManager(SystemAbility *systemAbility)
113 {
114 systemAbility_ = systemAbility;
115 usbRightManager_ = std::make_shared<UsbRightManager>();
116 #ifndef USB_MANAGER_PASS_THROUGH
117 usbd_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
118 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d usbd_ == nullptr: %{public}d",
119 __func__, __LINE__, usbd_ == nullptr);
120 #endif // USB_MANAGER_PASS_THROUGH
121 }
122
~UsbHostManager()123 UsbHostManager::~UsbHostManager()
124 {
125 for (auto &pair : devices_) {
126 delete pair.second;
127 }
128 devices_.clear();
129 }
130
131 #ifdef USB_MANAGER_PASS_THROUGH
InitUsbHostInterface()132 bool UsbHostManager::InitUsbHostInterface()
133 {
134 USB_HILOGI(MODULE_USB_SERVICE, "InitUsbHostInterface in");
135 usbHostInterface_ = HDI::Usb::V2_0::IUsbHostInterface::Get(SERVICE_NAME, true);
136 if (usbHostInterface_ == nullptr) {
137 USB_HILOGE(MODULE_USB_SERVICE, "InitUsbHostInterface get usbHostInterface_ is nullptr");
138 return false;
139 }
140 usbManagerSubscriber_ = new (std::nothrow) UsbManagerSubscriber();
141 if (usbManagerSubscriber_ == nullptr) {
142 USB_HILOGE(MODULE_USB_SERVICE, "usbManagerSubscriber_ is nullptr");
143 return false;
144 }
145 ErrCode ret = usbHostInterface_->BindUsbdHostSubscriber(usbManagerSubscriber_);
146 USB_HILOGI(MODULE_USB_SERVICE, "entry InitUsbHostInterface ret: %{public}d", ret);
147 return SUCCEEDED(ret);
148 }
149
Stop()150 void UsbHostManager::Stop()
151 {
152 if (usbHostInterface_ == nullptr) {
153 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbHostInterface_ is nullptr");
154 return;
155 }
156 usbHostInterface_->UnbindUsbdHostSubscriber(usbManagerSubscriber_);
157 Memory::MemMgrClient::GetInstance().NotifyProcessStatus(getpid(), 1, 0, USB_SYSTEM_ABILITY_ID);
158 }
159
BindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> & subscriber)160 int32_t UsbHostManager::BindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> &subscriber)
161 {
162 if (usbHostInterface_ == nullptr) {
163 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BindUsbdSubscriber usbHostInterface_ is nullptr");
164 return UEC_SERVICE_INVALID_VALUE;
165 }
166 return usbHostInterface_->BindUsbdHostSubscriber(subscriber);
167 }
168
UnbindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> & subscriber)169 int32_t UsbHostManager::UnbindUsbdSubscriber(const sptr<HDI::Usb::V2_0::IUsbdSubscriber> &subscriber)
170 {
171 if (usbHostInterface_ == nullptr) {
172 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UnbindUsbdSubscriber usbHostInterface_ is nullptr");
173 return UEC_SERVICE_INVALID_VALUE;
174 }
175 return usbHostInterface_->UnbindUsbdHostSubscriber(subscriber);
176 }
177 #endif // USB_MANAGER_PASS_THROUGH
178
179 // LCOV_EXCL_START
OnRemoteDied(const wptr<IRemoteObject> & object)180 void UsbHostManager::UsbSubmitTransferDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
181 {
182 USB_HILOGI(MODULE_USBD, "UsbHostManager UsbSubmitTransferDeathRecipient enter");
183 int32_t ret = service_->UsbCancelTransfer(devInfo_, endpoint_);
184 if (ret == UEC_OK) {
185 USB_HILOGI(MODULE_USBD, "UsbHostManager OnRemoteDied Close.");
186 service_->Close(devInfo_.busNum, devInfo_.devAddr);
187 }
188 }
189 // LCOV_EXCL_STOP
190
ExecuteStrategy(UsbDevice * devInfo)191 void UsbHostManager::ExecuteStrategy(UsbDevice *devInfo)
192 {
193 USB_HILOGI(MODULE_USB_SERVICE, "UsbHostManager::ExecuteStrategy start");
194 if (devInfo == nullptr || devInfo->GetClass() == BASE_CLASS_HUB) {
195 return;
196 }
197 if (!IsEdmEnabled()) {
198 USB_HILOGE(MODULE_USB_SERVICE, "edm is not activate, skip");
199 return;
200 }
201 bool isGlobalDisabled = false;
202 std::vector<UsbDeviceType> disableType{};
203 std::vector<UsbDeviceId> trustUsbDeviceIds{};
204
205 int32_t ret = GetUsbPolicy(isGlobalDisabled, disableType, trustUsbDeviceIds);
206 if (ret == UEC_SERVICE_EDM_SA_TIME_OUT_FAILED || ret == UEC_SERVICE_PREPARE_EDM_SA_FAILED) {
207 USB_HILOGE(MODULE_USB_SERVICE, "EDM sa time out or prepare failed, ret = %{public}d", ret);
208 return;
209 }
210
211 if (isGlobalDisabled) {
212 ret = ManageGlobalInterfaceImpl(isGlobalDisabled);
213 if (ret != UEC_OK) {
214 USB_HILOGE(MODULE_USB_SERVICE, "ManageGlobalInterface failed");
215 }
216 return;
217 }
218
219 if (!disableType.empty()) {
220 ret = ExecuteManageInterfaceType(disableType, true);
221 if (ret != UEC_OK) {
222 USB_HILOGE(MODULE_USB_SERVICE, "ExecuteManageInterfaceType failed");
223 }
224 return;
225 }
226
227 if (trustUsbDeviceIds.empty()) {
228 USB_HILOGI(MODULE_USB_SERVICE, "trustUsbDeviceIds is empty, no devices disable");
229 return;
230 }
231 ret = ExecuteManageDevicePolicy(trustUsbDeviceIds);
232 if (ret != UEC_OK) {
233 USB_HILOGE(MODULE_USB_SERVICE, "ExecuteManageDevicePolicy failed");
234 }
235 return;
236 }
237
OpenDevice(uint8_t busNum,uint8_t devAddr)238 int32_t UsbHostManager::OpenDevice(uint8_t busNum, uint8_t devAddr)
239 {
240 #ifdef USB_MANAGER_PASS_THROUGH
241 if (usbHostInterface_ == nullptr) {
242 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::OpenDevice usbHostInterface_ is nullptr");
243 return UEC_SERVICE_INVALID_VALUE;
244 }
245 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
246 return usbHostInterface_->OpenDevice(dev);
247 #else
248 const UsbDev dev = {busNum, devAddr};
249 if (usbd_ == nullptr) {
250 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
251 return UEC_SERVICE_INVALID_VALUE;
252 }
253 return usbd_->OpenDevice(dev);
254 #endif // USB_MANAGER_PASS_THROUGH
255 }
256
Close(uint8_t busNum,uint8_t devAddr)257 int32_t UsbHostManager::Close(uint8_t busNum, uint8_t devAddr)
258 {
259 #ifdef USB_MANAGER_PASS_THROUGH
260 if (usbHostInterface_ == nullptr) {
261 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::Close usbHostInterface_ is nullptr");
262 return UEC_SERVICE_INVALID_VALUE;
263 }
264 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
265 return usbHostInterface_->CloseDevice(dev);
266 #else
267 const UsbDev dev = {busNum, devAddr};
268 if (usbd_ == nullptr) {
269 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
270 return UEC_SERVICE_INVALID_VALUE;
271 }
272 return usbd_->CloseDevice(dev);
273 #endif // USB_MANAGER_PASS_THROUGH
274 }
275
ResetDevice(uint8_t busNum,uint8_t devAddr)276 int32_t UsbHostManager::ResetDevice(uint8_t busNum, uint8_t devAddr)
277 {
278 #ifdef USB_MANAGER_PASS_THROUGH
279 if (usbHostInterface_ == nullptr) {
280 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::ResetDevice usbHostInterface_ is nullptr");
281 return UEC_SERVICE_INVALID_VALUE;
282 }
283 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
284 return usbHostInterface_->ResetDevice(dev);
285 #else
286 const UsbDev dev = {busNum, devAddr};
287 if (usbd_ == nullptr) {
288 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
289 return UEC_SERVICE_INVALID_VALUE;
290 }
291 return usbd_->ResetDevice(dev);
292 #endif // USB_MANAGER_PASS_THROUGH
293 }
294
ClaimInterface(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,uint8_t force)295 int32_t UsbHostManager::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t force)
296 {
297 #ifdef USB_MANAGER_PASS_THROUGH
298 if (usbHostInterface_ == nullptr) {
299 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::ClaimInterface usbHostInterface_ is nullptr");
300 return UEC_SERVICE_INVALID_VALUE;
301 }
302 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
303 return usbHostInterface_->ClaimInterface(dev, interfaceid, force);
304 #else
305 const UsbDev dev = {busNum, devAddr};
306 if (usbd_ == nullptr) {
307 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
308 return UEC_SERVICE_INVALID_VALUE;
309 }
310 return usbd_->ClaimInterface(dev, interfaceid, force);
311 #endif // USB_MANAGER_PASS_THROUGH
312 }
313
SetInterface(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,uint8_t altIndex)314 int32_t UsbHostManager::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t altIndex)
315 {
316 #ifdef USB_MANAGER_PASS_THROUGH
317 if (usbHostInterface_ == nullptr) {
318 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::SetInterface usbHostInterface_ is nullptr");
319 return UEC_SERVICE_INVALID_VALUE;
320 }
321 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
322 return usbHostInterface_->SetInterface(dev, interfaceid, altIndex);
323 #else
324 const UsbDev dev = {busNum, devAddr};
325 if (usbd_ == nullptr) {
326 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
327 return UEC_SERVICE_INVALID_VALUE;
328 }
329 return usbd_->SetInterface(dev, interfaceid, altIndex);
330 #endif // USB_MANAGER_PASS_THROUGH
331 }
332
ReleaseInterface(uint8_t busNum,uint8_t devAddr,uint8_t interface)333 int32_t UsbHostManager::ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface)
334 {
335 #ifdef USB_MANAGER_PASS_THROUGH
336 if (usbHostInterface_ == nullptr) {
337 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::ReleaseInterface usbHostInterface_ is nullptr");
338 return UEC_SERVICE_INVALID_VALUE;
339 }
340 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
341 return usbHostInterface_->ReleaseInterface(dev, interface);
342 #else
343 const UsbDev dev = {busNum, devAddr};
344 if (usbd_ == nullptr) {
345 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
346 return UEC_SERVICE_INVALID_VALUE;
347 }
348 return usbd_->ReleaseInterface(dev, interface);
349 #endif // USB_MANAGER_PASS_THROUGH
350 }
351
SetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t configIndex)352 int32_t UsbHostManager::SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t configIndex)
353 {
354 #ifdef USB_MANAGER_PASS_THROUGH
355 if (usbHostInterface_ == nullptr) {
356 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::SetActiveConfig usbHostInterface_ is nullptr");
357 return UEC_SERVICE_INVALID_VALUE;
358 }
359 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
360 return usbHostInterface_->SetConfig(dev, configIndex);
361 #else
362 const UsbDev dev = {busNum, devAddr};
363 if (usbd_ == nullptr) {
364 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
365 return UEC_SERVICE_INVALID_VALUE;
366 }
367 return usbd_->SetConfig(dev, configIndex);
368 #endif // USB_MANAGER_PASS_THROUGH
369 }
370
ManageGlobalInterface(bool disable)371 int32_t UsbHostManager::ManageGlobalInterface(bool disable)
372 {
373 return ManageGlobalInterfaceImpl(disable);
374 }
375
ManageDevice(int32_t vendorId,int32_t productId,bool disable)376 int32_t UsbHostManager::ManageDevice(int32_t vendorId, int32_t productId, bool disable)
377 {
378 return ManageDeviceImpl(vendorId, productId, disable);
379 }
380
ManageInterfaceType(const std::vector<UsbDeviceType> & disableType,bool disable)381 int32_t UsbHostManager::ManageInterfaceType(const std::vector<UsbDeviceType> &disableType, bool disable)
382 {
383 return ExecuteManageInterfaceType(disableType, disable);
384 }
385
UsbAttachKernelDriver(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid)386 int32_t UsbHostManager::UsbAttachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid)
387 {
388 #ifdef USB_MANAGER_PASS_THROUGH
389 if (usbHostInterface_ == nullptr) {
390 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbAttachKernelDriver usbHostInterface_ is nullptr");
391 return UEC_SERVICE_INVALID_VALUE;
392 }
393 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
394 return usbHostInterface_->ManageInterface(dev, interfaceid, false);
395 #else
396 const UsbDev dev = {busNum, devAddr};
397 if (usbd_ == nullptr) {
398 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
399 return UEC_SERVICE_INVALID_VALUE;
400 }
401
402 return usbd_->ManageInterface(dev, interfaceid, false);
403 #endif // USB_MANAGER_PASS_THROUGH
404 }
405
UsbDetachKernelDriver(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid)406 int32_t UsbHostManager::UsbDetachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid)
407 {
408 #ifdef USB_MANAGER_PASS_THROUGH
409 if (usbHostInterface_ == nullptr) {
410 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbDetachKernelDriver usbHostInterface_ is nullptr");
411 return UEC_SERVICE_INVALID_VALUE;
412 }
413 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
414 return usbHostInterface_->ManageInterface(dev, interfaceid, true);
415 #else
416 const UsbDev dev = {busNum, devAddr};
417 if (usbd_ == nullptr) {
418 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
419 return UEC_SERVICE_INVALID_VALUE;
420 }
421
422 return usbd_->ManageInterface(dev, interfaceid, true);
423 #endif // USB_MANAGER_PASS_THROUGH
424 }
425
ClearHalt(uint8_t busNum,uint8_t devAddr,uint8_t interfaceId,uint8_t endpointId)426 int32_t UsbHostManager::ClearHalt(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId)
427 {
428 #ifdef USB_MANAGER_PASS_THROUGH
429 if (usbHostInterface_ == nullptr) {
430 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::ClearHalt usbHostInterface_ is nullptr");
431 return UEC_SERVICE_INVALID_VALUE;
432 }
433 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
434 const HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, endpointId};
435 return usbHostInterface_->ClearHalt(dev, pipe);
436 #else
437 const UsbDev dev = {busNum, devAddr};
438 const UsbPipe pipe = {interfaceId, endpointId};
439 if (usbd_ == nullptr) {
440 USB_HILOGE(MODULE_USB_SERVICE, "ClearHalt: usbd_ is nullptr");
441 return UEC_SERVICE_INVALID_VALUE;
442 }
443 return usbd_->ClearHalt(dev, pipe);
444 #endif // USB_MANAGER_PASS_THROUGH
445 }
446
GetDevices(std::vector<UsbDevice> & deviceList)447 int32_t UsbHostManager::GetDevices(std::vector<UsbDevice> &deviceList)
448 {
449 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices_.size());
450 bool isSystemAppOrSa = usbRightManager_->IsSystemAppOrSa();
451 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
452 if (it->second->GetClass() == BASE_CLASS_HUB && !isSystemAppOrSa) {
453 continue;
454 }
455 auto dev = UsbDevice(*it->second);
456 if (!(isSystemAppOrSa)) {
457 dev.SetmSerial("");
458 }
459 deviceList.push_back(dev);
460 }
461 return UEC_OK;
462 }
463
GetDeviceInfo(uint8_t busNum,uint8_t devAddr,UsbDevice & dev)464 int32_t UsbHostManager::GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev)
465 {
466 const UsbDev uDev = {busNum, devAddr};
467 std::vector<uint8_t> descriptor;
468
469 int32_t res = UEC_OK;
470 int32_t ret = UEC_OK;
471 for (int32_t i = 0; i < RETRY_NUM; i++) {
472 ret = OpenDevice(busNum, devAddr);
473 if (ret == UEC_OK) {
474 break;
475 }
476 std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_INTERVAL));
477 }
478 if (ret != UEC_OK) {
479 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfo OpenDevice failed ret=%{public}d", ret);
480 return ret;
481 }
482 ret = GetDeviceInfoDescriptor(uDev, descriptor, dev);
483 if (ret != UEC_OK) {
484 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfoDescriptor ret=%{public}d", ret);
485 res = Close(busNum, devAddr);
486 if (res != UEC_OK) {
487 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfo CloseDevice failed res=%{public}d", res);
488 return res;
489 }
490 return ret;
491 }
492 res = GetConfigDescriptor(dev, descriptor);
493 if (res != UEC_OK) {
494 USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor ret=%{public}d", ret);
495 }
496 ret = Close(busNum, devAddr);
497 if (ret != UEC_OK) {
498 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfo CloseDevice failed ret=%{public}d", ret);
499 return ret;
500 }
501 return res;
502 }
503
GetDeviceInfoDescriptor(const HDI::Usb::V1_0::UsbDev & uDev,std::vector<uint8_t> & descriptor,UsbDevice & dev)504 int32_t UsbHostManager::GetDeviceInfoDescriptor(const HDI::Usb::V1_0::UsbDev &uDev, std::vector<uint8_t> &descriptor,
505 UsbDevice &dev)
506 {
507 int32_t ret = GetRawDescriptor(uDev.busNum, uDev.devAddr, descriptor);
508 if (ret != UEC_OK) {
509 USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed ret=%{public}d busNum:%{public}d devAddr:%{public}d",
510 ret, uDev.busNum, uDev.devAddr);
511 return ret;
512 }
513 uint8_t *buffer = descriptor.data();
514 uint32_t length = descriptor.size();
515 if ((!buffer) || (length == 0)) {
516 USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed len=%{public}d busNum:%{public}d devAddr:%{public}d",
517 length, uDev.busNum, uDev.devAddr);
518 return UEC_SERVICE_INVALID_VALUE;
519 }
520 dev.SetBusNum(uDev.busNum);
521 dev.SetDevAddr(uDev.devAddr);
522 dev.SetName(std::to_string(uDev.busNum) + "-" + std::to_string(uDev.devAddr));
523
524 ret = UsbDescriptorParser::ParseDeviceDescriptor(buffer, length, dev);
525 if (ret != UEC_OK) {
526 USB_HILOGE(MODULE_USB_SERVICE, "ParseDeviceDescriptor failed ret=%{public}d", ret);
527 return ret;
528 }
529 return ret;
530 }
531
GetConfigDescriptor(UsbDevice & dev,std::vector<uint8_t> & descriptor)532 int32_t UsbHostManager::GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &descriptor)
533 {
534 std::vector<USBConfig> configs;
535 int32_t ret = UsbDescriptorParser::ParseConfigDescriptors(descriptor, CURSOR_INIT, configs);
536 if (ret != UEC_OK) {
537 USB_HILOGE(MODULE_USB_SERVICE, "ParseConfigDescriptors failed ret=%{public}d", ret);
538 return ret;
539 }
540 dev.SetConfigs(configs);
541 ret = FillDevStrings(dev);
542 USB_HILOGI(MODULE_USB_SERVICE, "FillDevStrings ret=%{public}d", ret);
543 return ret;
544 }
545
GetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t & configIndex)546 int32_t UsbHostManager::GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t &configIndex)
547 {
548 #ifdef USB_MANAGER_PASS_THROUGH
549 if (usbHostInterface_ == nullptr) {
550 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbHostInterface_ is nullptr");
551 return UEC_SERVICE_INVALID_VALUE;
552 }
553 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
554 return usbHostInterface_->GetConfig(dev, configIndex);
555 #else
556 const UsbDev dev = {busNum, devAddr};
557 if (usbd_ == nullptr) {
558 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
559 return UEC_SERVICE_INVALID_VALUE;
560 }
561
562 return usbd_->GetConfig(dev, configIndex);
563 #endif // USB_MANAGER_PASS_THROUGH
564 }
565
GetRawDescriptor(uint8_t busNum,uint8_t devAddr,std::vector<uint8_t> & bufferData)566 int32_t UsbHostManager::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vector<uint8_t> &bufferData)
567 {
568 #ifdef USB_MANAGER_PASS_THROUGH
569 if (usbHostInterface_ == nullptr) {
570 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::GetRawDescriptor usbHostInterface_ is nullptr");
571 return UEC_SERVICE_INVALID_VALUE;
572 }
573 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
574 return usbHostInterface_->GetRawDescriptor(dev, bufferData);
575 #else
576 const UsbDev dev = {busNum, devAddr};
577 if (usbd_ == nullptr) {
578 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
579 return UEC_SERVICE_INVALID_VALUE;
580 }
581 return usbd_->GetRawDescriptor(dev, bufferData);
582 #endif // USB_MANAGER_PASS_THROUGH
583 }
584
GetFileDescriptor(uint8_t busNum,uint8_t devAddr,int32_t & fd)585 int32_t UsbHostManager::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &fd)
586 {
587 #ifdef USB_MANAGER_PASS_THROUGH
588 if (usbHostInterface_ == nullptr) {
589 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::GetFileDescriptor usbHostInterface_ is nullptr");
590 return UEC_SERVICE_INVALID_VALUE;
591 }
592 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
593 return usbHostInterface_->GetDeviceFileDescriptor(dev, fd);
594 #else
595 const UsbDev dev = {busNum, devAddr};
596 if (usbd_ == nullptr) {
597 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
598 return UEC_SERVICE_INVALID_VALUE;
599 }
600 return usbd_->GetDeviceFileDescriptor(dev, fd);
601 #endif // USB_MANAGER_PASS_THROUGH
602 }
603
GetDeviceSpeed(uint8_t busNum,uint8_t devAddr,uint8_t & speed)604 int32_t UsbHostManager::GetDeviceSpeed(uint8_t busNum, uint8_t devAddr, uint8_t &speed)
605 {
606 #ifdef USB_MANAGER_PASS_THROUGH
607 if (usbHostInterface_ == nullptr) {
608 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::GetDeviceSpeed usbHostInterface_ is nullptr");
609 return UEC_SERVICE_INVALID_VALUE;
610 }
611 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
612 return usbHostInterface_->GetDeviceSpeed(dev, speed);
613 #else
614 const UsbDev dev = {busNum, devAddr};
615 if (usbd_ == nullptr) {
616 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
617 return UEC_SERVICE_INVALID_VALUE;
618 }
619 return usbd_->GetDeviceSpeed(dev, speed);
620 #endif // USB_MANAGER_PASS_THROUGH
621 }
622
GetInterfaceActiveStatus(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,bool & unactivated)623 int32_t UsbHostManager::GetInterfaceActiveStatus(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid,
624 bool &unactivated)
625 {
626 #ifdef USB_MANAGER_PASS_THROUGH
627 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
628 if (usbHostInterface_ == nullptr) {
629 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::GetInterfaceActiveStatus usbHostInterface_ is nullptr");
630 return UEC_SERVICE_INVALID_VALUE;
631 }
632 return usbHostInterface_->GetInterfaceActiveStatus(dev, interfaceid, unactivated);
633 #else
634 const UsbDev dev = {busNum, devAddr};
635 if (usbd_ == nullptr) {
636 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
637 return UEC_SERVICE_INVALID_VALUE;
638 }
639 return usbd_->GetInterfaceActiveStatus(dev, interfaceid, unactivated);
640 #endif // USB_MANAGER_PASS_THROUGH
641 }
642
BulkTransferRead(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_0::UsbPipe & pipe,std::vector<uint8_t> & bufferData,int32_t timeOut)643 int32_t UsbHostManager::BulkTransferRead(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe,
644 std::vector<uint8_t> &bufferData, int32_t timeOut)
645 {
646 #ifdef USB_MANAGER_PASS_THROUGH
647 if (usbHostInterface_ == nullptr) {
648 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkTransferRead usbHostInterface_ is nullptr");
649 return UEC_SERVICE_INVALID_VALUE;
650 }
651 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
652 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
653 return usbHostInterface_->BulkTransferRead(usbDev_, usbPipe_, timeOut, bufferData);
654 #else
655 if (usbd_ == nullptr) {
656 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
657 return UEC_SERVICE_INVALID_VALUE;
658 }
659
660 return usbd_->BulkTransferRead(dev, pipe, timeOut, bufferData);
661 #endif // USB_MANAGER_PASS_THROUGH
662 }
663
BulkTransferReadwithLength(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_0::UsbPipe & pipe,int32_t length,std::vector<uint8_t> & bufferData,int32_t timeOut)664 int32_t UsbHostManager::BulkTransferReadwithLength(const HDI::Usb::V1_0::UsbDev &dev,
665 const HDI::Usb::V1_0::UsbPipe &pipe, int32_t length, std::vector<uint8_t> &bufferData, int32_t timeOut)
666 {
667 #ifdef USB_MANAGER_PASS_THROUGH
668 if (usbHostInterface_ == nullptr) {
669 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkTransferReadwithLength usbHostInterface_ is nullptr");
670 return UEC_SERVICE_INVALID_VALUE;
671 }
672 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
673 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
674 return usbHostInterface_->BulkTransferReadwithLength(usbDev_, usbPipe_, timeOut, length, bufferData);
675 #else
676 if (usbd_ == nullptr) {
677 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
678 return UEC_SERVICE_INVALID_VALUE;
679 }
680 return usbd_->BulkTransferReadwithLength(dev, pipe, timeOut, length, bufferData);
681 #endif // USB_MANAGER_PASS_THROUGH
682 }
683
BulkTransferWrite(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_0::UsbPipe & pipe,const std::vector<uint8_t> & bufferData,int32_t timeOut)684 int32_t UsbHostManager::BulkTransferWrite(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe,
685 const std::vector<uint8_t> &bufferData, int32_t timeOut)
686 {
687 #ifdef USB_MANAGER_PASS_THROUGH
688 if (usbHostInterface_ == nullptr) {
689 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkTransferWrite usbHostInterface_ is nullptr");
690 return UEC_SERVICE_INVALID_VALUE;
691 }
692 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
693 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
694 return usbHostInterface_->BulkTransferWrite(usbDev_, usbPipe_, timeOut, bufferData);
695 #else
696 if (usbd_ == nullptr) {
697 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
698 return UEC_SERVICE_INVALID_VALUE;
699 }
700 return usbd_->BulkTransferWrite(dev, pipe, timeOut, bufferData);
701 #endif // USB_MANAGER_PASS_THROUGH
702 }
703
ControlTransfer(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_0::UsbCtrlTransfer & ctrl,std::vector<uint8_t> & bufferData)704 int32_t UsbHostManager::ControlTransfer(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbCtrlTransfer &ctrl,
705 std::vector<uint8_t> &bufferData)
706 {
707 #ifdef USB_MANAGER_PASS_THROUGH
708 if (usbHostInterface_ == nullptr) {
709 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::ControlTransfer usbHostInterface_ is nullptr");
710 return UEC_SERVICE_INVALID_VALUE;
711 }
712 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
713 const HDI::Usb::V2_0::UsbCtrlTransfer &usbCtrl_ = reinterpret_cast<const HDI::Usb::V2_0::UsbCtrlTransfer &>(ctrl);
714 int32_t ret = UEC_SERVICE_INNER_ERR;
715 std::lock_guard<std::mutex> guard(transferMutex_);
716 if (((uint32_t)ctrl.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
717 ret = usbHostInterface_->ControlTransferWrite(usbDev_, usbCtrl_, bufferData);
718 if (ret != UEC_OK) {
719 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransfer ControlTransferWrite error ret:%{public}d", ret);
720 }
721 } else {
722 bufferData.clear();
723 ret = usbHostInterface_->ControlTransferRead(usbDev_, usbCtrl_, bufferData);
724 if (ret != UEC_OK) {
725 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransfer ControlTransferRead error ret:%{public}d", ret);
726 }
727 }
728 return ret;
729 #else
730 if (usbd_ == nullptr) {
731 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
732 return UEC_SERVICE_INVALID_VALUE;
733 }
734 int32_t ret = UEC_SERVICE_INNER_ERR;
735 std::lock_guard<std::mutex> guard(transferMutex_);
736 if (((uint32_t)ctrl.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
737 ret = usbd_->ControlTransferWrite(dev, ctrl, bufferData);
738 if (ret != UEC_OK) {
739 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWrite error ret:%{public}d", ret);
740 }
741 } else {
742 bufferData.clear();
743 ret = usbd_->ControlTransferRead(dev, ctrl, bufferData);
744 if (ret != UEC_OK) {
745 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferRead error ret:%{public}d", ret);
746 }
747 }
748 return ret;
749 #endif // USB_MANAGER_PASS_THROUGH
750 }
751
UsbControlTransfer(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_2::UsbCtrlTransferParams & ctrlParams,std::vector<uint8_t> & bufferData)752 int32_t UsbHostManager::UsbControlTransfer(const HDI::Usb::V1_0::UsbDev &dev,
753 const HDI::Usb::V1_2::UsbCtrlTransferParams &ctrlParams, std::vector<uint8_t> &bufferData)
754 {
755 #ifdef USB_MANAGER_PASS_THROUGH
756 if (usbHostInterface_ == nullptr) {
757 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbControlTransfer usbHostInterface_ is nullptr");
758 return UEC_SERVICE_INVALID_VALUE;
759 }
760 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
761 const HDI::Usb::V2_0::UsbCtrlTransferParams &usbCtrlParams_ =
762 reinterpret_cast<const HDI::Usb::V2_0::UsbCtrlTransferParams &>(ctrlParams);
763 int32_t ret = UEC_SERVICE_INNER_ERR;
764 HDI::Usb::V2_0::UsbCtrlTransfer ctrl = {
765 ctrlParams.requestType, ctrlParams.requestCmd, ctrlParams.value, ctrlParams.index, ctrlParams.timeout};
766
767 std::lock_guard<std::mutex> guard(transferMutex_);
768 if (((uint32_t)ctrlParams.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
769 ret = usbHostInterface_->ControlTransferWrite(usbDev_, ctrl, bufferData);
770 if (ret != UEC_OK) {
771 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWrite UsbControlTransfer error ret:%{public}d", ret);
772 }
773 } else {
774 bufferData.clear();
775 ret = usbHostInterface_->ControlTransferReadwithLength(usbDev_, usbCtrlParams_, bufferData);
776 if (ret != UEC_OK) {
777 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWritewithLength error ret:%{public}d", ret);
778 }
779 }
780 return ret;
781 #else
782 if (usbd_ == nullptr) {
783 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
784 return UEC_SERVICE_INVALID_VALUE;
785 }
786 int32_t ret = UEC_SERVICE_INNER_ERR;
787 UsbCtrlTransfer ctrl = {
788 ctrlParams.requestType, ctrlParams.requestCmd, ctrlParams.value, ctrlParams.index, ctrlParams.timeout};
789
790 std::lock_guard<std::mutex> guard(transferMutex_);
791 if (((uint32_t)ctrlParams.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
792 ret = usbd_->ControlTransferWrite(dev, ctrl, bufferData);
793 if (ret != UEC_OK) {
794 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWrite error ret:%{public}d", ret);
795 }
796 } else {
797 bufferData.clear();
798 ret = usbd_->ControlTransferReadwithLength(dev, ctrlParams, bufferData);
799 if (ret != UEC_OK) {
800 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWritewithLength error ret:%{public}d", ret);
801 }
802 }
803 return ret;
804 #endif // USB_MANAGER_PASS_THROUGH
805 }
806
RequestQueue(const HDI::Usb::V1_0::UsbDev & dev,const HDI::Usb::V1_0::UsbPipe & pipe,const std::vector<uint8_t> & clientData,const std::vector<uint8_t> & bufferData)807 int32_t UsbHostManager::RequestQueue(const HDI::Usb::V1_0::UsbDev &dev, const HDI::Usb::V1_0::UsbPipe &pipe,
808 const std::vector<uint8_t> &clientData, const std::vector<uint8_t> &bufferData)
809 {
810 #ifdef USB_MANAGER_PASS_THROUGH
811 if (usbHostInterface_ == nullptr) {
812 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::RequestQueue usbHostInterface_ is nullptr");
813 return UEC_SERVICE_INVALID_VALUE;
814 }
815 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
816 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
817 return usbHostInterface_->RequestQueue(usbDev_, usbPipe_, clientData, bufferData);
818 #else
819 if (usbd_ == nullptr) {
820 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
821 return UEC_SERVICE_INVALID_VALUE;
822 }
823 return usbd_->RequestQueue(dev, pipe, clientData, bufferData);
824 #endif // USB_MANAGER_PASS_THROUGH
825 }
826
RequestWait(const HDI::Usb::V1_0::UsbDev & dev,int32_t timeOut,std::vector<uint8_t> & clientData,std::vector<uint8_t> & bufferData)827 int32_t UsbHostManager::RequestWait(const HDI::Usb::V1_0::UsbDev &dev, int32_t timeOut,
828 std::vector<uint8_t> &clientData, std::vector<uint8_t> &bufferData)
829 {
830 #ifdef USB_MANAGER_PASS_THROUGH
831 if (usbHostInterface_ == nullptr) {
832 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::RequestWait usbHostInterface_ is nullptr");
833 return UEC_SERVICE_INVALID_VALUE;
834 }
835 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
836 return usbHostInterface_->RequestWait(usbDev_, clientData, bufferData, timeOut);
837 #else
838 if (usbd_ == nullptr) {
839 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
840 return UEC_SERVICE_INVALID_VALUE;
841 }
842 return usbd_->RequestWait(dev, clientData, bufferData, timeOut);
843 #endif // USB_MANAGER_PASS_THROUGH
844 }
845
RequestCancel(uint8_t busNum,uint8_t devAddr,uint8_t interfaceId,uint8_t endpointId)846 int32_t UsbHostManager::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId)
847 {
848 #ifdef USB_MANAGER_PASS_THROUGH
849 if (usbHostInterface_ == nullptr) {
850 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::RequestCancel usbHostInterface_ is nullptr");
851 return UEC_SERVICE_INVALID_VALUE;
852 }
853 const HDI::Usb::V2_0::UsbDev dev = {busNum, devAddr};
854 const HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, endpointId};
855 return usbHostInterface_->RequestCancel(dev, pipe);
856 #else
857 const UsbDev dev = {busNum, devAddr};
858 const UsbPipe pipe = {interfaceId, endpointId};
859 if (usbd_ == nullptr) {
860 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
861 return UEC_SERVICE_INVALID_VALUE;
862 }
863
864 return usbd_->RequestCancel(dev, pipe);
865 #endif // USB_MANAGER_PASS_THROUGH
866 }
867
UsbCancelTransfer(const HDI::Usb::V1_0::UsbDev & devInfo,const int32_t & endpoint)868 int32_t UsbHostManager::UsbCancelTransfer(const HDI::Usb::V1_0::UsbDev &devInfo, const int32_t &endpoint)
869 {
870 #ifdef USB_MANAGER_PASS_THROUGH
871 if (usbHostInterface_ == nullptr) {
872 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbCancelTransfer usbHostInterface_ is nullptr");
873 return UEC_SERVICE_INVALID_VALUE;
874 }
875 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
876 return usbHostInterface_->UsbCancelTransfer(usbDev_, endpoint);
877 #else
878 if (usbd_ == nullptr) {
879 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
880 return UEC_SERVICE_INVALID_VALUE;
881 }
882 int32_t ret = usbd_->UsbCancelTransfer(devInfo, endpoint);
883 if (ret != UEC_OK) {
884 USB_HILOGE(MODULE_USB_SERVICE, "UsbCancelTransfer error ret:%{public}d", ret);
885 return ret;
886 }
887 return ret;
888 #endif // USB_MANAGER_PASS_THROUGH
889 }
890
UsbSubmitTransfer(const HDI::Usb::V1_0::UsbDev & devInfo,HDI::Usb::V1_2::USBTransferInfo & info,const sptr<IRemoteObject> & cb,sptr<Ashmem> & ashmem)891 int32_t UsbHostManager::UsbSubmitTransfer(const HDI::Usb::V1_0::UsbDev &devInfo, HDI::Usb::V1_2::USBTransferInfo &info,
892 const sptr<IRemoteObject> &cb, sptr<Ashmem> &ashmem)
893 {
894 int32_t ret = UEC_SERVICE_INVALID_VALUE;
895 #ifdef USB_MANAGER_PASS_THROUGH
896 if (usbHostInterface_ == nullptr) {
897 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbSubmitTransfer usbHostInterface_ is nullptr");
898 return UEC_SERVICE_INVALID_VALUE;
899 }
900 sptr<UsbHostManager::UsbSubmitTransferDeathRecipient> submitRecipient =
901 new UsbSubmitTransferDeathRecipient(devInfo, info.endpoint, this, cb);
902 if (!cb->AddDeathRecipient(submitRecipient)) {
903 USB_HILOGE(MODULE_USB_SERVICE, "add DeathRecipient failed");
904 return UEC_SERVICE_INVALID_VALUE;
905 }
906 sptr<UsbTransferCallbackImpl> callbackImpl = new UsbTransferCallbackImpl(cb);
907 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
908 const HDI::Usb::V2_0::USBTransferInfo &usbInfo = reinterpret_cast<const HDI::Usb::V2_0::USBTransferInfo &>(info);
909 ret = usbHostInterface_->UsbSubmitTransfer(usbDev_, usbInfo, callbackImpl, ashmem);
910 #else
911 if (usbd_ == nullptr) {
912 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UsbSubmitTransfer usbd_ is nullptr");
913 return UEC_SERVICE_INVALID_VALUE;
914 }
915 sptr<UsbHostManager::UsbSubmitTransferDeathRecipient> submitRecipient =
916 new UsbSubmitTransferDeathRecipient(devInfo, info.endpoint, this, cb);
917 if (!cb->AddDeathRecipient(submitRecipient)) {
918 USB_HILOGE(MODULE_USB_SERVICE, "add DeathRecipient failed");
919 return UEC_SERVICE_INVALID_VALUE;
920 }
921 sptr<UsbdTransferCallbackImpl> callbackImpl = new UsbdTransferCallbackImpl(cb);
922 ret = usbd_->UsbSubmitTransfer(devInfo, info, callbackImpl, ashmem);
923 #endif // USB_MANAGER_PASS_THROUGH
924 if (ret != UEC_OK) {
925 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager UsbSubmitTransfer error ret:%{public}d", ret);
926 cb->RemoveDeathRecipient(submitRecipient);
927 submitRecipient.clear();
928 return ret;
929 }
930 return ret;
931 }
932
RegBulkCallback(const HDI::Usb::V1_0::UsbDev & devInfo,const HDI::Usb::V1_0::UsbPipe & pipe,const sptr<IRemoteObject> & cb)933 int32_t UsbHostManager::RegBulkCallback(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe,
934 const sptr<IRemoteObject> &cb)
935 {
936 if (cb == nullptr) {
937 USB_HILOGE(MODULE_USB_SERVICE, "cb is nullptr");
938 return UEC_SERVICE_INVALID_VALUE;
939 }
940 std::lock_guard<std::mutex> guard(hdiCbMutex_);
941 #ifdef USB_MANAGER_PASS_THROUGH
942 if (usbHostHdiCb_ == nullptr) {
943 usbHostHdiCb_ = new UsbBulkCallbackImpl(cb);
944 }
945 if (usbHostInterface_ == nullptr) {
946 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::RegBulkCallback usbHostInterface_ is nullptr");
947 return UEC_SERVICE_INVALID_VALUE;
948 }
949 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
950 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
951 return usbHostInterface_->RegBulkCallback(usbDev_, usbPipe_, usbHostHdiCb_);
952 #else
953 if (hdiCb_ == nullptr) {
954 hdiCb_ = new UsbdBulkCallbackImpl(cb);
955 }
956 if (usbd_ == nullptr) {
957 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
958 return UEC_SERVICE_INVALID_VALUE;
959 }
960
961 return usbd_->RegBulkCallback(devInfo, pipe, hdiCb_);
962 #endif // USB_MANAGER_PASS_THROUGH
963 }
964
UnRegBulkCallback(const HDI::Usb::V1_0::UsbDev & devInfo,const HDI::Usb::V1_0::UsbPipe & pipe)965 int32_t UsbHostManager::UnRegBulkCallback(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe)
966 {
967 #ifdef USB_MANAGER_PASS_THROUGH
968 if (usbHostInterface_ == nullptr) {
969 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::UnRegBulkCallback usbHostInterface_ is nullptr");
970 return UEC_SERVICE_INVALID_VALUE;
971 }
972 std::lock_guard<std::mutex> guard(hdiCbMutex_);
973 usbHostHdiCb_ = nullptr;
974 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
975 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
976 return usbHostInterface_->UnRegBulkCallback(usbDev_, usbPipe_);
977 #else
978 if (usbd_ == nullptr) {
979 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
980 return UEC_SERVICE_INVALID_VALUE;
981 }
982
983 std::lock_guard<std::mutex> guard(hdiCbMutex_);
984 hdiCb_ = nullptr;
985 return usbd_->UnRegBulkCallback(devInfo, pipe);
986 #endif // USB_MANAGER_PASS_THROUGH
987 }
988
BulkRead(const HDI::Usb::V1_0::UsbDev & devInfo,const HDI::Usb::V1_0::UsbPipe & pipe,sptr<Ashmem> & ashmem)989 int32_t UsbHostManager::BulkRead(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe,
990 sptr<Ashmem> &ashmem)
991 {
992 if (ashmem == nullptr) {
993 USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ashmem");
994 return UEC_SERVICE_INVALID_VALUE;
995 }
996 #ifdef USB_MANAGER_PASS_THROUGH
997 if (usbHostInterface_ == nullptr) {
998 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkRead usbHostInterface_ is nullptr");
999 return UEC_SERVICE_INVALID_VALUE;
1000 }
1001 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
1002 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
1003 return usbHostInterface_->BulkRead(usbDev_, usbPipe_, ashmem);
1004 #else
1005 if (usbd_ == nullptr) {
1006 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
1007 return UEC_SERVICE_INVALID_VALUE;
1008 }
1009
1010 return usbd_->BulkRead(devInfo, pipe, ashmem);
1011 #endif // USB_MANAGER_PASS_THROUGH
1012 }
1013
BulkWrite(const HDI::Usb::V1_0::UsbDev & devInfo,const HDI::Usb::V1_0::UsbPipe & pipe,sptr<Ashmem> & ashmem)1014 int32_t UsbHostManager::BulkWrite(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe,
1015 sptr<Ashmem> &ashmem)
1016 {
1017 if (ashmem == nullptr) {
1018 USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ashmem");
1019 return UEC_SERVICE_INVALID_VALUE;
1020 }
1021 #ifdef USB_MANAGER_PASS_THROUGH
1022 if (usbHostInterface_ == nullptr) {
1023 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkWrite usbHostInterface_ is nullptr");
1024 return UEC_SERVICE_INVALID_VALUE;
1025 }
1026 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
1027 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
1028 return usbHostInterface_->BulkWrite(usbDev_, usbPipe_, ashmem);
1029 #else
1030 if (usbd_ == nullptr) {
1031 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
1032 return UEC_SERVICE_INVALID_VALUE;
1033 }
1034
1035 return usbd_->BulkWrite(devInfo, pipe, ashmem);
1036 #endif // USB_MANAGER_PASS_THROUGH
1037 }
1038
BulkCancel(const HDI::Usb::V1_0::UsbDev & devInfo,const HDI::Usb::V1_0::UsbPipe & pipe)1039 int32_t UsbHostManager::BulkCancel(const HDI::Usb::V1_0::UsbDev &devInfo, const HDI::Usb::V1_0::UsbPipe &pipe)
1040 {
1041 #ifdef USB_MANAGER_PASS_THROUGH
1042 if (usbHostInterface_ == nullptr) {
1043 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::BulkCancel usbHostInterface_ is nullptr");
1044 return UEC_SERVICE_INVALID_VALUE;
1045 }
1046 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(devInfo);
1047 const HDI::Usb::V2_0::UsbPipe &usbPipe_ = reinterpret_cast<const HDI::Usb::V2_0::UsbPipe &>(pipe);
1048 return usbHostInterface_->BulkCancel(usbDev_, usbPipe_);
1049 #else
1050 if (usbd_ == nullptr) {
1051 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
1052 return UEC_SERVICE_INVALID_VALUE;
1053 }
1054
1055 return usbd_->BulkCancel(devInfo, pipe);
1056 #endif // USB_MANAGER_PASS_THROUGH
1057 }
1058
GetDevices(MAP_STR_DEVICE & devices)1059 void UsbHostManager::GetDevices(MAP_STR_DEVICE &devices)
1060 {
1061 devices = devices_;
1062 }
1063
GetProductName(const std::string & deviceName,std::string & productName)1064 bool UsbHostManager::GetProductName(const std::string &deviceName, std::string &productName)
1065 {
1066 auto iter = devices_.find(deviceName);
1067 if (iter == devices_.end()) {
1068 return false;
1069 }
1070
1071 UsbDevice *dev = iter->second;
1072 if (dev == nullptr) {
1073 return false;
1074 }
1075
1076 productName = dev->GetProductName();
1077 return true;
1078 }
1079
DelDevice(uint8_t busNum,uint8_t devNum)1080 bool UsbHostManager::DelDevice(uint8_t busNum, uint8_t devNum)
1081 {
1082 std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
1083 MAP_STR_DEVICE::iterator iter = devices_.find(name);
1084 if (iter == devices_.end()) {
1085 USB_HILOGF(MODULE_SERVICE, "name:%{public}s bus:%{public}hhu dev:%{public}hhu not exist", name.c_str(), busNum,
1086 devNum);
1087 return false;
1088 }
1089 UsbDevice *devOld = iter->second;
1090 if (devOld == nullptr) {
1091 USB_HILOGE(MODULE_SERVICE, "invalid device");
1092 return false;
1093 }
1094
1095 auto isSuccess = PublishCommonEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED, *devOld);
1096 if (!isSuccess) {
1097 USB_HILOGW(MODULE_SERVICE, "send device attached broadcast failed");
1098 }
1099
1100 delete devOld;
1101 devices_.erase(iter);
1102 USB_HILOGI(MODULE_SERVICE,
1103 "device:%{public}s bus:%{public}hhu dev:%{public}hhu erase, cur device size: %{public}zu",
1104 name.c_str(), busNum, devNum, devices_.size());
1105 return true;
1106 }
1107
AddDevice(UsbDevice * dev)1108 bool UsbHostManager::AddDevice(UsbDevice *dev)
1109 {
1110 if (dev == nullptr) {
1111 USB_HILOGF(MODULE_SERVICE, "device is NULL");
1112 return false;
1113 }
1114
1115 uint8_t busNum = dev->GetBusNum();
1116 uint8_t devNum = dev->GetDevAddr();
1117 std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
1118 MAP_STR_DEVICE::iterator iter = devices_.find(name);
1119 if (iter != devices_.end()) {
1120 USB_HILOGF(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu already exist", name.c_str(),
1121 busNum, devNum);
1122 UsbDevice *devOld = iter->second;
1123 if (devOld != nullptr && devOld != dev) {
1124 delete devOld;
1125 }
1126 devices_.erase(iter);
1127 }
1128 devices_.insert(std::pair<std::string, UsbDevice *>(name, dev));
1129
1130 USB_HILOGI(MODULE_SERVICE,
1131 "device:%{public}s bus:%{public}hhu dev:%{public}hhu insert, cur device size: %{public}zu",
1132 name.c_str(), busNum, devNum, devices_.size());
1133 auto isSuccess = PublishCommonEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED, *dev);
1134 if (!isSuccess) {
1135 USB_HILOGW(MODULE_SERVICE, "send device attached broadcast failed");
1136 }
1137 return true;
1138 }
1139
PublishCommonEvent(const std::string & event,const UsbDevice & dev)1140 bool UsbHostManager::PublishCommonEvent(const std::string &event, const UsbDevice &dev)
1141 {
1142 Want want;
1143 want.SetAction(event);
1144 CommonEventData data(want);
1145 data.SetData(dev.getJsonString().c_str());
1146 CommonEventPublishInfo publishInfo;
1147 if (dev.GetClass() == BASE_CLASS_HUB) {
1148 publishInfo.SetSubscriberType(SubscriberType::SYSTEM_SUBSCRIBER_TYPE);
1149 }
1150 USB_HILOGI(MODULE_SERVICE, "send %{public}s broadcast device:%{public}s", event.c_str(),
1151 dev.getJsonString().c_str());
1152 ReportHostPlugSysEvent(event, dev);
1153 return CommonEventManager::PublishCommonEvent(data, publishInfo);
1154 }
1155
Dump(int fd,const std::string & args)1156 bool UsbHostManager::Dump(int fd, const std::string &args)
1157 {
1158 if (args.compare("-a") != 0) {
1159 dprintf(fd, "args is not -a\n");
1160 return false;
1161 }
1162
1163 dprintf(fd, "Usb Host all device list info:\n");
1164 for (const auto &item : devices_) {
1165 dprintf(fd, "usb host list info: %s\n", item.second->getJsonString().c_str());
1166 }
1167 return true;
1168 }
1169
GetDeviceDescription(int32_t baseClass,std::string & description,uint8_t & usage)1170 int32_t UsbHostManager::GetDeviceDescription(int32_t baseClass, std::string &description, uint8_t &usage)
1171 {
1172 auto iter = deviceUsageMap.find(baseClass);
1173 if (iter != deviceUsageMap.end()) {
1174 description = iter->second.description;
1175 usage = iter->second.usage;
1176 } else {
1177 description = "NA";
1178 usage = 1;
1179 }
1180 return UEC_OK;
1181 }
1182
1183
ConcatenateToDescription(const UsbDeviceType & interfaceType,const std::string & str)1184 std::string UsbHostManager::ConcatenateToDescription(const UsbDeviceType &interfaceType, const std::string& str)
1185 {
1186 std::stringstream ss;
1187 ss << std::setw(CLASS_PRINT_LENGTH) << std::setfill('0') << std::hex << interfaceType.baseClass << "_";
1188 ss << std::setw(CLASS_PRINT_LENGTH) << std::setfill('0') << std::hex << interfaceType.subClass << "_";
1189 ss << std::setw(CLASS_PRINT_LENGTH) << std::setfill('0') << std::hex << interfaceType.protocol << ",";
1190 ss << str;
1191 return ss.str();
1192 }
1193
GetInterfaceUsageDescription(const UsbDeviceType & interfaceType)1194 std::string UsbHostManager::GetInterfaceUsageDescription(const UsbDeviceType &interfaceType)
1195 {
1196 std::string infUsageDes = "NA";
1197 auto infUsageIter = interfaceUsageMap.find(interfaceType);
1198 if (infUsageIter != interfaceUsageMap.end()) {
1199 return infUsageIter->second;
1200 }
1201 return infUsageDes;
1202 }
1203
GetInterfaceDescription(const UsbDevice & dev,std::string & description,int32_t & baseClass)1204 int32_t UsbHostManager::GetInterfaceDescription(const UsbDevice &dev, std::string &description, int32_t &baseClass)
1205 {
1206 std::set<UsbDeviceType> useInterfaceType;
1207 for (int32_t i = 0; i < dev.GetConfigCount(); i++) {
1208 USBConfig config;
1209 dev.GetConfig(i, config);
1210 for (uint32_t j = 0; j < config.GetInterfaceCount(); j++) {
1211 if (i != 0 || j != 0) {
1212 description += ";";
1213 }
1214 UsbInterface interface;
1215 config.GetInterface(j, interface);
1216 baseClass = interface.GetClass();
1217 UsbDeviceType interfaceType = {interface.GetClass(),
1218 interface.GetSubClass(), interface.GetProtocol(), 0};
1219 useInterfaceType.insert(interfaceType);
1220 std::string infUsageDes = GetInterfaceUsageDescription(interfaceType);
1221 description += ConcatenateToDescription(interfaceType, infUsageDes);
1222 }
1223 }
1224 return UEC_OK;
1225 }
1226
ReportHostPlugSysEvent(const std::string & event,const UsbDevice & dev)1227 void UsbHostManager::ReportHostPlugSysEvent(const std::string &event, const UsbDevice &dev)
1228 {
1229 std::string deviceUsageDes;
1230 uint8_t deviceUsage = 0;
1231 GetDeviceDescription(dev.GetClass(), deviceUsageDes, deviceUsage);
1232 std::string extUsageDes;
1233 int32_t intfBaseClass = 0;
1234 if (deviceUsage & DES_USAGE_IN_INTERFACE) {
1235 GetInterfaceDescription(dev, extUsageDes, intfBaseClass);
1236 }
1237
1238 if (dev.GetClass() == USAGE_IN_INTERFACE_CLASS) {
1239 GetDeviceDescription(intfBaseClass, deviceUsageDes, deviceUsage);
1240 }
1241 std::string snNum;
1242 if (dev.GetmSerial().length() > LAST_FIVE) {
1243 snNum = dev.GetmSerial().substr(dev.GetmSerial().length() - LAST_FIVE);
1244 }
1245 USB_HILOGI(MODULE_SERVICE, "Host mode Indicates the insertion and removal information");
1246 HiSysEventWrite(HiSysEvent::Domain::USB, "PLUG_IN_OUT_HOST_MODE", HiSysEvent::EventType::BEHAVIOR,
1247 "DEVICE_NAME", dev.GetProductName(), "DEVICE_PROTOCOL", dev.GetProtocol(),
1248 "DEVICE_SUBCLASS", dev.GetSubclass(), "DEVICE_CLASS", dev.GetClass(),
1249 "DEVICE_CLASS_DESCRIPTION", deviceUsageDes, "INTERFACE_CLASS_DESCRIPTION", extUsageDes,
1250 "VENDOR_ID", dev.GetVendorId(), "PRODUCT_ID", dev.GetProductId(),
1251 "VERSION", dev.GetVersion(), "EVENT_NAME", event, "SN_NUM", snNum,
1252 "MANUFACTURER_NAME", dev.GetManufacturerName());
1253 }
1254
BcdToString(uint16_t bcdUsb)1255 static std::string BcdToString(uint16_t bcdUsb)
1256 {
1257 std::ostringstream oss;
1258 oss << std::hex << std::uppercase <<std::setw(BCD_HEX_DIGITS) << std::setfill('0') << bcdUsb;
1259 return oss.str();
1260 }
1261
FillDevStrings(UsbDevice & dev)1262 int32_t UsbHostManager::FillDevStrings(UsbDevice &dev)
1263 {
1264 uint8_t busNum;
1265 uint8_t devAddr;
1266
1267 busNum = dev.GetBusNum();
1268 devAddr = dev.GetDevAddr();
1269 uint16_t bcdUsb = dev.GetbcdUSB();
1270 dev.SetVersion(BcdToString(bcdUsb));
1271 dev.SetManufacturerName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiManufacturer()));
1272 dev.SetProductName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiProduct()));
1273 dev.SetmSerial(GetDevStringValFromIdx(busNum, devAddr, dev.GetiSerialNumber()));
1274 USB_HILOGI(MODULE_USB_SERVICE,
1275 "iSerial:%{public}d Manufactur:%{public}s product:%{public}s "
1276 "version:%{public}s",
1277 dev.GetiSerialNumber(), dev.GetManufacturerName().c_str(), dev.GetProductName().c_str(),
1278 dev.GetVersion().c_str());
1279
1280 std::vector<USBConfig> configs;
1281 configs = dev.GetConfigs();
1282 for (auto it = configs.begin(); it != configs.end(); ++it) {
1283 it->SetName(GetDevStringValFromIdx(busNum, devAddr, it->GetiConfiguration()));
1284 USB_HILOGI(MODULE_USB_SERVICE, "Config:%{public}d %{public}s", it->GetiConfiguration(), it->GetName().c_str());
1285 std::vector<UsbInterface> interfaces = it->GetInterfaces();
1286 for (auto itIF = interfaces.begin(); itIF != interfaces.end(); ++itIF) {
1287 itIF->SetName(GetDevStringValFromIdx(busNum, devAddr, itIF->GetiInterface()));
1288 USB_HILOGI(MODULE_USB_SERVICE, "interface:%{public}hhu %{public}s", itIF->GetiInterface(),
1289 itIF->GetName().c_str());
1290 }
1291 it->SetInterfaces(interfaces);
1292 }
1293 dev.SetConfigs(configs);
1294
1295 return UEC_OK;
1296 }
1297
Utf16leToUtf8(const uint8_t * utf16leBytes,size_t length)1298 static std::string Utf16leToUtf8(const uint8_t* utf16leBytes, size_t length)
1299 {
1300 if (utf16leBytes == nullptr || length % HALF) {
1301 USB_HILOGE(MODULE_USB_SERVICE, "Utf16leToUtf8: invalid length: %{public}zu", length);
1302 return " ";
1303 }
1304 const char16_t* utf16leData = reinterpret_cast<const char16_t*>(utf16leBytes);
1305 size_t charCount = length / HALF;
1306 size_t startIdx = 0;
1307 // check and skip BOM
1308 if (charCount > 0 && utf16leData[0] == 0xFEFF) {
1309 startIdx = 1;
1310 charCount--;
1311 }
1312
1313 std::u16string utf16leStr(utf16leData + startIdx, charCount);
1314 std::wstring_convert<std::codecvt_utf8_utf16<char16_t, 0x10FFFF, std::little_endian>, char16_t> converter;
1315 return converter.to_bytes(utf16leStr);
1316 }
1317
GetDevStringValFromIdx(uint8_t busNum,uint8_t devAddr,uint8_t idx)1318 std::string UsbHostManager::GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8_t idx)
1319 {
1320 const UsbDev dev = {busNum, devAddr};
1321 std::vector<uint8_t> strV;
1322 std::string strDesc = " ";
1323
1324 if (idx == 0) {
1325 return strDesc;
1326 }
1327
1328 #ifdef USB_MANAGER_PASS_THROUGH
1329 if (usbHostInterface_ == nullptr) {
1330 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbHostInterface_ is nullptr");
1331 return nullptr;
1332 }
1333 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
1334 int32_t ret = usbHostInterface_->GetStringDescriptor(usbDev_, idx, strV);
1335 #else
1336 if (usbd_ == nullptr) {
1337 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::usbd_ is nullptr");
1338 return nullptr;
1339 }
1340 int32_t ret = usbd_->GetStringDescriptor(dev, idx, strV);
1341 #endif // USB_MANAGER_PASS_THROUGH
1342 if (ret != UEC_OK) {
1343 USB_HILOGE(MODULE_USB_SERVICE, "get string[%{public}hhu] failed ret:%{public}d", idx, ret);
1344 return strDesc;
1345 }
1346 size_t length = strV.size();
1347 if ((length < DESCRIPTOR_VALUE_START_OFFSET) || (strV[1] != DESCRIPTOR_TYPE_STRING)) {
1348 USB_HILOGI(MODULE_USB_SERVICE, "type or length error, len:%{public}zu", length);
1349 return strDesc;
1350 }
1351
1352 uint8_t *tbuf = new (std::nothrow) uint8_t[length - DESCRIPTOR_VALUE_START_OFFSET]();
1353 if (tbuf == nullptr) {
1354 USB_HILOGI(MODULE_USB_SERVICE, "new failed");
1355 return strDesc;
1356 }
1357
1358 for (uint32_t i = 0; i < length - DESCRIPTOR_VALUE_START_OFFSET; ++i) {
1359 tbuf[i] = strV[i + DESCRIPTOR_VALUE_START_OFFSET];
1360 }
1361
1362 strDesc = Utf16leToUtf8(tbuf, length - DESCRIPTOR_VALUE_START_OFFSET);
1363 USB_HILOGI(MODULE_USB_SERVICE, "getString idx:%{public}d length:%{public}zu, str: %{public}s",
1364 idx, strDesc.length(), strDesc.c_str());
1365 delete[] tbuf;
1366 return strDesc;
1367 }
1368
IsEdmEnabled()1369 bool UsbHostManager::IsEdmEnabled()
1370 {
1371 std::string edmParaValue = OHOS::system::GetParameter("persist.edm.edm_enable", "false");
1372 USB_HILOGI(MODULE_USB_SERVICE, "edmParaValue is %{public}s", edmParaValue.c_str());
1373 return edmParaValue == "true";
1374 }
1375
ExecuteManageDevicePolicy(std::vector<UsbDeviceId> & whiteList)1376 int32_t UsbHostManager::ExecuteManageDevicePolicy(std::vector<UsbDeviceId> &whiteList)
1377 {
1378 int32_t ret = UEC_INTERFACE_NO_MEMORY;
1379 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices_.size());
1380 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1381 bool inWhiteList = false;
1382 for (auto dev : whiteList) {
1383 if (it->second->GetProductId() == dev.productId && it->second->GetVendorId() == dev.vendorId) {
1384 inWhiteList = true;
1385 break;
1386 }
1387 }
1388 if (inWhiteList) {
1389 ret = ManageDeviceImpl(it->second->GetVendorId(), it->second->GetProductId(), false);
1390 } else {
1391 ret = ManageDeviceImpl(it->second->GetVendorId(), it->second->GetProductId(), true);
1392 }
1393 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1394 }
1395 if (ret != UEC_OK) {
1396 USB_HILOGI(MODULE_USB_SERVICE, "ManageDevice failed");
1397 return UEC_SERVICE_EXECUTE_POLICY_FAILED;
1398 }
1399 return UEC_OK;
1400 }
1401
ExecuteManageInterfaceType(const std::vector<UsbDeviceType> & disableType,bool disable)1402 int32_t UsbHostManager::ExecuteManageInterfaceType(const std::vector<UsbDeviceType> &disableType, bool disable)
1403 {
1404 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1405 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1406 int32_t ret = OpenDevice(dev.busNum, dev.devAddr);
1407 if (ret != UEC_OK) {
1408 USB_HILOGW(MODULE_USB_SERVICE, "ExecuteManageInterfaceType open fail ret = %{public}d", ret);
1409 }
1410 }
1411 ExecuteManageDeviceType(disableType, disable, d_typeMap, true);
1412 ExecuteManageDeviceType(disableType, disable, g_typeMap, false);
1413 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1414 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1415 int32_t ret = Close(dev.busNum, dev.devAddr);
1416 if (ret != UEC_OK) {
1417 USB_HILOGW(MODULE_USB_SERVICE, "ExecuteManageInterfaceType close fail ret = %{public}d", ret);
1418 }
1419 }
1420 return UEC_OK;
1421 }
1422
GetEdmPolicy(bool & IsGlobalDisabled,std::vector<UsbDeviceType> & disableType,std::vector<UsbDeviceId> & trustUsbDeviceIds)1423 int32_t UsbHostManager::GetEdmPolicy(bool &IsGlobalDisabled, std::vector<UsbDeviceType> &disableType,
1424 std::vector<UsbDeviceId> &trustUsbDeviceIds)
1425 {
1426 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1427 if (sm == nullptr) {
1428 USB_HILOGE(MODULE_USB_SERVICE, "fail to get SystemAbilityManager");
1429 return UEC_SERVICE_GET_SYSTEM_ABILITY_MANAGER_FAILED;
1430 }
1431 sptr<IRemoteObject> remote = sm->CheckSystemAbility(EDM_SYSTEM_ABILITY_ID);
1432 if (remote == nullptr) {
1433 USB_HILOGE(MODULE_USB_SERVICE, "Get Edm SystemAbility failed.");
1434 return UEC_SERVICE_GET_EDM_SERVICE_FAILED;
1435 }
1436 int32_t ret = GetEdmGlobalPolicy(remote, IsGlobalDisabled);
1437 if (ret != UEC_OK) {
1438 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmGlobalPolicy failed.");
1439 return ret;
1440 }
1441 ret = GetEdmStroageTypePolicy(remote, disableType);
1442 if (ret != UEC_OK) {
1443 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmStroageTypePolicy failed.");
1444 return ret;
1445 }
1446 ret = GetEdmTypePolicy(remote, disableType);
1447 if (ret != UEC_OK) {
1448 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmTypePolicy failed.");
1449 return ret;
1450 }
1451 ret = GetEdmWhiteListPolicy(remote, trustUsbDeviceIds);
1452 if (ret != UEC_OK) {
1453 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy failed.");
1454 return ret;
1455 }
1456 return UEC_OK;
1457 }
1458
GetUsbPolicy(bool & IsGlobalDisabled,std::vector<UsbDeviceType> & disableType,std::vector<UsbDeviceId> & trustUsbDeviceIds)1459 int32_t UsbHostManager::GetUsbPolicy(bool &IsGlobalDisabled, std::vector<UsbDeviceType> &disableType,
1460 std::vector<UsbDeviceId> &trustUsbDeviceIds)
1461 {
1462 auto startTime = std::chrono::steady_clock::now();
1463 bool isPolicyObtained = false;
1464 while (!isPolicyObtained) {
1465 int32_t ret = GetEdmPolicy(IsGlobalDisabled, disableType, trustUsbDeviceIds);
1466 if (ret == UEC_OK) {
1467 USB_HILOGI(MODULE_USB_SERVICE, "GetUsbPolicy succeed");
1468 break;
1469 } else if (ret == EDM_SA_TIME_OUT_CODE) {
1470 auto currentTime = std::chrono::steady_clock::now();
1471 auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - startTime).count();
1472 if (elapsedTime >= EDM_SA_MAX_TIME_OUT) {
1473 USB_HILOGE(MODULE_USB_SERVICE, "Time out, exit loop");
1474 return UEC_SERVICE_EDM_SA_TIME_OUT_FAILED;
1475 }
1476 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1477 } else {
1478 USB_HILOGE(MODULE_USB_SERVICE, "EDM sa failed");
1479 return UEC_SERVICE_PREPARE_EDM_SA_FAILED;
1480 }
1481 }
1482 return UEC_OK;
1483 }
1484
GetEdmTypePolicy(sptr<IRemoteObject> remote,std::vector<UsbDeviceType> & disableType)1485 int32_t UsbHostManager::GetEdmTypePolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceType> &disableType)
1486 {
1487 if (remote == nullptr) {
1488 USB_HILOGE(MODULE_USB_SERVICE, "Remote is nullpter.");
1489 return UEC_SERVICE_INVALID_VALUE;
1490 }
1491 MessageParcel data;
1492 MessageParcel reply;
1493 MessageOption option;
1494 data.WriteInterfaceToken(DESCRIPTOR);
1495 data.WriteInt32(WITHOUT_USERID);
1496 data.WriteString("");
1497 data.WriteInt32(WITHOUT_ADMIN);
1498 uint32_t funcCode = (1 << EMD_MASK_CODE) | USB_DEVICE_ACCESS_POLICY;
1499 int32_t sendRet = remote->SendRequest(funcCode, data, reply, option);
1500 int32_t ret = ERR_INVALID_VALUE;
1501 bool isSuccess = reply.ReadInt32(ret) && (ret == ERR_OK);
1502 if (!isSuccess || (sendRet != UEC_OK)) {
1503 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmTypePolicy failed. sendRet = %{public}d, ret = %{public}d",
1504 sendRet, ret);
1505 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
1506 }
1507
1508 int32_t size = reply.ReadInt32();
1509 if (size < 0 || static_cast<uint32_t>(size) > WHITELIST_POLICY_MAX_DEVICES) {
1510 USB_HILOGE(MODULE_USB_SERVICE, "EdmTypeList size=[%{public}d] is invalid", size);
1511 return UEC_SERVICE_EDM_DEVICE_SIZE_EXCEED;
1512 }
1513 USB_HILOGI(MODULE_USB_SERVICE, "GetEdmTypePolicy return size:%{public}d", size);
1514 for (int32_t i = 0; i < size; i++) {
1515 UsbDeviceType usbDeviceType;
1516 usbDeviceType.baseClass = reply.ReadInt32();
1517 usbDeviceType.subClass = reply.ReadInt32();
1518 usbDeviceType.protocol = reply.ReadInt32();
1519 usbDeviceType.isDeviceType = reply.ReadBool();
1520 disableType.emplace_back(usbDeviceType);
1521 }
1522 return UEC_OK;
1523 }
1524
GetEdmGlobalPolicy(sptr<IRemoteObject> remote,bool & IsGlobalDisabled)1525 int32_t UsbHostManager::GetEdmGlobalPolicy(sptr<IRemoteObject> remote, bool &IsGlobalDisabled)
1526 {
1527 if (remote == nullptr) {
1528 USB_HILOGE(MODULE_USB_SERVICE, "Remote is nullpter.");
1529 return UEC_SERVICE_INVALID_VALUE;
1530 }
1531 MessageParcel data;
1532 MessageParcel reply;
1533 MessageOption option;
1534 data.WriteInterfaceToken(DESCRIPTOR);
1535 data.WriteInt32(WITHOUT_USERID);
1536 data.WriteString("");
1537 data.WriteInt32(WITHOUT_ADMIN);
1538 uint32_t funcCode = (1 << EMD_MASK_CODE) | DISABLE_USB;
1539 int32_t sendRet = remote->SendRequest(funcCode, data, reply, option);
1540 int32_t ret = ERR_INVALID_VALUE;
1541 bool isSuccess = reply.ReadInt32(ret) && (ret == UEC_OK);
1542 if (!isSuccess || (sendRet != UEC_OK)) {
1543 USB_HILOGE(MODULE_USB_SERVICE, "GetGlobalPolicy failed. sendRet = %{public}d, ret = %{public}d",
1544 sendRet, ret);
1545 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
1546 }
1547
1548 reply.ReadBool(IsGlobalDisabled);
1549 return UEC_OK;
1550 }
1551
GetEdmStroageTypePolicy(sptr<IRemoteObject> remote,std::vector<UsbDeviceType> & disableType)1552 int32_t UsbHostManager::GetEdmStroageTypePolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceType> &disableType)
1553 {
1554 if (remote == nullptr) {
1555 USB_HILOGE(MODULE_USB_SERVICE, "Remote is nullpter.");
1556 return UEC_SERVICE_INVALID_VALUE;
1557 }
1558 int32_t stroageDisableType = 0;
1559 MessageParcel data;
1560 MessageParcel reply;
1561 MessageOption option;
1562 data.WriteInterfaceToken(DESCRIPTOR);
1563 data.WriteInt32(WITHOUT_USERID);
1564 data.WriteString("");
1565 data.WriteInt32(WITHOUT_ADMIN);
1566 uint32_t funcCode = (1 << EMD_MASK_CODE) | USB_STORAGE_DEVICE_ACCESS_POLICY;
1567 int32_t sendRet = remote->SendRequest(funcCode, data, reply, option);
1568 int32_t ret = ERR_INVALID_VALUE;
1569 bool isSuccess = reply.ReadInt32(ret) && (ret == ERR_OK);
1570 if (!isSuccess || (sendRet != UEC_OK)) {
1571 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmStroageTypePolicy failed. sendRet = %{public}d, ret = %{public}d",
1572 sendRet, ret);
1573 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
1574 }
1575
1576 reply.ReadInt32(stroageDisableType);
1577 if (stroageDisableType == GET_EDM_STORAGE_DISABLE_TYPE) {
1578 UsbDeviceType usbDeviceType;
1579 usbDeviceType.baseClass = STORAGE_BASE_CLASS;
1580 usbDeviceType.isDeviceType = 0;
1581 disableType.emplace_back(usbDeviceType);
1582 }
1583 return UEC_OK;
1584 }
1585
GetEdmWhiteListPolicy(sptr<IRemoteObject> remote,std::vector<UsbDeviceId> & trustUsbDeviceIds)1586 int32_t UsbHostManager::GetEdmWhiteListPolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceId> &trustUsbDeviceIds)
1587 {
1588 if (remote == nullptr) {
1589 USB_HILOGE(MODULE_USB_SERVICE, "Remote is nullpter.");
1590 return UEC_SERVICE_INVALID_VALUE;
1591 }
1592 MessageParcel data;
1593 MessageParcel reply;
1594 MessageOption option;
1595 data.WriteInterfaceToken(DESCRIPTOR);
1596 data.WriteInt32(WITHOUT_USERID);
1597 data.WriteString("");
1598 data.WriteInt32(WITHOUT_ADMIN);
1599 uint32_t funcCode = (1 << EMD_MASK_CODE) | ALLOWED_USB_DEVICES;
1600 int32_t sendRet = remote->SendRequest(funcCode, data, reply, option);
1601 int32_t ret = ERR_INVALID_VALUE;
1602 bool IsSuccess = reply.ReadInt32(ret) && (ret == ERR_OK);
1603 if (!IsSuccess || (sendRet != UEC_OK)) {
1604 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy failed. sendRet = %{public}d, ret = %{public}d",
1605 sendRet, ret);
1606 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
1607 }
1608
1609 int32_t size = reply.ReadInt32();
1610 if (size < 0 || static_cast<uint32_t>(size) > WHITELIST_POLICY_MAX_DEVICES) {
1611 USB_HILOGE(MODULE_USB_SERVICE, "EdmTypeList size=[%{public}d] is invalid", size);
1612 return UEC_SERVICE_EDM_DEVICE_SIZE_EXCEED;
1613 }
1614 USB_HILOGI(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy return size:%{public}d", size);
1615 for (int32_t i = 0; i < size; i++) {
1616 UsbDeviceId usbDeviceId;
1617 usbDeviceId.vendorId = reply.ReadInt32();
1618 usbDeviceId.productId = reply.ReadInt32();
1619 trustUsbDeviceIds.emplace_back(usbDeviceId);
1620 }
1621 return UEC_OK;
1622 }
1623
ManageInterface(const HDI::Usb::V1_0::UsbDev & dev,uint8_t interfaceId,bool disable)1624 int32_t UsbHostManager::ManageInterface(const HDI::Usb::V1_0::UsbDev &dev, uint8_t interfaceId, bool disable)
1625 {
1626 #ifdef USB_MANAGER_PASS_THROUGH
1627 if (usbHostInterface_ == nullptr) {
1628 USB_HILOGE(MODULE_SERVICE, "UsbHostManager::ManageInterface usbHostInterface_ is nullptr");
1629 return UEC_SERVICE_INVALID_VALUE;
1630 }
1631 const HDI::Usb::V2_0::UsbDev &usbDev_ = reinterpret_cast<const HDI::Usb::V2_0::UsbDev &>(dev);
1632 return usbHostInterface_->ManageInterface(usbDev_, interfaceId, disable);
1633 #else
1634 if (usbd_ == nullptr) {
1635 USB_HILOGE(MODULE_USB_SERVICE, "usbd_ is nullptr");
1636 return UEC_SERVICE_INVALID_VALUE;
1637 }
1638 return usbd_->ManageInterface(dev, interfaceId, disable);
1639 #endif // USB_MANAGER_PASS_THROUGH
1640 }
1641
ExecuteManageDeviceType(const std::vector<UsbDeviceType> & disableType,bool disable,const std::unordered_map<InterfaceType,std::vector<int32_t>> & map,bool isDev)1642 void UsbHostManager::ExecuteManageDeviceType(const std::vector<UsbDeviceType> &disableType, bool disable,
1643 const std::unordered_map<InterfaceType, std::vector<int32_t>> &map, bool isDev)
1644 {
1645 std::vector<InterfaceType> interfaceTypes;
1646 for (const auto &dev : disableType) {
1647 bool isMatch = false;
1648 for (auto& [interfaceTypeValues, typeValues] : map) {
1649 if ((typeValues[0] == dev.baseClass) &&
1650 (typeValues[1] == -1 || typeValues[1] == dev.subClass) &&
1651 (typeValues[HALF] == -1 || typeValues[HALF] == dev.protocol)) {
1652 isMatch = true;
1653 interfaceTypes.emplace_back(interfaceTypeValues);
1654 break;
1655 }
1656 }
1657 if (!isMatch) {
1658 USB_HILOGE(MODULE_USB_SERVICE, "is not in the type list, %{public}d, %{public}d, %{public}d",
1659 dev.baseClass, dev.subClass, dev.protocol);
1660 }
1661 }
1662
1663 for (auto& [interfaceTypeValues, typeValues] : map) {
1664 bool canFind = false;
1665 for (auto disallowedValues : interfaceTypes) {
1666 if (interfaceTypeValues == disallowedValues) {
1667 canFind = true;
1668 break;
1669 }
1670 }
1671 if ((!isDev) && canFind) {
1672 ManageInterfaceTypeImpl(interfaceTypeValues, disable);
1673 }
1674 if ((!isDev) && (!canFind)) {
1675 ManageInterfaceTypeImpl(interfaceTypeValues, !disable);
1676 }
1677 if (isDev && canFind) {
1678 ManageDeviceTypeImpl(interfaceTypeValues, disable);
1679 }
1680 if (isDev && !canFind) {
1681 ManageDeviceTypeImpl(interfaceTypeValues, !disable);
1682 }
1683 }
1684 }
1685
ManageGlobalInterfaceImpl(bool disable)1686 int32_t UsbHostManager::ManageGlobalInterfaceImpl(bool disable)
1687 {
1688 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices_.size());
1689 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1690 if (it->second->GetClass() == BASE_CLASS_HUB) {
1691 continue;
1692 }
1693 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1694 uint8_t configIndex = 0;
1695 if (OpenDevice(dev.busNum, dev.devAddr) != UEC_OK) {
1696 USB_HILOGW(MODULE_USB_SERVICE, "ManageGlobalInterfaceImpl OpenDevice failed");
1697 continue;
1698 }
1699 if (GetActiveConfig(dev.busNum, dev.devAddr, configIndex) || (configIndex < 1)) {
1700 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1701 Close(dev.busNum, dev.devAddr);
1702 continue;
1703 }
1704 USBConfig configs;
1705 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1706 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1707 Close(dev.busNum, dev.devAddr);
1708 continue;
1709 }
1710
1711 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1712 for (uint32_t i = 0; i < interfaces.size(); i++) {
1713 ManageInterface(dev, interfaces[i].GetId(), disable);
1714 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1715 }
1716 if (disable) {
1717 ReportManageDeviceInfo("GlobalType", it->second, nullptr, false);
1718 }
1719 if (Close(dev.busNum, dev.devAddr) != UEC_OK) {
1720 USB_HILOGW(MODULE_USB_SERVICE, "ManageGlobalInterfaceImpl CloseDevice fail");
1721 }
1722 }
1723 return UEC_OK;
1724 }
1725
ManageDeviceImpl(int32_t vendorId,int32_t productId,bool disable)1726 int32_t UsbHostManager::ManageDeviceImpl(int32_t vendorId, int32_t productId, bool disable)
1727 {
1728 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu, vId: %{public}d, pId: %{public}d, b: %{public}d",
1729 devices_.size(), vendorId, productId, disable);
1730 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1731 if (it->second->GetClass() == BASE_CLASS_HUB) {
1732 continue;
1733 }
1734 if ((it->second->GetVendorId() == vendorId) && (it->second->GetProductId() == productId)) {
1735 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1736 uint8_t configIndex = 0;
1737 if (OpenDevice(dev.busNum, dev.devAddr) != UEC_OK) {
1738 USB_HILOGW(MODULE_USB_SERVICE, "ManageDeviceImpl open fail");
1739 continue;
1740 }
1741 if (GetActiveConfig(dev.busNum, dev.devAddr, configIndex) || (configIndex < 1)) {
1742 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1743 Close(dev.busNum, dev.devAddr);
1744 continue;
1745 }
1746 USBConfig configs;
1747 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1748 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1749 Close(dev.busNum, dev.devAddr);
1750 continue;
1751 }
1752 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1753 for (uint32_t i = 0; i < interfaces.size(); i++) {
1754 ManageInterface(dev, interfaces[i].GetId(), disable);
1755 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1756 }
1757 if (disable) {
1758 ReportManageDeviceInfo("DeviceType", it->second, nullptr, false);
1759 }
1760 if (Close(dev.busNum, dev.devAddr) != UEC_OK) {
1761 USB_HILOGW(MODULE_USB_SERVICE, "ManageDeviceImpl Close fail");
1762 }
1763 }
1764 }
1765 return UEC_OK;
1766 }
1767
ManageInterfaceTypeImpl(InterfaceType interfaceType,bool disable)1768 int32_t UsbHostManager::ManageInterfaceTypeImpl(InterfaceType interfaceType, bool disable)
1769 {
1770 auto iterInterface = g_typeMap.find(interfaceType);
1771 if (iterInterface == g_typeMap.end()) {
1772 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::not find interface type");
1773 return UEC_SERVICE_INVALID_VALUE;
1774 }
1775 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1776 if (it->second->GetClass() == BASE_CLASS_HUB) {
1777 continue;
1778 }
1779 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1780 uint8_t configIndex = 0;
1781 if (GetActiveConfig(dev.busNum, dev.devAddr, configIndex) || (configIndex < 1)) {
1782 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1783 continue;
1784 }
1785 USBConfig configs;
1786 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1787 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1788 continue;
1789 }
1790 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1791
1792 for (uint32_t i = 0; i < interfaces.size(); i++) {
1793 int32_t ret = RANDOM_VALUE_INDICATE;
1794 // 0 indicate base class, 1 indicate subclass, 2 indicate protocal. -1 indicate any value.
1795 if ((interfaces[i].GetClass() == iterInterface->second[BASECLASS_INDEX]) && (interfaces[i].GetSubClass() ==
1796 iterInterface->second[SUBCLASS_INDEX] || iterInterface->second[SUBCLASS_INDEX] ==
1797 RANDOM_VALUE_INDICATE) && (interfaces[i].GetProtocol() == iterInterface->second[PROTOCAL_INDEX] ||
1798 iterInterface->second[PROTOCAL_INDEX] == RANDOM_VALUE_INDICATE)) {
1799 ManageInterface(dev, interfaces[i].GetId(), disable);
1800 USB_HILOGI(MODULE_USB_SERVICE, "size %{public}zu, interfaceType: %{public}d, disable: %{public}d",
1801 devices_.size(), static_cast<int32_t>(interfaceType), disable);
1802 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1803 }
1804 if (disable && ret == UEC_OK) {
1805 ReportManageDeviceInfo("InterfaceType", it->second, &interfaces[i], true);
1806 }
1807 }
1808 }
1809 return UEC_OK;
1810 }
1811
ManageDeviceTypeImpl(InterfaceType interfaceType,bool disable)1812 int32_t UsbHostManager::ManageDeviceTypeImpl(InterfaceType interfaceType, bool disable)
1813 {
1814 auto iterInterface = d_typeMap.find(interfaceType);
1815 if (iterInterface == d_typeMap.end()) {
1816 USB_HILOGE(MODULE_USB_SERVICE, "UsbHostManager::not find interface type");
1817 return UEC_SERVICE_INVALID_VALUE;
1818 }
1819 for (auto it = devices_.begin(); it != devices_.end(); ++it) {
1820 if ((it->second->GetClass() == iterInterface->second[BASECLASS_INDEX]) && (it->second->GetSubclass() ==
1821 iterInterface->second[SUBCLASS_INDEX] || iterInterface->second[SUBCLASS_INDEX] ==
1822 RANDOM_VALUE_INDICATE) && (it->second->GetProtocol() == iterInterface->second[PROTOCAL_INDEX] ||
1823 iterInterface->second[PROTOCAL_INDEX] == RANDOM_VALUE_INDICATE)) {
1824 ManageDeviceImpl(it->second->GetVendorId(), it->second->GetProductId(), disable);
1825 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu, interfaceType: %{public}d, disable: %{public}d",
1826 devices_.size(), static_cast<int32_t>(interfaceType), disable);
1827 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1828 }
1829 if (disable) {
1830 ReportManageDeviceInfo("InterfaceType", it->second, nullptr, false);
1831 }
1832 }
1833 return UEC_OK;
1834 }
1835
ReportManageDeviceInfo(const std::string & operationType,UsbDevice * device,const UsbInterface * interface,bool isInterfaceType)1836 void UsbHostManager::ReportManageDeviceInfo(const std::string &operationType, UsbDevice* device,
1837 const UsbInterface* interface, bool isInterfaceType)
1838 {
1839 USB_HILOGI(MODULE_USB_SERVICE, "ReportManageDeviceInfo");
1840 int32_t vid = device->GetVendorId();
1841 int32_t pid = device->GetProductId();
1842 int32_t baseClass = RANDOM_VALUE_INDICATE;
1843 int32_t subClass = RANDOM_VALUE_INDICATE;
1844 int32_t protocol = RANDOM_VALUE_INDICATE;
1845 if (isInterfaceType) {
1846 baseClass = interface->GetClass();
1847 subClass = interface->GetSubClass();
1848 protocol = interface->GetProtocol();
1849 } else {
1850 baseClass = device->GetClass();
1851 subClass = device->GetSubclass();
1852 protocol = device->GetProtocol();
1853 }
1854 HiSysEventWrite(HiSysEvent::Domain::USB, "DEVICE_SECURITY_POLICY",
1855 HiSysEvent::EventType::SECURITY, "SECURITY_POLICY_TYPE", operationType,
1856 "VID", vid,
1857 "PID", pid,
1858 "CLASS", baseClass,
1859 "SUBCLASS", subClass,
1860 "PROTOCOL", protocol);
1861 }
1862 } // namespace USB
1863 } // namespace OHOS
1864