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
16 #include "usb_service.h"
17
18 #include <cstdio>
19 #include <iostream>
20 #include <ipc_skeleton.h>
21 #include <sstream>
22 #include <string>
23 #include <unistd.h>
24 #include <unordered_map>
25 #include "parameters.h"
26 #include "bundle_mgr_interface.h"
27 #include "bundle_mgr_proxy.h"
28 #include "common_timer_errors.h"
29 #include "file_ex.h"
30 #include "if_system_ability_manager.h"
31 #include "iproxy_broker.h"
32 #include "iservice_registry.h"
33 #include "iusb_srv.h"
34 #include "securec.h"
35 #include "system_ability_definition.h"
36 #include "usb_common.h"
37 #include "usb_descriptor_parser.h"
38 #include "usb_errors.h"
39 #include "usb_napi_errors.h"
40 #include "usb_port_manager.h"
41 #include "usb_right_manager.h"
42 #include "usb_right_db_helper.h"
43 #include "tokenid_kit.h"
44 #include "accesstoken_kit.h"
45 #include "mem_mgr_proxy.h"
46 #include "mem_mgr_client.h"
47 #include "usb_function_switch_window.h"
48 #include "usbd_transfer_callback_impl.h"
49 #include "hitrace_meter.h"
50 #include "hisysevent.h"
51
52 using OHOS::sptr;
53 using OHOS::HiviewDFX::HiSysEvent;
54 using namespace OHOS::HDI::Usb::V1_2;
55 using namespace OHOS::Security::AccessToken;
56 namespace OHOS {
57 namespace USB {
58 namespace {
59 constexpr int32_t COMMEVENT_REGISTER_RETRY_TIMES = 10;
60 constexpr int32_t COMMEVENT_REGISTER_WAIT_DELAY_US = 20000;
61 constexpr int32_t SERVICE_STARTUP_MAX_TIME = 30;
62 constexpr uint32_t UNLOAD_SA_TIMER_INTERVAL = 30 * 1000;
63 #if defined(USB_MANAGER_FEATURE_HOST) || defined(USB_MANAGER_FEATURE_DEVICE)
64 constexpr int32_t USB_RIGHT_USERID_INVALID = -1;
65 #endif // USB_MANAGER_FEATURE_HOST || USB_MANAGER_FEATURE_DEVICE
66 constexpr int32_t API_VERSION_ID_18 = 18;
67 constexpr const char *USB_DEFAULT_TOKEN = "UsbServiceTokenId";
68 constexpr const pid_t ROOT_UID = 0;
69 constexpr const pid_t EDM_UID = 3057;
70 } // namespace
71 auto g_serviceInstance = DelayedSpSingleton<UsbService>::GetInstance();
72 const bool G_REGISTER_RESULT =
73 SystemAbility::MakeAndRegisterAbility(DelayedSpSingleton<UsbService>::GetInstance().GetRefPtr());
74
UsbService()75 UsbService::UsbService() : SystemAbility(USB_SYSTEM_ABILITY_ID, true)
76 {
77 #ifdef USB_MANAGER_FEATURE_HOST
78 usbHostManager_ = std::make_shared<UsbHostManager>(nullptr);
79 #endif // USB_MANAGER_FEATURE_HOST
80 usbRightManager_ = std::make_shared<UsbRightManager>();
81 #ifdef USB_MANAGER_FEATURE_PORT
82 usbPortManager_ = std::make_shared<UsbPortManager>();
83 #endif // USB_MANAGER_FEATURE_PORT
84 #ifdef USB_MANAGER_FEATURE_DEVICE
85 usbDeviceManager_ = std::make_shared<UsbDeviceManager>();
86 usbAccessoryManager_ = std::make_shared<UsbAccessoryManager>();
87 #endif // USB_MANAGER_FEATURE_DEVICE
88 usbSerialManager_ = std::make_shared<SERIAL::SerialManager>();
89 #ifndef USB_MANAGER_PASS_THROUGH
90 if (usbd_ == nullptr) {
91 usbd_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
92 } else {
93 USB_HILOGW(MODULE_USB_SERVICE, "%{public}s:usbd_ != nullptr", __func__);
94 }
95 #endif // USB_MANAGER_PASS_THROUGH
96 }
97
~UsbService()98 UsbService::~UsbService() {}
99
100 // LCOV_EXCL_START
101 #ifndef USB_MANAGER_PASS_THROUGH
SetUsbd(const sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> & usbd)102 int32_t UsbService::SetUsbd(const sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> &usbd)
103 {
104 if (usbd == nullptr) {
105 USB_HILOGE(MODULE_USB_SERVICE, "UsbService usbd is nullptr");
106 return UEC_SERVICE_INVALID_VALUE;
107 }
108 if (usbd_ == nullptr) {
109 usbd_ = usbd;
110 } else {
111 USB_HILOGW(MODULE_USB_SERVICE, "%{public}s:usbd_ != nullptr", __func__);
112 }
113 #ifdef USB_MANAGER_FEATURE_PORT
114 if (usbPortManager_ == nullptr) {
115 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
116 return UEC_SERVICE_INVALID_VALUE;
117 }
118 usbPortManager_->SetUsbd(usbd);
119 #endif // USB_MANAGER_FEATURE_PORT
120 #ifdef USB_MANAGER_FEATURE_DEVICE
121 if (usbDeviceManager_ == nullptr) {
122 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
123 return UEC_SERVICE_INVALID_VALUE;
124 }
125 usbDeviceManager_->SetUsbd(usbd);
126
127 if (usbAccessoryManager_ == nullptr) {
128 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbAccessoryManager_");
129 return UEC_SERVICE_INVALID_VALUE;
130 }
131 usbAccessoryManager_->SetUsbd(usbd);
132 #endif // USB_MANAGER_FEATURE_DEVICE
133 return UEC_OK;
134 }
135 #endif // USB_MANAGER_PASS_THROUGH
136 // LCOV_EXCL_STOP
137
138 #ifdef USB_MANAGER_PASS_THROUGH
139 // LCOV_EXCL_START
SystemAbilityStatusChangeListener(sptr<UsbManagerSubscriber> usbManagerSubscriber)140 UsbService::SystemAbilityStatusChangeListener::SystemAbilityStatusChangeListener(
141 sptr<UsbManagerSubscriber> usbManagerSubscriber)
142 : usbManagerSubscriber_(usbManagerSubscriber)
143 {
144 }
145 // LCOV_EXCL_STOP
146
147 // LCOV_EXCL_START
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)148 void UsbService::SystemAbilityStatusChangeListener::OnAddSystemAbility(
149 int32_t systemAbilityId, const std::string &deviceId)
150 {
151 USB_HILOGI(MODULE_USB_SERVICE, "OnAddSystemAbility ID = %{public}d", systemAbilityId);
152 }
153 // LCOV_EXCL_STOP
154
155 // LCOV_EXCL_START
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)156 void UsbService::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
157 int32_t systemAbilityId, const std::string &deviceId)
158 {
159 USB_HILOGI(MODULE_USB_SERVICE, "OnRemoveSystemAbility ID = %{public}d", systemAbilityId);
160 if (systemAbilityId == USB_SYSTEM_ABILITY_ID) {
161 #ifdef USB_MANAGER_FEATURE_HOST
162 sptr<OHOS::HDI::Usb::V2_0::IUsbHostInterface> usbHostInterface_ =
163 OHOS::HDI::Usb::V2_0::IUsbHostInterface::Get("usb_host_interface_service", true);
164 if (usbHostInterface_ != nullptr) {
165 usbHostInterface_->UnbindUsbdHostSubscriber(usbManagerSubscriber_);
166 }
167 #endif // USB_MANAGER_FEATURE_HOST
168 #ifdef USB_MANAGER_FEATURE_DEVICE
169 sptr<OHOS::HDI::Usb::V2_0::IUsbDeviceInterface> usbDeviceInterface_ =
170 OHOS::HDI::Usb::V2_0::IUsbDeviceInterface::Get();
171 if (usbDeviceInterface_ != nullptr) {
172 usbDeviceInterface_->UnbindUsbdDeviceSubscriber(usbManagerSubscriber_);
173 }
174 #endif // USB_MANAGER_FEATURE_DEVICE
175 #ifdef USB_MANAGER_FEATURE_PORT
176 sptr<OHOS::HDI::Usb::V2_0::IUsbPortInterface> usbPortInterface_ =
177 OHOS::HDI::Usb::V2_0::IUsbPortInterface::Get();
178 if (usbPortInterface_ != nullptr) {
179 usbPortInterface_->UnbindUsbdPortSubscriber(usbManagerSubscriber_);
180 }
181 #endif // USB_MANAGER_FEATURE_PORT
182 }
183 }
184 // LCOV_EXCL_STOP
185 #else
186 // LCOV_EXCL_START
SystemAbilityStatusChangeListener(sptr<UsbServiceSubscriber> usbdSubscriber)187 UsbService::SystemAbilityStatusChangeListener::SystemAbilityStatusChangeListener(
188 sptr<UsbServiceSubscriber> usbdSubscriber)
189 : usbdSubscriber_(usbdSubscriber)
190 {
191 }
192 // LCOV_EXCL_STOP
193
194 // LCOV_EXCL_START
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)195 void UsbService::SystemAbilityStatusChangeListener::OnAddSystemAbility(
196 int32_t systemAbilityId, const std::string &deviceId)
197 {
198 USB_HILOGI(MODULE_USB_SERVICE, "OnAddSystemAbility ID = %{public}d", systemAbilityId);
199 }
200 // LCOV_EXCL_STOP
201
202 // LCOV_EXCL_START
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)203 void UsbService::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
204 int32_t systemAbilityId, const std::string &deviceId)
205 {
206 USB_HILOGI(MODULE_USB_SERVICE, "OnRemoveSystemAbility ID = %{public}d", systemAbilityId);
207 if (systemAbilityId == USB_SYSTEM_ABILITY_ID) {
208 sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> usbd_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
209 if (usbd_ != nullptr) {
210 usbd_->UnbindUsbdSubscriber(usbdSubscriber_);
211 }
212 }
213 }
214 // LCOV_EXCL_STOP
215 #endif // USB_MANAGER_PASS_THROUGH
216
217 // LCOV_EXCL_START
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)218 void UsbService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
219 {
220 USB_HILOGI(MODULE_USB_SERVICE, "OnAddSystemAbility systemAbilityId:%{public}d", systemAbilityId);
221 if (systemAbilityId == MEMORY_MANAGER_SA_ID) {
222 Memory::MemMgrClient::GetInstance().NotifyProcessStatus(getpid(), 1, 1, USB_SYSTEM_ABILITY_ID);
223 Memory::MemMgrClient::GetInstance().SetCritical(getpid(), true, USB_SYSTEM_ABILITY_ID);
224 }
225 }
226 // LCOV_EXCL_STOP
227
228 // LCOV_EXCL_START
WaitUsbdService()229 void UsbService::WaitUsbdService()
230 {
231 // wait for the usbd service to start and bind usb service and usbd service
232 int32_t retryTimes = 0;
233 while (retryTimes < SERVICE_STARTUP_MAX_TIME) {
234 if (InitUsbd() && InitSerial()) {
235 break;
236 }
237 sleep(1);
238 retryTimes++;
239
240 if (retryTimes == SERVICE_STARTUP_MAX_TIME) {
241 USB_HILOGE(MODULE_USB_SERVICE, "OnStart call initUsbd or InitSerial failed");
242 return;
243 }
244 }
245 }
246 // LCOV_EXCL_STOP
247
248 // LCOV_EXCL_START
OnStart()249 void UsbService::OnStart()
250 {
251 USB_HILOGI(MODULE_USB_SERVICE, "usb_service OnStart enter");
252 if (ready_) {
253 USB_HILOGE(MODULE_USB_SERVICE, "OnStart is ready, nothing to do");
254 return;
255 }
256
257 if (!(Init())) {
258 USB_HILOGE(MODULE_USB_SERVICE, "OnStart call init fail");
259 return;
260 }
261
262 WaitUsbdService();
263
264 #ifdef USB_MANAGER_FEATURE_PORT
265 if (usbPortManager_ == nullptr) {
266 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
267 return;
268 }
269 usbPortManager_->Init();
270 #endif // USB_MANAGER_FEATURE_PORT
271 #ifdef USB_MANAGER_FEATURE_DEVICE
272 if (usbDeviceManager_ == nullptr) {
273 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
274 return;
275 }
276 (void)usbDeviceManager_->Init();
277 #endif // USB_MANAGER_FEATURE_DEVICE
278 (void)InitUsbRight();
279 ready_ = true;
280 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
281 #ifdef USB_MANAGER_PASS_THROUGH
282 sptr<ISystemAbilityStatusChange> status =
283 new (std::nothrow) SystemAbilityStatusChangeListener(usbManagerSubscriber_);
284 #else
285 sptr<ISystemAbilityStatusChange> status = new (std::nothrow) SystemAbilityStatusChangeListener(usbdSubscriber_);
286 #endif // USB_MANAGER_PASS_THROUGH
287 if (samgrProxy == nullptr || status == nullptr) {
288 USB_HILOGE(MODULE_USB_SERVICE, "samgrProxy or SystemAbilityStatusChangeListener is nullptr");
289 return;
290 }
291 int32_t ret = samgrProxy->SubscribeSystemAbility(USB_SYSTEM_ABILITY_ID, status);
292 if (ret != UEC_OK) {
293 USB_HILOGE(MODULE_USB_SERVICE, "SubscribeSystemAbility failed. ret = %{public}d", ret);
294 return;
295 }
296 AddSystemAbilityListener(MEMORY_MANAGER_SA_ID);
297 USB_HILOGE(MODULE_USB_SERVICE, "OnStart and add system ability success");
298 }
299 // LCOV_EXCL_STOP
300
301 // LCOV_EXCL_START
Init()302 bool UsbService::Init()
303 {
304 USB_HILOGI(MODULE_USB_SERVICE, "usb_service Init enter");
305 if (!Publish(g_serviceInstance)) {
306 USB_HILOGE(MODULE_USB_SERVICE, "OnStart register to system ability manager failed.");
307 return false;
308 }
309
310 while (commEventRetryTimes_ <= COMMEVENT_REGISTER_RETRY_TIMES) {
311 if (!IsCommonEventServiceAbilityExist()) {
312 ++commEventRetryTimes_;
313 usleep(COMMEVENT_REGISTER_WAIT_DELAY_US);
314 } else {
315 commEventRetryTimes_ = 0;
316 break;
317 }
318 }
319 USB_HILOGI(MODULE_USB_SERVICE, "Init success");
320 return true;
321 }
322 // LCOV_EXCL_STOP
323
324 // LCOV_EXCL_START
InitUsbd()325 bool UsbService::InitUsbd()
326 {
327 #ifdef USB_MANAGER_PASS_THROUGH
328 #ifdef USB_MANAGER_FEATURE_PORT
329 if (usbPortManager_ == nullptr || !usbPortManager_->InitUsbPortInterface()) {
330 return false;
331 }
332 #endif // USB_MANAGER_FEATURE_PORT
333 #ifdef USB_MANAGER_FEATURE_HOST
334 if (usbHostManager_ == nullptr || !usbHostManager_->InitUsbHostInterface()) {
335 return false;
336 }
337 #endif // USB_MANAGER_FEATURE_HOST
338 #ifdef USB_MANAGER_FEATURE_DEVICE
339 if (usbAccessoryManager_ == nullptr || !usbAccessoryManager_->InitUsbAccessoryInterface()) {
340 return false;
341 }
342 if (usbDeviceManager_ == nullptr || !usbDeviceManager_->InitUsbDeviceInterface()) {
343 return false;
344 }
345 #endif // USB_MANAGER_FEATURE_DEVICE
346 return true;
347 #else
348 if (usbd_ == nullptr) {
349 usbd_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
350 } else {
351 USB_HILOGW(MODULE_USB_SERVICE, "%{public}s:usbd_ != nullptr", __func__);
352 }
353 if (usbd_ == nullptr) {
354 USB_HILOGE(MODULE_USB_SERVICE, " get usbd_ is nullptr");
355 return false;
356 }
357 usbdSubscriber_ = new (std::nothrow) UsbServiceSubscriber();
358 if (usbdSubscriber_ == nullptr) {
359 USB_HILOGE(MODULE_USB_SERVICE, "Init failed");
360 return false;
361 }
362 recipient_ = new UsbdDeathRecipient();
363 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<HDI::Usb::V1_0::IUsbInterface>(usbd_);
364 if (!remote->AddDeathRecipient(recipient_)) {
365 USB_HILOGE(MODULE_USB_SERVICE, "add DeathRecipient failed");
366 return false;
367 }
368
369 ErrCode ret = usbd_->BindUsbdSubscriber(usbdSubscriber_);
370 USB_HILOGI(MODULE_USB_SERVICE, "entry InitUsbd ret: %{public}d", ret);
371 return SUCCEEDED(ret);
372 #endif // USB_MANAGER_PASS_THROUGH
373 }
374 // LCOV_EXCL_STOP
375
376 // LCOV_EXCL_START
OnStop()377 void UsbService::OnStop()
378 {
379 USB_HILOGI(MODULE_USB_SERVICE, "entry stop service %{public}d", ready_);
380 if (!ready_) {
381 return;
382 }
383 ready_ = false;
384 #ifdef USB_MANAGER_PASS_THROUGH
385 #ifdef USB_MANAGER_FEATURE_HOST
386 if (usbHostManager_ == nullptr) {
387 return;
388 }
389 usbHostManager_->Stop();
390 #endif // USB_MANAGER_FEATURE_HOST
391 #ifdef USB_MANAGER_FEATURE_DEVICE
392 if (usbDeviceManager_ == nullptr) {
393 return;
394 }
395 usbDeviceManager_->Stop();
396 #endif // USB_MANAGER_FEATURE_DEVICE
397 #ifdef USB_MANAGER_FEATURE_PORT
398 if (usbPortManager_ == nullptr) {
399 return;
400 }
401 usbPortManager_->Stop();
402 #endif // USB_MANAGER_FEATURE_PORT
403 #else
404 if (usbd_ == nullptr) {
405 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
406 return;
407 }
408 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<HDI::Usb::V1_0::IUsbInterface>(usbd_);
409 remote->RemoveDeathRecipient(recipient_);
410 recipient_.clear();
411 usbd_->UnbindUsbdSubscriber(usbdSubscriber_);
412 Memory::MemMgrClient::GetInstance().NotifyProcessStatus(getpid(), 1, 0, USB_SYSTEM_ABILITY_ID);
413 #endif // USB_MANAGER_PASS_THROUGH
414 }
415 // LCOV_EXCL_STOP
416
417 // LCOV_EXCL_START
IsCommonEventServiceAbilityExist()418 bool UsbService::IsCommonEventServiceAbilityExist()
419 {
420 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
421 if (sm == nullptr) {
422 USB_HILOGE(MODULE_USB_SERVICE,
423 "IsCommonEventServiceAbilityExist Get ISystemAbilityManager "
424 "failed, no SystemAbilityManager");
425 return false;
426 }
427 sptr<IRemoteObject> remote = sm->CheckSystemAbility(COMMON_EVENT_SERVICE_ID);
428 if (!remote) {
429 USB_HILOGE(MODULE_USB_SERVICE, "No CesServiceAbility");
430 return false;
431 }
432 return true;
433 }
434 // LCOV_EXCL_STOP
435
436 #ifdef USB_MANAGER_FEATURE_HOST
437 // LCOV_EXCL_START
OpenDevice(uint8_t busNum,uint8_t devAddr)438 int32_t UsbService::OpenDevice(uint8_t busNum, uint8_t devAddr)
439 {
440 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
441 return UEC_SERVICE_PERMISSION_DENIED;
442 }
443
444 if (usbHostManager_ == nullptr) {
445 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
446 return UEC_SERVICE_INVALID_VALUE;
447 }
448 int32_t ret = usbHostManager_->OpenDevice(busNum, devAddr);
449 if (ret != UEC_OK) {
450 USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret:%{public}d", ret);
451 }
452
453 return ret;
454 }
455 // LCOV_EXCL_STOP
456
457 // LCOV_EXCL_START
Close(uint8_t busNum,uint8_t devAddr)458 int32_t UsbService::Close(uint8_t busNum, uint8_t devAddr)
459 {
460 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
461 return UEC_SERVICE_PERMISSION_DENIED;
462 }
463
464 if (usbHostManager_ == nullptr) {
465 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
466 return UEC_SERVICE_INVALID_VALUE;
467 }
468 return usbHostManager_->Close(busNum, devAddr);
469 }
470 // LCOV_EXCL_STOP
471
472 // LCOV_EXCL_START
ResetDevice(uint8_t busNum,uint8_t devAddr)473 int32_t UsbService::ResetDevice(uint8_t busNum, uint8_t devAddr)
474 {
475 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
476 return UEC_SERVICE_PERMISSION_DENIED;
477 }
478
479 if (usbHostManager_ == nullptr) {
480 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
481 return UEC_SERVICE_INVALID_VALUE;
482 }
483 int32_t ret = usbHostManager_->ResetDevice(busNum, devAddr);
484 if (ret != UEC_OK) {
485 USB_HILOGE(MODULE_USB_SERVICE, "ResetDevice failed ret:%{public}d", ret);
486 }
487
488 return ret;
489 }
490 // LCOV_EXCL_STOP
491
492 // LCOV_EXCL_START
ClaimInterface(uint8_t busNum,uint8_t devAddr,uint8_t interface,uint8_t force)493 int32_t UsbService::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface, uint8_t force)
494 {
495 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
496 return UEC_SERVICE_PERMISSION_DENIED;
497 }
498
499 if (usbHostManager_ == nullptr) {
500 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
501 return UEC_SERVICE_INVALID_VALUE;
502 }
503 int32_t ret = usbHostManager_->ClaimInterface(busNum, devAddr, interface, force);
504 if (ret != UEC_OK) {
505 USB_HILOGE(MODULE_USB_SERVICE, "claim interface false.");
506 }
507 return ret;
508 }
509 // LCOV_EXCL_STOP
510
511 // LCOV_EXCL_START
SetInterface(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,uint8_t altIndex)512 int32_t UsbService::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t altIndex)
513 {
514 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
515 return UEC_SERVICE_PERMISSION_DENIED;
516 }
517
518 if (usbHostManager_ == nullptr) {
519 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
520 return UEC_SERVICE_INVALID_VALUE;
521 }
522 return usbHostManager_->SetInterface(busNum, devAddr, interfaceid, altIndex);
523 }
524 // LCOV_EXCL_STOP
525
526 // LCOV_EXCL_START
ReleaseInterface(uint8_t busNum,uint8_t devAddr,uint8_t interface)527 int32_t UsbService::ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface)
528 {
529 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
530 return UEC_SERVICE_PERMISSION_DENIED;
531 }
532
533 if (usbHostManager_ == nullptr) {
534 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
535 return UEC_SERVICE_INVALID_VALUE;
536 }
537 int32_t ret = usbHostManager_->ReleaseInterface(busNum, devAddr, interface);
538 if (ret == HDF_DEV_ERR_OP) {
539 USB_HILOGE(MODULE_USB_SERVICE, "ReleaseInterface failed.");
540 return UEC_INTERFACE_INVALID_OPERATION;
541 }
542 return ret;
543 }
544 // LCOV_EXCL_STOP
545
546 // LCOV_EXCL_START
SetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t configIndex)547 int32_t UsbService::SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t configIndex)
548 {
549 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
550 return UEC_SERVICE_PERMISSION_DENIED;
551 }
552
553 if (usbHostManager_ == nullptr) {
554 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
555 return UEC_SERVICE_INVALID_VALUE;
556 }
557 return usbHostManager_->SetActiveConfig(busNum, devAddr, configIndex);
558 }
559 // LCOV_EXCL_STOP
560
561 // LCOV_EXCL_START
ManageGlobalInterface(bool disable)562 int32_t UsbService::ManageGlobalInterface(bool disable)
563 {
564 if (!IsCallerValid()) {
565 USB_HILOGE(MODULE_USB_SERVICE, "not root or edm process.");
566 return UEC_SERVICE_INVALID_OPERATION;
567 }
568 if (PreCallFunction() != UEC_OK) {
569 USB_HILOGE(MODULE_USB_SERVICE, "PreCallFunction failed");
570 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
571 }
572 return usbHostManager_->ManageGlobalInterface(disable);
573 }
574 // LCOV_EXCL_STOP
575
576 // LCOV_EXCL_START
ManageDevice(int32_t vendorId,int32_t productId,bool disable)577 int32_t UsbService::ManageDevice(int32_t vendorId, int32_t productId, bool disable)
578 {
579 if (!IsCallerValid()) {
580 USB_HILOGE(MODULE_USB_SERVICE, "not root or edm process.");
581 return UEC_SERVICE_INVALID_OPERATION;
582 }
583 if (PreCallFunction() != UEC_OK) {
584 USB_HILOGE(MODULE_USB_SERVICE, "PreCallFunction failed");
585 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
586 }
587 return usbHostManager_->ManageDevice(vendorId, productId, disable);
588 }
589 // LCOV_EXCL_STOP
590
591 // LCOV_EXCL_START
ManageInterfaceType(const std::vector<UsbDeviceTypeInfo> & devTypeInfo,bool disable)592 int32_t UsbService::ManageInterfaceType(const std::vector<UsbDeviceTypeInfo> &devTypeInfo, bool disable)
593 {
594 if (!IsCallerValid()) {
595 USB_HILOGE(MODULE_USB_SERVICE, "not root or edm process.");
596 return UEC_SERVICE_INVALID_OPERATION;
597 }
598 if (PreCallFunction() != UEC_OK) {
599 USB_HILOGE(MODULE_USB_SERVICE, "PreCallFunction failed");
600 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
601 }
602 std::vector<UsbDeviceType> disableType;
603 UsbDeviceTypeChange(disableType, devTypeInfo);
604 return usbHostManager_->ManageInterfaceType(disableType, disable);
605 }
606 // LCOV_EXCL_STOP
607
608 // LCOV_EXCL_START
UsbAttachKernelDriver(uint8_t busNum,uint8_t devAddr,uint8_t interface)609 int32_t UsbService::UsbAttachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interface)
610 {
611 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
612 return UEC_SERVICE_PERMISSION_DENIED;
613 }
614
615 if (usbHostManager_ == nullptr) {
616 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
617 return UEC_SERVICE_INVALID_VALUE;
618 }
619
620 int32_t ret = usbHostManager_->UsbAttachKernelDriver(busNum, devAddr, interface);
621 if (ret != UEC_OK) {
622 USB_HILOGE(MODULE_USB_SERVICE, "UsbAttachKernelDriver ManageInterface false.");
623 }
624 return ret;
625 }
626 // LCOV_EXCL_STOP
627
628 // LCOV_EXCL_START
UsbDetachKernelDriver(uint8_t busNum,uint8_t devAddr,uint8_t interface)629 int32_t UsbService::UsbDetachKernelDriver(uint8_t busNum, uint8_t devAddr, uint8_t interface)
630 {
631 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
632 return UEC_SERVICE_PERMISSION_DENIED;
633 }
634
635 if (usbHostManager_ == nullptr) {
636 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
637 return UEC_SERVICE_INVALID_VALUE;
638 }
639
640 int32_t ret = usbHostManager_->UsbDetachKernelDriver(busNum, devAddr, interface);
641 if (ret != UEC_OK) {
642 USB_HILOGE(MODULE_USB_SERVICE, "UsbDetachKernelDriver ManageInterface false.");
643 }
644 return ret;
645 }
646 // LCOV_EXCL_STOP
647
648 // LCOV_EXCL_START
ClearHalt(uint8_t busNum,uint8_t devAddr,uint8_t interfaceId,uint8_t endpointId)649 int32_t UsbService::ClearHalt(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId)
650 {
651 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
652 return UEC_SERVICE_PERMISSION_DENIED;
653 }
654
655 if (usbHostManager_ == nullptr) {
656 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
657 return UEC_SERVICE_INVALID_VALUE;
658 }
659 int32_t ret = usbHostManager_->ClearHalt(busNum, devAddr, interfaceId, endpointId);
660 if (ret != UEC_OK) {
661 USB_HILOGE(MODULE_USB_SERVICE, "ClearHalt error ret:%{public}d", ret);
662 }
663 return ret;
664 }
665 // LCOV_EXCL_STOP
666
667 // LCOV_EXCL_START
AddDevice(uint8_t busNum,uint8_t devAddr)668 bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
669 {
670 if (usbHostManager_ == nullptr) {
671 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
672 return false;
673 }
674 UsbDevice *devInfo = new (std::nothrow) UsbDevice();
675 if (devInfo == nullptr) {
676 USB_HILOGE(MODULE_USB_SERVICE, "new failed");
677 return false;
678 }
679
680 int32_t ret = GetDeviceInfo(busNum, devAddr, *devInfo);
681 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceInfo ret=%{public}d", ret);
682 if (ret != UEC_OK) {
683 delete devInfo;
684 return false;
685 }
686
687 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
688 std::string uniqueName = std::to_string(devInfo->GetVendorId()) + "-" + std::to_string(devInfo->GetProductId()) +
689 "-" + devInfo->GetmSerial();
690 USB_HILOGI(MODULE_USB_SERVICE, "map+: %{public}s", name.c_str());
691 {
692 std::lock_guard<std::mutex> guard(mutex_);
693 deviceVidPidMap_.insert(std::pair<std::string, std::string>(name, uniqueName));
694 }
695
696 usbHostManager_->AddDevice(devInfo);
697 usbHostManager_->ExecuteStrategy(devInfo);
698 return true;
699 }
700 // LCOV_EXCL_STOP
701
702 // LCOV_EXCL_START
DelDevice(uint8_t busNum,uint8_t devAddr)703 bool UsbService::DelDevice(uint8_t busNum, uint8_t devAddr)
704 {
705 USB_HILOGI(MODULE_USBD, "entry");
706 int32_t ret = Close(busNum, devAddr);
707 if (ret != UEC_OK) {
708 USB_HILOGE(MODULE_USBD, "Close device failed width ret = %{public}d", ret);
709 }
710
711 if (usbHostManager_ == nullptr || usbRightManager_ == nullptr) {
712 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_ or usbRightManager_");
713 return false;
714 }
715
716 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
717 if (!usbRightManager_->RemoveDeviceAllRight(GetDeviceVidPidSerialNumber(name))) {
718 USB_HILOGW(MODULE_USB_SERVICE, "remove right failed: %{public}s", name.c_str());
719 }
720
721 {
722 std::lock_guard<std::mutex> guard(mutex_);
723 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
724 if (it->first == name) {
725 deviceVidPidMap_.erase(it);
726 break;
727 }
728 }
729 }
730 {
731 std::lock_guard<std::mutex> lock(openedFdsMutex_);
732 auto iter = openedFds_.find({busNum, devAddr});
733 if (iter != openedFds_.end()) {
734 int32_t fd = iter->second;
735 int res = close(fd);
736 openedFds_.erase(iter);
737 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d close %{public}d ret = %{public}d",
738 __func__, __LINE__, fd, res);
739 } else {
740 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d not opened", __func__, __LINE__);
741 }
742 }
743
744 return usbHostManager_->DelDevice(busNum, devAddr);
745 }
746 // LCOV_EXCL_STOP
747
748 // LCOV_EXCL_START
GetDevices(std::vector<UsbDevice> & deviceList)749 int32_t UsbService::GetDevices(std::vector<UsbDevice> &deviceList)
750 {
751 if (usbHostManager_ == nullptr) {
752 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
753 return UEC_SERVICE_INVALID_VALUE;
754 }
755 return usbHostManager_->GetDevices(deviceList);
756 }
757 // LCOV_EXCL_STOP
758
759 // LCOV_EXCL_START
GetDeviceInfo(uint8_t busNum,uint8_t devAddr,UsbDevice & dev)760 int32_t UsbService::GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev)
761 {
762 if (usbHostManager_ == nullptr) {
763 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
764 return UEC_SERVICE_INVALID_VALUE;
765 }
766 return usbHostManager_->GetDeviceInfo(busNum, devAddr, dev);
767 }
768 // LCOV_EXCL_STOP
769
770 // LCOV_EXCL_START
GetDeviceInfoDescriptor(const UsbDev & uDev,std::vector<uint8_t> & descriptor,UsbDevice & dev)771 int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint8_t> &descriptor, UsbDevice &dev)
772 {
773 if (usbHostManager_ == nullptr) {
774 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
775 return UEC_SERVICE_INVALID_VALUE;
776 }
777 return usbHostManager_->GetDeviceInfoDescriptor(uDev, descriptor, dev);
778 }
779 // LCOV_EXCL_STOP
780
781 // LCOV_EXCL_START
GetConfigDescriptor(UsbDevice & dev,std::vector<uint8_t> & descriptor)782 int32_t UsbService::GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &descriptor)
783 {
784 if (usbHostManager_ == nullptr) {
785 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
786 return UEC_SERVICE_INVALID_VALUE;
787 }
788 return usbHostManager_->GetConfigDescriptor(dev, descriptor);
789 }
790 // LCOV_EXCL_STOP
791
792 // LCOV_EXCL_START
GetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t & configIndex)793 int32_t UsbService::GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t &configIndex)
794 {
795 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
796 return UEC_SERVICE_PERMISSION_DENIED;
797 }
798 if (usbHostManager_ == nullptr) {
799 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
800 return UEC_SERVICE_INVALID_VALUE;
801 }
802 return usbHostManager_->GetActiveConfig(busNum, devAddr, configIndex);
803 }
804 // LCOV_EXCL_STOP
805
806 // LCOV_EXCL_START
GetRawDescriptor(uint8_t busNum,uint8_t devAddr,std::vector<uint8_t> & bufferData)807 int32_t UsbService::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vector<uint8_t> &bufferData)
808 {
809 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
810 return UEC_SERVICE_PERMISSION_DENIED;
811 }
812
813 if (usbHostManager_ == nullptr) {
814 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
815 return UEC_SERVICE_INVALID_VALUE;
816 }
817 int32_t ret = usbHostManager_->GetRawDescriptor(busNum, devAddr, bufferData);
818 if (ret != UEC_OK) {
819 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
820 }
821 return ret;
822 }
823 // LCOV_EXCL_STOP
824
825 // LCOV_EXCL_START
GetFileDescriptor(uint8_t busNum,uint8_t devAddr,int32_t & fd)826 int32_t UsbService::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &fd)
827 {
828 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
829 return UEC_SERVICE_PERMISSION_DENIED;
830 }
831
832 if (usbHostManager_ == nullptr) {
833 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
834 return UEC_SERVICE_INVALID_VALUE;
835 }
836 int32_t ret = usbHostManager_->GetFileDescriptor(busNum, devAddr, fd);
837 if (ret != UEC_OK) {
838 USB_HILOGE(MODULE_USB_SERVICE, "get fd error ret:%{public}d", ret);
839 } else {
840 std::lock_guard<std::mutex> lock(openedFdsMutex_);
841 auto iter = openedFds_.find({busNum, devAddr});
842 if (iter != openedFds_.end()) {
843 int32_t oldFd = iter->second;
844 int res = close(oldFd);
845 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d close old %{public}d ret = %{public}d",
846 __func__, __LINE__, oldFd, res);
847 } else {
848 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d first time get fd", __func__, __LINE__);
849 }
850 openedFds_[{busNum, devAddr}] = fd;
851 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d opened %{public}d", __func__, __LINE__, fd);
852 }
853 return ret;
854 }
855 // LCOV_EXCL_STOP
856
857 // LCOV_EXCL_START
GetDeviceSpeed(uint8_t busNum,uint8_t devAddr,uint8_t & speed)858 int32_t UsbService::GetDeviceSpeed(uint8_t busNum, uint8_t devAddr, uint8_t &speed)
859 {
860 if (PreCallFunction() != UEC_OK) {
861 USB_HILOGE(MODULE_USB_SERVICE, "PreCallFunction failed");
862 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
863 }
864
865 int32_t ret = usbHostManager_->GetDeviceSpeed(busNum, devAddr, speed);
866 if (ret != UEC_OK) {
867 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
868 }
869 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceSpeedImpl:%{public}u", speed);
870 return ret;
871 }
872 // LCOV_EXCL_STOP
873
874 // LCOV_EXCL_START
GetInterfaceActiveStatus(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,bool & unactivated)875 int32_t UsbService::GetInterfaceActiveStatus(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, bool &unactivated)
876 {
877 if (PreCallFunction() != UEC_OK) {
878 USB_HILOGE(MODULE_USB_SERVICE, "PreCallFunction failed");
879 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
880 }
881
882 int32_t ret = usbHostManager_->GetInterfaceActiveStatus(busNum, devAddr, interfaceid, unactivated);
883 if (ret != UEC_OK) {
884 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
885 }
886 return ret;
887 }
888 // LCOV_EXCL_STOP
889
890 // LCOV_EXCL_START
GetDeviceProductName(const std::string & deviceName,std::string & productName)891 bool UsbService::GetDeviceProductName(const std::string &deviceName, std::string &productName)
892 {
893 if (usbHostManager_ == nullptr) {
894 USB_HILOGE(MODULE_USB_SERVICE, "usbHostManager_ is nullptr");
895 return false;
896 }
897 return usbHostManager_->GetProductName(deviceName, productName);
898 }
899 // LCOV_EXCL_STOP
900
901 // LCOV_EXCL_START
BulkTransferRead(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,std::vector<uint8_t> & bufferData,int32_t timeOut)902 int32_t UsbService::BulkTransferRead(
903 uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep, std::vector<uint8_t> &bufferData, int32_t timeOut)
904 {
905 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
906 return UEC_SERVICE_PERMISSION_DENIED;
907 }
908 if (usbHostManager_ == nullptr) {
909 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
910 return UEC_SERVICE_INVALID_VALUE;
911 }
912 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
913 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
914 int32_t ret = usbHostManager_->BulkTransferRead(devInfo, pipe, bufferData, timeOut);
915 if (ret != UEC_OK) {
916 USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferRead error ret:%{public}d", ret);
917 }
918 return ret;
919 }
920 // LCOV_EXCL_STOP
921
922 // LCOV_EXCL_START
BulkTransferReadwithLength(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,int32_t length,std::vector<uint8_t> & bufferData,int32_t timeOut)923 int32_t UsbService::BulkTransferReadwithLength(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep,
924 int32_t length, std::vector<uint8_t> &bufferData, int32_t timeOut)
925 {
926 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
927 return UEC_SERVICE_PERMISSION_DENIED;
928 }
929 if (usbHostManager_ == nullptr) {
930 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
931 return UEC_SERVICE_INVALID_VALUE;
932 }
933 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
934 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
935 int32_t ret = usbHostManager_->BulkTransferReadwithLength(devInfo, pipe, length, bufferData, timeOut);
936 if (ret != UEC_OK) {
937 USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferRead error ret:%{public}d", ret);
938 }
939 return ret;
940 }
941 // LCOV_EXCL_STOP
942
943 // LCOV_EXCL_START
BulkTransferWrite(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,const std::vector<uint8_t> & bufferData,int32_t timeOut)944 int32_t UsbService::BulkTransferWrite(
945 uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep, const std::vector<uint8_t> &bufferData, int32_t timeOut)
946 {
947 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
948 return UEC_SERVICE_PERMISSION_DENIED;
949 }
950 if (usbHostManager_ == nullptr) {
951 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
952 return UEC_SERVICE_INVALID_VALUE;
953 }
954 HDI::Usb::V1_0::UsbDev dev = {busNum, devAddr};
955 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
956 int32_t ret = usbHostManager_->BulkTransferWrite(dev, pipe, bufferData, timeOut);
957 if (ret != UEC_OK) {
958 USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferWrite error ret:%{public}d", ret);
959 }
960 return ret;
961 }
962 // LCOV_EXCL_STOP
963
964 // LCOV_EXCL_START
ControlTransfer(uint8_t busNum,uint8_t devAddr,const UsbCtlSetUp & ctrlParams,std::vector<uint8_t> & bufferData)965 int32_t UsbService::ControlTransfer(uint8_t busNum, uint8_t devAddr,
966 const UsbCtlSetUp& ctrlParams, std::vector<uint8_t> &bufferData)
967 {
968 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
969 return UEC_SERVICE_PERMISSION_DENIED;
970 }
971
972 if (usbHostManager_ == nullptr) {
973 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
974 return UEC_SERVICE_INVALID_VALUE;
975 }
976 HDI::Usb::V1_0::UsbCtrlTransfer ctrl;
977 UsbCtrlTransferChange(ctrl, ctrlParams);
978 HDI::Usb::V1_0::UsbDev dev = {busNum, devAddr};
979 return usbHostManager_->ControlTransfer(dev, ctrl, bufferData);
980 }
981 // LCOV_EXCL_STOP
982
UsbCtrlTransferChange(HDI::Usb::V1_0::UsbCtrlTransfer & param,const UsbCtlSetUp & ctlSetup)983 void UsbService::UsbCtrlTransferChange(HDI::Usb::V1_0::UsbCtrlTransfer ¶m, const UsbCtlSetUp &ctlSetup)
984 {
985 param.requestType = ctlSetup.reqType;
986 param.requestCmd = ctlSetup.reqCmd ;
987 param.value = ctlSetup.value;
988 param.index = ctlSetup.index;
989 param.timeout = ctlSetup.length;
990 return;
991 }
992
UsbCtrlTransferChange(HDI::Usb::V1_2::UsbCtrlTransferParams & param,const UsbCtlSetUp & ctlSetup)993 void UsbService::UsbCtrlTransferChange(HDI::Usb::V1_2::UsbCtrlTransferParams ¶m, const UsbCtlSetUp &ctlSetup)
994 {
995 param.requestType = ctlSetup.reqType;
996 param.requestCmd = ctlSetup.reqCmd ;
997 param.value = ctlSetup.value;
998 param.index = ctlSetup.index;
999 param.length = ctlSetup.length;
1000 param.timeout = ctlSetup.length;
1001 return;
1002 }
1003
1004 // LCOV_EXCL_START
UsbControlTransfer(uint8_t busNum,uint8_t devAddr,const UsbCtlSetUp & ctrlParams,std::vector<uint8_t> & bufferData)1005 int32_t UsbService::UsbControlTransfer(
1006 uint8_t busNum, uint8_t devAddr, const UsbCtlSetUp& ctrlParams, std::vector<uint8_t> &bufferData)
1007 {
1008 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1009 return UEC_SERVICE_PERMISSION_DENIED;
1010 }
1011
1012 if (usbHostManager_ == nullptr) {
1013 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1014 return UEC_SERVICE_INVALID_VALUE;
1015 }
1016 HDI::Usb::V1_0::UsbDev dev = {busNum, devAddr};
1017 HDI::Usb::V1_2::UsbCtrlTransferParams ctlSetUp;
1018 UsbCtrlTransferChange(ctlSetUp, ctrlParams);
1019 return usbHostManager_->UsbControlTransfer(dev, ctlSetUp, bufferData);
1020 }
1021 // LCOV_EXCL_STOP
1022
1023 // LCOV_EXCL_START
RequestQueue(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,const std::vector<uint8_t> & clientData,const std::vector<uint8_t> & bufferData)1024 int32_t UsbService::RequestQueue(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep,
1025 const std::vector<uint8_t> &clientData, const std::vector<uint8_t> &bufferData)
1026 {
1027 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1028 return UEC_SERVICE_PERMISSION_DENIED;
1029 }
1030
1031 if (usbHostManager_ == nullptr) {
1032 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1033 return UEC_SERVICE_INVALID_VALUE;
1034 }
1035 HDI::Usb::V1_0::UsbDev dev = {busNum, devAddr};
1036 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1037 int32_t ret = usbHostManager_->RequestQueue(dev, pipe, clientData, bufferData);
1038 if (ret != UEC_OK) {
1039 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
1040 }
1041 return ret;
1042 }
1043 // LCOV_EXCL_STOP
1044
1045 // LCOV_EXCL_START
RequestWait(uint8_t busNum,uint8_t devAddr,int32_t timeOut,std::vector<uint8_t> & clientData,std::vector<uint8_t> & bufferData)1046 int32_t UsbService::RequestWait(uint8_t busNum, uint8_t devAddr, int32_t timeOut,
1047 std::vector<uint8_t> &clientData, std::vector<uint8_t> &bufferData)
1048 {
1049 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1050 return UEC_SERVICE_PERMISSION_DENIED;
1051 }
1052
1053 if (usbHostManager_ == nullptr) {
1054 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1055 return UEC_SERVICE_INVALID_VALUE;
1056 }
1057 HDI::Usb::V1_0::UsbDev dev = {busNum, devAddr};
1058 int32_t ret = usbHostManager_->RequestWait(dev, timeOut, clientData, bufferData);
1059 if (ret != UEC_OK) {
1060 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
1061 }
1062 return ret;
1063 }
1064 // LCOV_EXCL_STOP
1065
1066 // LCOV_EXCL_START
RequestCancel(uint8_t busNum,uint8_t devAddr,uint8_t interfaceId,uint8_t endpointId)1067 int32_t UsbService::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId)
1068 {
1069 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1070 return UEC_SERVICE_PERMISSION_DENIED;
1071 }
1072
1073 if (usbHostManager_ == nullptr) {
1074 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1075 return UEC_SERVICE_INVALID_VALUE;
1076 }
1077 return usbHostManager_->RequestCancel(busNum, devAddr, interfaceId, endpointId);
1078 }
1079 // LCOV_EXCL_STOP
1080
1081 // LCOV_EXCL_START
RegBulkCallback(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,const sptr<IRemoteObject> & cb)1082 int32_t UsbService::RegBulkCallback(uint8_t busNum, uint8_t devAddr,
1083 const USBEndpoint &ep, const sptr<IRemoteObject> &cb)
1084 {
1085 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1086 return UEC_SERVICE_PERMISSION_DENIED;
1087 }
1088
1089 if (usbHostManager_ == nullptr) {
1090 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1091 return UEC_SERVICE_INVALID_VALUE;
1092 }
1093 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1094 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1095 int32_t ret = usbHostManager_->RegBulkCallback(devInfo, pipe, cb);
1096 if (ret != UEC_OK) {
1097 USB_HILOGE(MODULE_USB_SERVICE, "RegBulkCallback error ret:%{public}d", ret);
1098 }
1099 return ret;
1100 }
1101 // LCOV_EXCL_STOP
1102
1103 // LCOV_EXCL_START
UsbCancelTransfer(uint8_t busNum,uint8_t devAddr,int32_t endpoint)1104 int32_t UsbService::UsbCancelTransfer(uint8_t busNum, uint8_t devAddr, int32_t endpoint)
1105 {
1106 USB_HILOGI(MODULE_USBD, "UsbService UsbCancelTransfer enter");
1107 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1108 return UEC_SERVICE_PERMISSION_DENIED;
1109 }
1110 if (usbHostManager_ == nullptr) {
1111 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1112 return UEC_SERVICE_INVALID_VALUE;
1113 }
1114 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1115 int32_t ret = usbHostManager_->UsbCancelTransfer(devInfo, endpoint);
1116 if (ret != UEC_OK) {
1117 USB_HILOGE(MODULE_USB_SERVICE, "UsbCancelTransfer error ret:%{public}d", ret);
1118 }
1119 return ret;
1120 }
1121 // LCOV_EXCL_STOP
1122
UsbTransInfoChange(HDI::Usb::V1_2::USBTransferInfo & info,const UsbTransInfo & param)1123 void UsbService::UsbTransInfoChange(HDI::Usb::V1_2::USBTransferInfo &info, const UsbTransInfo ¶m)
1124 {
1125 info.endpoint = param.endpoint;
1126 info.flags = param.flags;
1127 info.type = param.type;
1128 info.timeOut = param.timeOut;
1129 info.length = param.length;
1130 info.userData = param.userData;
1131 info.numIsoPackets = param.numIsoPackets;
1132 return;
1133 }
1134
1135 // LCOV_EXCL_START
UsbSubmitTransfer(uint8_t busNum,uint8_t devAddr,const UsbTransInfo & param,const sptr<IRemoteObject> & cb,int32_t fd,int32_t memSize)1136 int32_t UsbService::UsbSubmitTransfer(uint8_t busNum, uint8_t devAddr, const UsbTransInfo ¶m,
1137 const sptr<IRemoteObject> &cb, int32_t fd, int32_t memSize)
1138 {
1139 USB_HILOGI(MODULE_USBD, "UsbService UsbSubmitTransfer enter");
1140 if (cb == nullptr) {
1141 USB_HILOGE(MODULE_USB_SERVICE, "UsbService UsbSubmitTransfer cb is nullptr");
1142 return UEC_SERVICE_INVALID_VALUE;
1143 }
1144 HDI::Usb::V1_2::USBTransferInfo info;
1145 UsbTransInfoChange(info, param);
1146 sptr<Ashmem> ashmem = new Ashmem(fd, memSize);
1147 if (ashmem == nullptr) {
1148 USB_HILOGE(MODULE_USB_SERVICE, "UsbService UsbSubmitTransfer error ashmem");
1149 return UEC_SERVICE_INVALID_VALUE;
1150 }
1151 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1152 return UEC_SERVICE_PERMISSION_DENIED;
1153 }
1154 if (usbHostManager_ == nullptr) {
1155 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1156 return UEC_SERVICE_INVALID_VALUE;
1157 }
1158 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1159 int32_t ret = usbHostManager_->UsbSubmitTransfer(devInfo, info, cb, ashmem);
1160 return ret;
1161 }
1162 // LCOV_EXCL_STOP
1163
1164 // LCOV_EXCL_START
UnRegBulkCallback(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep)1165 int32_t UsbService::UnRegBulkCallback(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep)
1166 {
1167 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1168 return UEC_SERVICE_PERMISSION_DENIED;
1169 }
1170
1171 if (usbHostManager_ == nullptr) {
1172 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1173 return UEC_SERVICE_INVALID_VALUE;
1174 }
1175 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1176 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1177 int32_t ret = usbHostManager_->UnRegBulkCallback(devInfo, pipe);
1178 if (ret != UEC_OK) {
1179 USB_HILOGE(MODULE_USB_SERVICE, "UnRegBulkCallback error ret:%{public}d", ret);
1180 }
1181 return ret;
1182 }
1183 // LCOV_EXCL_STOP
1184
1185 // LCOV_EXCL_START
BulkRead(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,int32_t fd,int32_t memSize)1186 int32_t UsbService::BulkRead(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep, int32_t fd, int32_t memSize)
1187 {
1188 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1189 return UEC_SERVICE_PERMISSION_DENIED;
1190 }
1191
1192 if (usbHostManager_ == nullptr) {
1193 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1194 return UEC_SERVICE_INVALID_VALUE;
1195 }
1196 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1197 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1198 sptr<Ashmem> ashmem = new Ashmem(fd, memSize);
1199 int32_t ret = usbHostManager_->BulkRead(devInfo, pipe, ashmem);
1200 if (ret != UEC_OK) {
1201 USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ret:%{public}d", ret);
1202 }
1203 return ret;
1204 }
1205 // LCOV_EXCL_STOP
1206
1207 // LCOV_EXCL_START
BulkWrite(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep,int32_t fd,int32_t memSize)1208 int32_t UsbService::BulkWrite(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep, int32_t fd, int32_t memSize)
1209 {
1210 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1211 return UEC_SERVICE_PERMISSION_DENIED;
1212 }
1213
1214 if (usbHostManager_ == nullptr) {
1215 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1216 return UEC_SERVICE_INVALID_VALUE;
1217 }
1218 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1219 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1220 sptr<Ashmem> ashmem = new Ashmem(fd, memSize);
1221 int32_t ret = usbHostManager_->BulkWrite(devInfo, pipe, ashmem);
1222 if (ret != UEC_OK) {
1223 USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ret:%{public}d", ret);
1224 }
1225 return ret;
1226 }
1227 // LCOV_EXCL_STOP
1228
1229 // LCOV_EXCL_START
BulkCancel(uint8_t busNum,uint8_t devAddr,const USBEndpoint & ep)1230 int32_t UsbService::BulkCancel(uint8_t busNum, uint8_t devAddr, const USBEndpoint &ep)
1231 {
1232 if (!UsbService::CheckDevicePermission(busNum, devAddr)) {
1233 return UEC_SERVICE_PERMISSION_DENIED;
1234 }
1235
1236 if (usbHostManager_ == nullptr) {
1237 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbHostManager_ is nullptr");
1238 return UEC_SERVICE_INVALID_VALUE;
1239 }
1240 HDI::Usb::V1_0::UsbDev devInfo = {busNum, devAddr};
1241 UsbPipe pipe = {ep.GetInterfaceId(), ep.GetAddress()};
1242 int32_t ret = usbHostManager_->BulkCancel(devInfo, pipe);
1243 if (ret != UEC_OK) {
1244 USB_HILOGE(MODULE_USB_SERVICE, "BulkCancel error ret:%{public}d", ret);
1245 }
1246 return ret;
1247 }
1248 // LCOV_EXCL_STOP
1249
1250 // LCOV_EXCL_START
CheckDevicePermission(uint8_t busNum,uint8_t devAddr)1251 bool UsbService::CheckDevicePermission(uint8_t busNum, uint8_t devAddr)
1252 {
1253 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
1254 if (!UsbService::HasRight(name)) {
1255 USB_HILOGE(MODULE_USB_SERVICE, "No permission");
1256 return false;
1257 }
1258 return true;
1259 }
1260 // LCOV_EXCL_STOP
HasRight(const std::string & deviceName,bool & hasRight)1261 int32_t UsbService::HasRight(const std::string &deviceName, bool &hasRight)
1262 {
1263 hasRight = this->HasRight(deviceName);
1264 return UEC_OK;
1265 }
1266 // LCOV_EXCL_START
HasRight(const std::string & deviceName)1267 bool UsbService::HasRight(const std::string &deviceName)
1268 {
1269 USB_HILOGI(MODULE_USB_SERVICE, "calling usbRightManager HasRight");
1270 if (usbRightManager_ == nullptr) {
1271 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1272 return false;
1273 }
1274
1275 std::string deviceVidPidSerialNum = "";
1276 if (GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum) != UEC_OK) {
1277 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1278 return false;
1279 }
1280
1281 if (usbRightManager_->IsSystemAppOrSa()) {
1282 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
1283 return true;
1284 }
1285
1286 std::string bundleName;
1287 std::string tokenId;
1288 int32_t userId = USB_RIGHT_USERID_INVALID;
1289 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1290 USB_HILOGE(MODULE_USB_SERVICE, "HasRight GetCallingInfo false");
1291 return false;
1292 }
1293
1294 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s", bundleName.c_str(), deviceName.c_str());
1295 if (usbRightManager_->HasRight(deviceVidPidSerialNum, bundleName, tokenId, userId)) {
1296 return true;
1297 }
1298
1299 return usbRightManager_->HasRight(deviceVidPidSerialNum, bundleName, USB_DEFAULT_TOKEN, userId);
1300 }
1301 // LCOV_EXCL_STOP
1302
1303 // LCOV_EXCL_START
RequestRight(const std::string & deviceName)1304 int32_t UsbService::RequestRight(const std::string &deviceName)
1305 {
1306 USB_HILOGI(MODULE_USB_SERVICE, "calling usbRightManager RequestRight");
1307 if (usbRightManager_ == nullptr) {
1308 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1309 return UEC_SERVICE_INNER_ERR;
1310 }
1311 std::string deviceVidPidSerialNum = "";
1312 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
1313 if (ret != UEC_OK) {
1314 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1315 return ret;
1316 }
1317 if (usbRightManager_->IsSystemAppOrSa()) {
1318 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
1319 return UEC_OK;
1320 }
1321 std::string bundleName;
1322 std::string tokenId;
1323 int32_t userId = USB_RIGHT_USERID_INVALID;
1324 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1325 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1326 return false;
1327 }
1328
1329 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s", bundleName.c_str(), deviceName.c_str());
1330 return usbRightManager_->RequestRight(deviceName, deviceVidPidSerialNum, bundleName, tokenId, userId);
1331 }
1332 // LCOV_EXCL_STOP
1333
1334 // LCOV_EXCL_START
RemoveRight(const std::string & deviceName)1335 int32_t UsbService::RemoveRight(const std::string &deviceName)
1336 {
1337 if (usbRightManager_ == nullptr) {
1338 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1339 return UEC_SERVICE_INVALID_VALUE;
1340 }
1341 std::string deviceVidPidSerialNum = "";
1342 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
1343 if (ret != UEC_OK) {
1344 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1345 return ret;
1346 }
1347 if (usbRightManager_->IsSystemAppOrSa()) {
1348 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
1349 return UEC_OK;
1350 }
1351 std::string bundleName;
1352 std::string tokenId;
1353 int32_t userId = USB_RIGHT_USERID_INVALID;
1354 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1355 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1356 return false;
1357 }
1358
1359 if (usbRightManager_->RemoveDeviceRight(deviceVidPidSerialNum, bundleName, tokenId, userId)) {
1360 USB_HILOGI(MODULE_USB_SERVICE, "RemoveDeviceRight done");
1361 return UEC_OK;
1362 }
1363
1364 if (!usbRightManager_->RemoveDeviceRight(deviceVidPidSerialNum, bundleName, USB_DEFAULT_TOKEN, userId)) {
1365 USB_HILOGE(MODULE_USB_SERVICE, "RemoveDeviceRight failed");
1366 return UEC_SERVICE_INNER_ERR;
1367 }
1368 USB_HILOGI(MODULE_USB_SERVICE, "RemoveRight done");
1369 return UEC_OK;
1370 }
1371 // LCOV_EXCL_STOP
1372
1373 // LCOV_EXCL_START
AddRight(const std::string & bundleName,const std::string & deviceName)1374 int32_t UsbService::AddRight(const std::string &bundleName, const std::string &deviceName)
1375 {
1376 if (usbRightManager_ == nullptr) {
1377 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1378 return UEC_SERVICE_INVALID_VALUE;
1379 }
1380 std::string deviceVidPidSerialNum = "";
1381 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
1382 if (ret != UEC_OK) {
1383 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1384 return ret;
1385 }
1386 ret = CheckSysApiPermission();
1387 if (ret != UEC_OK) {
1388 return ret;
1389 }
1390 std::string tokenId;
1391 int32_t userId = USB_RIGHT_USERID_INVALID;
1392 if (!GetBundleInfo(tokenId, userId)) {
1393 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1394 return false;
1395 }
1396 USB_HILOGI(MODULE_USB_SERVICE, "AddRight bundleName = %{public}s, deviceName = %{public}s", bundleName.c_str(),
1397 deviceName.c_str());
1398 if (!usbRightManager_->AddDeviceRight(deviceVidPidSerialNum, bundleName, tokenId, userId)) {
1399 USB_HILOGE(MODULE_USB_SERVICE, "AddDeviceRight failed");
1400 return UEC_SERVICE_INNER_ERR;
1401 }
1402 USB_HILOGI(MODULE_USB_SERVICE, "AddRight done");
1403 return UEC_OK;
1404 }
1405 // LCOV_EXCL_STOP
1406
1407 // LCOV_EXCL_START
AddAccessRight(const std::string & tokenId,const std::string & deviceName)1408 int32_t UsbService::AddAccessRight(const std::string &tokenId, const std::string &deviceName)
1409 {
1410 if (usbRightManager_ == nullptr) {
1411 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1412 return UEC_SERVICE_INVALID_VALUE;
1413 }
1414 int32_t ret = CheckSysApiPermission();
1415 if (ret != UEC_OK) {
1416 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1417 return ret;
1418 }
1419 std::string deviceVidPidSerialNum = "";
1420 ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
1421 if (ret != UEC_OK) {
1422 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1423 return ret;
1424 }
1425 USB_HILOGI(MODULE_USB_SERVICE, "AddRight deviceName = %{public}s", deviceName.c_str());
1426 if (!usbRightManager_->AddDeviceRight(deviceVidPidSerialNum, tokenId)) {
1427 USB_HILOGE(MODULE_USB_SERVICE, "AddDeviceRight failed");
1428 return UEC_SERVICE_INNER_ERR;
1429 }
1430 USB_HILOGI(MODULE_USB_SERVICE, "AddRight done");
1431 return UEC_OK;
1432 }
1433 // LCOV_EXCL_STOP
1434
1435 // LCOV_EXCL_START
GetBundleInfo(std::string & tokenId,int32_t & userId)1436 bool UsbService::GetBundleInfo(std::string &tokenId, int32_t &userId)
1437 {
1438 OHOS::Security::AccessToken::AccessTokenID token = IPCSkeleton::GetCallingTokenID();
1439 OHOS::Security::AccessToken::HapTokenInfo hapTokenInfoRes;
1440 int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::GetHapTokenInfo(token, hapTokenInfoRes);
1441 if (ret != ERR_OK) {
1442 USB_HILOGE(MODULE_USB_SERVICE, "failed, ret: %{public}d", ret);
1443 return false;
1444 }
1445 tokenId = USB_DEFAULT_TOKEN;
1446 userId = hapTokenInfoRes.userID;
1447 return true;
1448 }
1449 // LCOV_EXCL_STOP
1450
UsbDeviceTypeChange(std::vector<UsbDeviceType> & disableType,const std::vector<UsbDeviceTypeInfo> & deviceTypes)1451 void UsbService::UsbDeviceTypeChange(std::vector<UsbDeviceType> &disableType,
1452 const std::vector<UsbDeviceTypeInfo> &deviceTypes)
1453 {
1454 for (size_t i = 0; i < deviceTypes.size(); i++) {
1455 UsbDeviceType info;
1456 info.baseClass = deviceTypes[i].baseClass;
1457 info.subClass = deviceTypes[i].subClass;
1458 info.protocol = deviceTypes[i].protocol;
1459 info.isDeviceType = deviceTypes[i].isDeviceType;
1460 disableType.push_back(info);
1461 }
1462 return;
1463 }
1464
1465 // LCOV_EXCL_START
GetDeviceVidPidSerialNumber(const std::string & deviceName)1466 std::string UsbService::GetDeviceVidPidSerialNumber(const std::string &deviceName)
1467 {
1468 std::string strDesc = "test";
1469 std::lock_guard<std::mutex> guard(mutex_);
1470 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
1471 USB_HILOGI(MODULE_USB_SERVICE, " it->first = %{public}s", it->first.c_str());
1472 if (it->first == deviceName) {
1473 strDesc = it->second;
1474 break;
1475 }
1476 }
1477 return strDesc;
1478 }
1479 // LCOV_EXCL_STOP
1480
1481 // LCOV_EXCL_START
GetDeviceVidPidSerialNumber(const std::string & deviceName,std::string & strDesc)1482 int32_t UsbService::GetDeviceVidPidSerialNumber(const std::string &deviceName, std::string& strDesc)
1483 {
1484 int32_t isMatched = UEC_INTERFACE_INVALID_VALUE;
1485 std::lock_guard<std::mutex> guard(mutex_);
1486 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
1487 USB_HILOGI(MODULE_USB_SERVICE, " it->first = %{public}s", it->first.c_str());
1488 if (it->first == deviceName) {
1489 strDesc = it->second;
1490 isMatched = UEC_OK;
1491 break;
1492 }
1493 }
1494 return isMatched;
1495 }
1496 // LCOV_EXCL_STOP
1497
1498 // LCOV_EXCL_START
PreCallFunction()1499 int32_t UsbService::PreCallFunction()
1500 {
1501 #ifdef USB_MANAGER_PASS_THROUGH
1502 sptr<HDI::Usb::V2_0::IUsbHostInterface> usbHostInterface_ =
1503 HDI::Usb::V2_0::IUsbHostInterface::Get("usb_host_interface_service", true);
1504 if (usbHostInterface_ == nullptr) {
1505 USB_HILOGE(MODULE_USB_SERVICE, "usbHostInterface_ is nullptr");
1506 return UEC_SERVICE_INVALID_VALUE;
1507 }
1508 #else
1509 if (usbd_ == nullptr) {
1510 usbd_ = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
1511 } else {
1512 USB_HILOGW(MODULE_USB_SERVICE, "%{public}s:usbd_ != nullptr", __func__);
1513 }
1514 if (usbd_ == nullptr) {
1515 USB_HILOGE(MODULE_USB_SERVICE, "usbd_ is nullptr");
1516 return UEC_SERVICE_INVALID_VALUE;
1517 }
1518 #endif // USB_MANAGER_PASS_THROUGH
1519 if (usbRightManager_ == nullptr) {
1520 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1521 return UEC_SERVICE_INVALID_VALUE;
1522 }
1523 int32_t ret = CheckSysApiPermission();
1524 if (ret != UEC_OK) {
1525 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1526 return ret;
1527 }
1528 if (usbHostManager_ == nullptr) {
1529 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_");
1530 return UEC_SERVICE_INVALID_VALUE;
1531 }
1532
1533 return UEC_OK;
1534 }
1535 // LCOV_EXCL_STOP
1536 #endif // USB_MANAGER_FEATURE_HOST
1537
1538 #ifdef USB_MANAGER_FEATURE_DEVICE
1539 // LCOV_EXCL_START
GetCurrentFunctions(int32_t & functions)1540 int32_t UsbService::GetCurrentFunctions(int32_t &functions)
1541 {
1542 if (usbRightManager_ == nullptr) {
1543 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1544 return UEC_SERVICE_INVALID_VALUE;
1545 }
1546 int32_t ret = CheckSysApiPermission();
1547 if (ret != UEC_OK) {
1548 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1549 return ret;
1550 }
1551 if (usbDeviceManager_ == nullptr) {
1552 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbDeviceManager_ is nullptr");
1553 return UEC_SERVICE_INVALID_VALUE;
1554 }
1555 return usbDeviceManager_->GetCurrentFunctions(functions);
1556 }
1557 // LCOV_EXCL_STOP
1558
1559 // LCOV_EXCL_START
SetCurrentFunctions(int32_t functions)1560 int32_t UsbService::SetCurrentFunctions(int32_t functions)
1561 {
1562 USB_HILOGI(MODULE_USB_SERVICE, "func = %{public}d", functions);
1563 if (usbRightManager_ == nullptr) {
1564 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1565 return UEC_SERVICE_INVALID_VALUE;
1566 }
1567 int32_t ret = CheckSysApiPermission();
1568 if (ret != UEC_OK) {
1569 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1570 return ret;
1571 }
1572 ret = usbRightManager_->HasSetFuncRight(functions);
1573 if (ret != 0) {
1574 USB_HILOGE(MODULE_USB_SERVICE, "HasSetFuncRight fail");
1575 return ret;
1576 }
1577 if (usbDeviceManager_ == nullptr) {
1578 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbDeviceManager_ is nullptr");
1579 return UEC_SERVICE_INVALID_VALUE;
1580 }
1581 return usbDeviceManager_->SetCurrentFunctions(functions);
1582 }
1583 // LCOV_EXCL_STOP
1584
1585 // LCOV_EXCL_START
UsbFunctionsFromString(const std::string & funcs,int32_t & funcResult)1586 int32_t UsbService::UsbFunctionsFromString(const std::string &funcs, int32_t &funcResult)
1587 {
1588 if (usbRightManager_ == nullptr) {
1589 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1590 funcResult = UEC_SERVICE_INVALID_VALUE;
1591 return UEC_OK;
1592 }
1593 int32_t ret = CheckSysApiPermission();
1594 if (ret != UEC_OK) {
1595 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1596 funcResult = ret;
1597 return UEC_OK;
1598 }
1599 USB_HILOGI(MODULE_USB_SERVICE, "calling UsbFunctionsFromString");
1600 funcResult = UsbDeviceManager::ConvertFromString(funcs);
1601 return UEC_OK;
1602 }
1603 // LCOV_EXCL_STOP
1604
1605 // LCOV_EXCL_START
UsbFunctionsToString(int32_t funcs,std::string & funcResult)1606 int32_t UsbService::UsbFunctionsToString(int32_t funcs, std::string& funcResult)
1607 {
1608 if (usbRightManager_ == nullptr) {
1609 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1610 funcResult = "";
1611 return UEC_OK;
1612 }
1613 if (!usbRightManager_->IsSystemAppOrSa()) {
1614 funcResult = PERMISSION_DENIED_SYSAPI;
1615 return UEC_OK;
1616 }
1617 if (!usbRightManager_->VerifyPermission()) {
1618 int32_t apiVersion = GetHapApiVersion();
1619 if (apiVersion < API_VERSION_ID_18) {
1620 funcResult = PERMISSION_DENIED_SYSAPI;
1621 return UEC_OK;
1622 }
1623 funcResult = SYS_APP_PERMISSION_DENIED_SYSAPI;
1624 return UEC_OK;
1625 }
1626
1627 USB_HILOGI(MODULE_USB_SERVICE, "calling UsbFunctionsToString");
1628 funcResult = UsbDeviceManager::ConvertToString(funcs);
1629 return UEC_OK;
1630 }
1631 // LCOV_EXCL_STOP
1632
1633 // LCOV_EXCL_START
UpdateDeviceState(int32_t status)1634 void UsbService::UpdateDeviceState(int32_t status)
1635 {
1636 if (usbDeviceManager_ == nullptr) {
1637 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
1638 return;
1639 }
1640
1641 usbDeviceManager_->HandleEvent(status);
1642
1643 if (usbAccessoryManager_ == nullptr) {
1644 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbAccessoryManager_");
1645 return;
1646 }
1647 usbAccessoryManager_->HandleEvent(status);
1648 }
1649 // LCOV_EXCL_STOP
1650
UserChangeProcess()1651 int32_t UsbService::UserChangeProcess()
1652 {
1653 if (usbDeviceManager_ == nullptr) {
1654 USB_HILOGE(MODULE_USB_SERVICE, "usbDeviceManager_ is nullptr");
1655 return UEC_SERVICE_INVALID_VALUE;
1656 }
1657 return usbDeviceManager_->UserChangeProcess();
1658 }
1659
GetAccessoryList(std::vector<USBAccessory> & accessList)1660 int32_t UsbService::GetAccessoryList(std::vector<USBAccessory> &accessList)
1661 {
1662 if (usbAccessoryManager_ == nullptr) {
1663 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbAccessoryManager_");
1664 return UEC_SERVICE_INVALID_VALUE;
1665 }
1666 std::string bundleName;
1667 std::string tokenId;
1668 int32_t userId = USB_RIGHT_USERID_INVALID;
1669 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1670 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1671 return UEC_SERVICE_INNER_ERR;
1672 }
1673
1674 usbAccessoryManager_->GetAccessoryList(bundleName, accessList);
1675 USB_HILOGD(MODULE_USB_SERVICE, "get accessory list size %{public}zu", accessList.size());
1676 return UEC_OK;
1677 }
1678
OpenAccessory(const USBAccessory & access,int32_t & fd)1679 int32_t UsbService::OpenAccessory(const USBAccessory &access, int32_t &fd)
1680 {
1681 if (usbAccessoryManager_ == nullptr) {
1682 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbAccessoryManager_");
1683 return UEC_SERVICE_INVALID_VALUE;
1684 }
1685 std::string bundleName;
1686 std::string tokenId;
1687 int32_t userId = USB_RIGHT_USERID_INVALID;
1688 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1689 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1690 return UEC_SERVICE_GET_TOKEN_INFO_FAILED;
1691 }
1692
1693 std::string serialNum = "";
1694 int32_t ret = usbAccessoryManager_->GetAccessorySerialNumber(access, bundleName, serialNum);
1695 if (ret != UEC_OK) {
1696 USB_HILOGE(MODULE_USB_SERVICE, "can not find accessory.");
1697 return ret;
1698 }
1699
1700 bool result = false;
1701 ret = UsbService::HasAccessoryRight(access, result);
1702 if (ret != UEC_OK || !result) {
1703 USB_HILOGE(MODULE_USB_SERVICE, "No permission");
1704 return UEC_SERVICE_PERMISSION_DENIED;
1705 }
1706
1707 ret = usbAccessoryManager_->OpenAccessory(fd);
1708 if (ret != UEC_OK) {
1709 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
1710 }
1711 return ret;
1712 }
1713
CloseAccessory(int32_t fd)1714 int32_t UsbService::CloseAccessory(int32_t fd)
1715 {
1716 if (usbAccessoryManager_ == nullptr) {
1717 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbAccessoryManager_");
1718 return UEC_SERVICE_INVALID_VALUE;
1719 }
1720 int32_t ret = usbAccessoryManager_->CloseAccessory(fd);
1721 if (ret != UEC_OK) {
1722 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
1723 }
1724 return ret;
1725 }
1726
AddAccessoryRight(const uint32_t tokenId,const USBAccessory & access)1727 int32_t UsbService::AddAccessoryRight(const uint32_t tokenId, const USBAccessory &access)
1728 {
1729 if (usbRightManager_ == nullptr || usbAccessoryManager_ == nullptr) {
1730 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_ or usbAccessoryManager_");
1731 return UEC_SERVICE_INVALID_VALUE;
1732 }
1733 int32_t ret = CheckSysApiPermission();
1734 if (ret != UEC_OK) {
1735 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1736 return ret;
1737 }
1738
1739 HapTokenInfo hapTokenInfoRes;
1740 ret = AccessTokenKit::GetHapTokenInfo((AccessTokenID) tokenId, hapTokenInfoRes);
1741 if (ret != UEC_OK) {
1742 USB_HILOGE(MODULE_USB_SERVICE, "GetHapTokenInfo failed:ret:%{public}d", ret);
1743 return UEC_SERVICE_GET_TOKEN_INFO_FAILED;
1744 }
1745
1746 std::string serialNum = "";
1747 ret = usbAccessoryManager_->GetAccessorySerialNumber(access, hapTokenInfoRes.bundleName, serialNum);
1748 if (ret != UEC_OK) {
1749 USB_HILOGE(MODULE_USB_SERVICE, "can not find accessory.");
1750 return ret;
1751 }
1752
1753 USB_HILOGI(MODULE_USB_SERVICE, "Add accessory Right, deviceName = %{public}s", serialNum.c_str());
1754 if (!usbRightManager_->AddDeviceRight(serialNum, std::to_string(tokenId))) {
1755 USB_HILOGE(MODULE_USB_SERVICE, "AddDeviceRight failed");
1756 return UEC_SERVICE_DATABASE_OPERATION_FAILED;
1757 }
1758 USB_HILOGI(MODULE_USB_SERVICE, "AddAccessoryRight done");
1759 return UEC_OK;
1760 }
1761
HasAccessoryRight(const USBAccessory & access,bool & result)1762 int32_t UsbService::HasAccessoryRight(const USBAccessory &access, bool &result)
1763 {
1764 USB_HILOGI(MODULE_USB_SERVICE, "calling HasAccessoryRight");
1765 if (usbRightManager_ == nullptr || usbAccessoryManager_ == nullptr) {
1766 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_ or usbAccessoryManager_");
1767 return UEC_SERVICE_INVALID_VALUE;
1768 }
1769
1770 std::string bundleName;
1771 std::string tokenId;
1772 int32_t userId = USB_RIGHT_USERID_INVALID;
1773 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1774 USB_HILOGE(MODULE_USB_SERVICE, "HasRight GetCallingInfo false");
1775 return UEC_SERVICE_GET_TOKEN_INFO_FAILED;
1776 }
1777
1778 std::string serialNum = "";
1779 int32_t ret = usbAccessoryManager_->GetAccessorySerialNumber(access, bundleName, serialNum);
1780 if (ret != UEC_OK) {
1781 USB_HILOGE(MODULE_USB_SERVICE, "can not find accessory.");
1782 return ret;
1783 }
1784
1785 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, serialNum=%{public}s", bundleName.c_str(), serialNum.c_str());
1786 result = usbRightManager_->HasRight(serialNum, bundleName, tokenId, userId);
1787
1788 return UEC_OK;
1789 }
1790
RequestAccessoryRight(const USBAccessory & access,bool & result)1791 int32_t UsbService::RequestAccessoryRight(const USBAccessory &access, bool &result)
1792 {
1793 USB_HILOGI(MODULE_USB_SERVICE, "calling usbRightManager RequestAccessoryRight");
1794 if (usbRightManager_ == nullptr || usbAccessoryManager_ == nullptr) {
1795 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_ or usbAccessoryManager_");
1796 return UEC_SERVICE_INVALID_VALUE;
1797 }
1798
1799 std::string bundleName;
1800 std::string tokenId;
1801 int32_t userId = USB_RIGHT_USERID_INVALID;
1802 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1803 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1804 return UEC_SERVICE_GET_TOKEN_INFO_FAILED;
1805 }
1806
1807 std::string serialNum = "";
1808 int32_t ret = usbAccessoryManager_->GetAccessorySerialNumber(access, bundleName, serialNum);
1809 if (ret != UEC_OK) {
1810 USB_HILOGE(MODULE_USB_SERVICE, "can not find accessory.");
1811 return ret;
1812 }
1813
1814 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s", bundleName.c_str(), serialNum.c_str());
1815 return usbRightManager_->RequestRight(access, serialNum, bundleName, tokenId, userId, result);
1816 }
1817
CancelAccessoryRight(const USBAccessory & access)1818 int32_t UsbService::CancelAccessoryRight(const USBAccessory &access)
1819 {
1820 USB_HILOGI(MODULE_USB_SERVICE, "calling CancelAccessoryRight");
1821 if (usbRightManager_ == nullptr || usbAccessoryManager_ == nullptr) {
1822 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_ or usbAccessoryManager_");
1823 return UEC_SERVICE_INVALID_VALUE;
1824 }
1825
1826 std::string bundleName;
1827 std::string tokenId;
1828 int32_t userId = USB_RIGHT_USERID_INVALID;
1829 if (!GetCallingInfo(bundleName, tokenId, userId)) {
1830 USB_HILOGE(MODULE_USB_SERVICE, "GetCallingInfo false");
1831 return UEC_SERVICE_GET_TOKEN_INFO_FAILED;
1832 }
1833
1834 std::string serialNum = "";
1835 int32_t ret = usbAccessoryManager_->GetAccessorySerialNumber(access, bundleName, serialNum);
1836 if (ret != UEC_OK) {
1837 USB_HILOGE(MODULE_USB_SERVICE, "can not find accessory.");
1838 return ret;
1839 }
1840
1841 if (usbRightManager_->CancelDeviceRight(serialNum, bundleName, tokenId, userId) != UEC_OK) {
1842 USB_HILOGI(MODULE_USB_SERVICE, "CancelAccessoryRight failed");
1843 return UEC_SERVICE_DATABASE_OPERATION_FAILED;
1844 }
1845
1846 USB_HILOGI(MODULE_USB_SERVICE, "CancelAccessoryRight done");
1847 return UEC_OK;
1848 }
1849 #endif // USB_MANAGER_FEATURE_DEVICE
1850
1851 #ifdef USB_MANAGER_FEATURE_PORT
1852 // LCOV_EXCL_START
GetPorts(std::vector<UsbPort> & ports)1853 int32_t UsbService::GetPorts(std::vector<UsbPort> &ports)
1854 {
1855 USB_HILOGI(MODULE_USB_SERVICE, "calling usbPortManager getPorts");
1856 if (usbRightManager_ == nullptr) {
1857 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1858 return UEC_SERVICE_INVALID_VALUE;
1859 }
1860 int32_t ret = CheckSysApiPermission();
1861 if (ret != UEC_OK) {
1862 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1863 return ret;
1864 }
1865 if (usbPortManager_ == nullptr) {
1866 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
1867 return UEC_SERVICE_INVALID_VALUE;
1868 }
1869 return usbPortManager_->GetPorts(ports);
1870 }
1871 // LCOV_EXCL_STOP
1872
1873 // LCOV_EXCL_START
GetSupportedModes(int32_t portId,int32_t & supportedModes)1874 int32_t UsbService::GetSupportedModes(int32_t portId, int32_t &supportedModes)
1875 {
1876 USB_HILOGI(MODULE_USB_SERVICE, "calling usbPortManager getSupportedModes");
1877 if (usbRightManager_ == nullptr) {
1878 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1879 return UEC_SERVICE_INVALID_VALUE;
1880 }
1881 int32_t ret = CheckSysApiPermission();
1882 if (ret != UEC_OK) {
1883 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1884 return ret;
1885 }
1886 if (usbPortManager_ == nullptr) {
1887 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
1888 return UEC_SERVICE_INVALID_VALUE;
1889 }
1890 return usbPortManager_->GetSupportedModes(portId, supportedModes);
1891 }
1892 // LCOV_EXCL_STOP
1893
1894 // LCOV_EXCL_START
SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)1895 int32_t UsbService::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole)
1896 {
1897 USB_HILOGI(MODULE_USB_SERVICE, "calling usbPortManager SetPortRole");
1898 if (usbRightManager_ == nullptr) {
1899 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1900 return UEC_SERVICE_INVALID_VALUE;
1901 }
1902 int32_t ret = CheckSysApiPermission();
1903 if (ret != UEC_OK) {
1904 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: CheckSysApiPermission failed ret = %{public}d", __func__, ret);
1905 return ret;
1906 }
1907 if (usbPortManager_ == nullptr) {
1908 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbPortManager_ is nullptr");
1909 return UEC_SERVICE_INVALID_VALUE;
1910 }
1911 ret = usbPortManager_->SetPortRole(portId, powerRole, dataRole);
1912 if (ret == HDF_ERR_NOT_SUPPORT) {
1913 USB_HILOGE(MODULE_USB_SERVICE, "SetPortRole not support");
1914 return UEC_SERVICE_NOT_SUPPORT_SWITCH_PORT;
1915 }
1916 return ret;
1917 }
1918 // LCOV_EXCL_STOP
1919
1920 // LCOV_EXCL_START
UpdateUsbPort(int32_t portId,int32_t powerRole,int32_t dataRole,int32_t mode)1921 void UsbService::UpdateUsbPort(int32_t portId, int32_t powerRole, int32_t dataRole, int32_t mode)
1922 {
1923 if (usbPortManager_ == nullptr) {
1924 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
1925 return;
1926 }
1927
1928 usbPortManager_->UpdatePort(portId, powerRole, dataRole, mode);
1929 }
1930 // LCOV_EXCL_STOP
1931 #endif // USB_MANAGER_FEATURE_PORT
1932
1933 #if defined(USB_MANAGER_FEATURE_HOST) || defined(USB_MANAGER_FEATURE_DEVICE)
1934 // LCOV_EXCL_START
GetCallingInfo(std::string & bundleName,std::string & tokenId,int32_t & userId)1935 bool UsbService::GetCallingInfo(std::string &bundleName, std::string &tokenId, int32_t &userId)
1936 {
1937 OHOS::Security::AccessToken::AccessTokenID token = IPCSkeleton::GetCallingTokenID();
1938 OHOS::Security::AccessToken::HapTokenInfo hapTokenInfoRes;
1939 int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::GetHapTokenInfo(token, hapTokenInfoRes);
1940 if (ret != ERR_OK) {
1941 USB_HILOGE(MODULE_USB_SERVICE, "failed, ret: %{public}d, app: %{public}s",
1942 ret, bundleName.c_str());
1943 return false;
1944 }
1945 bundleName = hapTokenInfoRes.bundleName;
1946 tokenId = std::to_string((uint32_t)token);
1947 userId = hapTokenInfoRes.userID;
1948 USB_HILOGD(MODULE_USB_SERVICE, "ret: %{public}d, app: %{public}s,", ret, bundleName.c_str());
1949 return true;
1950 }
1951 // LCOV_EXCL_STOP
1952 #endif // USB_MANAGER_FEATURE_HOST || USB_MANAGER_FEATURE_DEVICE
1953
CheckSysApiPermission()1954 int32_t UsbService::CheckSysApiPermission()
1955 {
1956 if (!usbRightManager_->IsSystemAppOrSa()) {
1957 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
1958 }
1959 if (!usbRightManager_->VerifyPermission()) {
1960 int32_t apiVersion = GetHapApiVersion();
1961 if (apiVersion < API_VERSION_ID_18) {
1962 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
1963 }
1964 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI_FAILED;
1965 }
1966
1967 return UEC_OK;
1968 }
1969
GetHapApiVersion()1970 int32_t UsbService::GetHapApiVersion()
1971 {
1972 OHOS::Security::AccessToken::AccessTokenID token = IPCSkeleton::GetCallingTokenID();
1973 OHOS::Security::AccessToken::HapTokenInfo hapTokenInfoRes;
1974 int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::GetHapTokenInfo(token, hapTokenInfoRes);
1975 if (ret != ERR_OK) {
1976 USB_HILOGE(MODULE_USB_SERVICE, "GetHapTokenInfo failed, ret: %{public}d", ret);
1977 return API_VERSION_ID_18;
1978 }
1979 int32_t hapApiVersion = hapTokenInfoRes.apiVersion;
1980 USB_HILOGD(MODULE_USB_SERVICE, "API check hapApiVersion = %{public}d", hapApiVersion);
1981
1982 return hapApiVersion;
1983 }
1984
1985 // LCOV_EXCL_START
InitUsbRight()1986 int32_t UsbService::InitUsbRight()
1987 {
1988 if (usbRightManager_ == nullptr) {
1989 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1990 return UEC_SERVICE_INVALID_VALUE;
1991 }
1992 int32_t ret = usbRightManager_->Init();
1993 if (ret != UEC_OK) {
1994 USB_HILOGE(MODULE_USBD, "Init usb right manager failed: %{public}d", ret);
1995 return ret;
1996 }
1997 std::vector<std::string> devices;
1998 std::lock_guard<std::mutex> guard(mutex_);
1999 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
2000 devices.push_back(it->second);
2001 }
2002 USB_HILOGI(MODULE_USBD, "clean: %{public}zu/%{public}zu", devices.size(), deviceVidPidMap_.size());
2003 ret = usbRightManager_->CleanUpRightExpired(devices);
2004 if (ret != USB_RIGHT_OK) {
2005 USB_HILOGE(MODULE_USBD, "clean expired usb right failed: %{public}d", ret);
2006 }
2007 return ret;
2008 }
2009 // LCOV_EXCL_STOP
2010
2011 // LCOV_EXCL_START
GetBundleName(std::string & bundleName)2012 bool UsbService::GetBundleName(std::string &bundleName)
2013 {
2014 #ifdef USB_RIGHT_TEST
2015 bundleName = "com.usb.right";
2016 return true;
2017 #endif // USB_RIGHT_TEST
2018 pid_t uid = GetCallingUid();
2019 sptr<ISystemAbilityManager> systemAbilityManager =
2020 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2021 if (systemAbilityManager == nullptr) {
2022 return false;
2023 }
2024 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
2025 if (remoteObject == nullptr) {
2026 return false;
2027 }
2028
2029 sptr<AppExecFwk::IBundleMgr> bundleMgr(new AppExecFwk::BundleMgrProxy(remoteObject));
2030 if (bundleMgr == nullptr) {
2031 return false;
2032 }
2033
2034 ErrCode ret = bundleMgr->GetNameForUid(uid, bundleName);
2035 if (ret != ERR_OK) {
2036 USB_HILOGE(MODULE_USB_SERVICE, "failed to obtain bundleName");
2037 return false;
2038 }
2039 return true;
2040 }
2041 // LCOV_EXCL_STOP
2042
2043 // LCOV_EXCL_START
DoDump(int fd,const std::vector<std::string> & argList)2044 bool UsbService::DoDump(int fd, const std::vector<std::string> &argList)
2045 {
2046 #ifdef USB_MANAGER_FEATURE_HOST
2047 if (usbHostManager_ == nullptr) {
2048 USB_HILOGE(MODULE_USB_SERVICE, "usbHostManager_ is nullptr");
2049 return false;
2050 }
2051 if (argList[0] == USB_HOST) {
2052 usbHostManager_->Dump(fd, argList[1]);
2053 }
2054 #endif // USB_MANAGER_FEATURE_HOST
2055 #ifdef USB_MANAGER_FEATURE_DEVICE
2056 if (usbDeviceManager_ == nullptr) {
2057 USB_HILOGE(MODULE_USB_SERVICE, "usbDeviceManager_ is nullptr");
2058 return false;
2059 }
2060 if (argList[0] == USB_DEVICE) {
2061 usbDeviceManager_->Dump(fd, argList);
2062 }
2063 #endif // USB_MANAGER_FEATURE_DEVICE
2064 #ifdef USB_MANAGER_FEATURE_PORT
2065 if (usbPortManager_ == nullptr) {
2066 USB_HILOGE(MODULE_USB_SERVICE, "usbPortManager_ is nullptr");
2067 return false;
2068 }
2069 if (argList[0] == USB_PORT) {
2070 usbPortManager_->Dump(fd, argList);
2071 }
2072 #endif // USB_MANAGER_FEATURE_PORT
2073 return true;
2074 }
2075 // LCOV_EXCL_STOP
2076
2077 // LCOV_EXCL_START
Dump(int fd,const std::vector<std::u16string> & args)2078 int UsbService::Dump(int fd, const std::vector<std::u16string> &args)
2079 {
2080 if (fd < 0) {
2081 USB_HILOGE(MODULE_USB_SERVICE, "fd is invalid fd:%{public}d", fd);
2082 return UEC_SERVICE_INVALID_VALUE;
2083 }
2084
2085 std::vector<std::string> argList;
2086 std::transform(args.begin(), args.end(), std::back_inserter(argList), [](const std::u16string &arg) {
2087 return Str16ToStr8(arg);
2088 });
2089
2090 if (usbSerialManager_ == nullptr) {
2091 USB_HILOGE(MODULE_USB_SERVICE, "usbSerialManager_ is nullptr");
2092 return UEC_SERVICE_INVALID_VALUE;
2093 }
2094 if (argList.empty()) {
2095 USB_HILOGE(MODULE_USB_SERVICE, "argList is empty");
2096 DumpHelp(fd);
2097 usbSerialManager_->ListGetDumpHelp(fd);
2098 return UEC_SERVICE_INVALID_VALUE;
2099 }
2100 if (!DoDump(fd, argList)) {
2101 return UEC_SERVICE_INVALID_VALUE;
2102 }
2103 if (argList[0] == USB_HELP) {
2104 DumpHelp(fd);
2105 usbSerialManager_->ListGetDumpHelp(fd);
2106 } else if (argList[0] == USB_LIST) {
2107 usbSerialManager_->SerialPortListDump(fd, argList);
2108 } else if (argList[0] == USB_GETT) {
2109 usbSerialManager_->SerialGetAttributeDump(fd, argList);
2110 } else {
2111 dprintf(fd, "Usb Dump service:invalid parameter.\n");
2112 DumpHelp(fd);
2113 usbSerialManager_->ListGetDumpHelp(fd);
2114 }
2115 return UEC_OK;
2116 }
2117 // LCOV_EXCL_STOP
2118
2119 // LCOV_EXCL_START
DumpHelp(int32_t fd)2120 void UsbService::DumpHelp(int32_t fd)
2121 {
2122 dprintf(fd, "Refer to the following usage:\n");
2123 dprintf(fd, "-h: dump help\n");
2124 dprintf(fd, "============= dump the all device ==============\n");
2125 dprintf(fd, "usb_host -a: dump the all device list info\n");
2126 dprintf(fd, "------------------------------------------------\n");
2127 #ifdef USB_MANAGER_FEATURE_DEVICE
2128 if (usbDeviceManager_ == nullptr) {
2129 USB_HILOGE(MODULE_USB_SERVICE, "usbDeviceManager_ is nullptr");
2130 return;
2131 }
2132 usbDeviceManager_->GetDumpHelp(fd);
2133 #endif // USB_MANAGER_FEATURE_DEVICE
2134 #ifdef USB_MANAGER_FEATURE_PORT
2135 if (usbPortManager_ == nullptr) {
2136 USB_HILOGE(MODULE_USB_SERVICE, "usbPortManager_ is nullptr");
2137 return;
2138 }
2139 usbPortManager_->GetDumpHelp(fd);
2140 #endif // USB_MANAGER_FEATURE_PORT
2141 }
2142 // LCOV_EXCL_STOP
2143
IsNotNeedUnload()2144 bool UsbService::IsNotNeedUnload()
2145 {
2146 bool hasActiveDevices = false;
2147 bool isGadgetConnected = false;
2148 #ifdef USB_MANAGER_FEATURE_HOST
2149 std::map<std::string, UsbDevice *> devices;
2150 usbHostManager_->GetDevices(devices);
2151 hasActiveDevices = !devices.empty();
2152 #endif // USB_MANAGER_FEATURE_HOST
2153 #ifdef USB_MANAGER_FEATURE_DEVICE
2154 isGadgetConnected = usbDeviceManager_->IsGadgetConnected();
2155 #endif // USB_MANAGER_FEATURE_DEVICE
2156 return hasActiveDevices || isGadgetConnected;
2157 }
2158
2159 // LCOV_EXCL_START
UnLoadSelf(UnLoadSaType type)2160 void UsbService::UnLoadSelf(UnLoadSaType type)
2161 {
2162 if (OHOS::system::GetBoolParameter("const.security.developermode.state", true)) {
2163 USB_HILOGI(MODULE_USB_SERVICE, "no need to unload in dev mode");
2164 return;
2165 }
2166
2167 auto task = []() {
2168 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2169 if (samgrProxy == nullptr) {
2170 USB_HILOGE(MODULE_USB_SERVICE, "get samgr failed");
2171 return;
2172 }
2173
2174 auto ret = samgrProxy->UnloadSystemAbility(USB_SYSTEM_ABILITY_ID);
2175 if (ret != UEC_OK) {
2176 USB_HILOGE(MODULE_USB_SERVICE, "unload failed");
2177 }
2178 };
2179 if (type == UNLOAD_SA_IMMEDIATELY) {
2180 task();
2181 return;
2182 }
2183 #ifdef USB_MANAGER_FEATURE_HOST
2184 if (usbHostManager_ == nullptr) {
2185 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_");
2186 return;
2187 }
2188 #endif // USB_MANAGER_FEATURE_HOST
2189 #ifdef USB_MANAGER_FEATURE_DEVICE
2190 if (usbDeviceManager_ == nullptr) {
2191 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
2192 return;
2193 }
2194 #endif // USB_MANAGER_FEATURE_DEVICE
2195 unloadSelfTimer_.Unregister(unloadSelfTimerId_);
2196 unloadSelfTimer_.Shutdown();
2197
2198 if (IsNotNeedUnload()) { // delay unload conditions
2199 USB_HILOGW(MODULE_USB_SERVICE, "not need unload");
2200 Memory::MemMgrClient::GetInstance().SetCritical(getpid(), true, USB_SYSTEM_ABILITY_ID);
2201 return;
2202 } else {
2203 Memory::MemMgrClient::GetInstance().SetCritical(getpid(), false, USB_SYSTEM_ABILITY_ID);
2204 }
2205
2206 if (auto ret = unloadSelfTimer_.Setup(); ret != Utils::TIMER_ERR_OK) {
2207 USB_HILOGE(MODULE_USB_SERVICE, "set up timer failed %{public}u", ret);
2208 return;
2209 }
2210 unloadSelfTimerId_ = unloadSelfTimer_.Register(task, UNLOAD_SA_TIMER_INTERVAL, true);
2211 }
2212 // LCOV_EXCL_STOP
2213
2214 // LCOV_EXCL_START
OnRemoteDied(const wptr<IRemoteObject> & object)2215 void UsbService::UsbdDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
2216 {
2217 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2218 if (samgrProxy == nullptr) {
2219 USB_HILOGE(MODULE_USB_SERVICE, "get samgr failed");
2220 return;
2221 }
2222
2223 auto ret = samgrProxy->UnloadSystemAbility(USB_SYSTEM_ABILITY_ID);
2224 if (ret != UEC_OK) {
2225 USB_HILOGE(MODULE_USB_SERVICE, "unload failed");
2226 }
2227 }
2228 // LCOV_EXCL_STOP
2229
OnRemoteDied(const wptr<IRemoteObject> & object)2230 void UsbService::SerialDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
2231 {
2232 USB_HILOGI(MODULE_USBD, "UsbService SerialDeathRecipient enter");
2233 service_->FreeTokenId(this->portId_, this->tokenId_);
2234 service_->CancelSerialRight(this->portId_);
2235 }
2236
FreeTokenId(int32_t portId,uint32_t tokenId)2237 void UsbService::FreeTokenId(int32_t portId, uint32_t tokenId)
2238 {
2239 usbSerialManager_->FreeTokenId(portId, tokenId);
2240 }
2241
2242 // LCOV_EXCL_START
GetGlobalInstance()2243 sptr<UsbService> UsbService::GetGlobalInstance()
2244 {
2245 return g_serviceInstance;
2246 }
2247 // LCOV_EXCL_STOP
2248
2249 // LCOV_EXCL_START
DeviceEvent(const HDI::Usb::V1_0::USBDeviceInfo & info)2250 int32_t UsbService::DeviceEvent(const HDI::Usb::V1_0::USBDeviceInfo &info)
2251 {
2252 int32_t status = info.status;
2253 #ifdef USB_MANAGER_FEATURE_DEVICE
2254 if (status == ACT_UPDEVICE || status == ACT_DOWNDEVICE ||
2255 status == ACT_ACCESSORYUP || status == ACT_ACCESSORYDOWN || status == ACT_ACCESSORYSEND) {
2256 USB_HILOGI(MODULE_USB_SERVICE, "device: usb");
2257 g_serviceInstance->UpdateDeviceState(status);
2258 g_serviceInstance->UnLoadSelf(UsbService::UnLoadSaType::UNLOAD_SA_DELAY);
2259 return UEC_OK;
2260 }
2261 #endif // USB_MANAGER_FEATURE_DEVICE
2262 #ifdef USB_MANAGER_FEATURE_HOST
2263 int32_t busNum = info.busNum;
2264 int32_t devAddr = info.devNum;
2265 if (status == ACT_DEVUP) {
2266 USB_HILOGI(MODULE_USB_SERVICE, "host: usb attached");
2267 g_serviceInstance->AddDevice(busNum, devAddr);
2268 } else {
2269 USB_HILOGI(MODULE_USB_SERVICE, "host: usb detached");
2270 g_serviceInstance->DelDevice(busNum, devAddr);
2271 }
2272 g_serviceInstance->UnLoadSelf(UsbService::UnLoadSaType::UNLOAD_SA_DELAY);
2273 #endif // USB_MANAGER_FEATURE_HOST
2274 return UEC_OK;
2275 }
2276 // LCOV_EXCL_STOP
2277
2278 // LCOV_EXCL_START
IsCallerValid()2279 bool UsbService::IsCallerValid()
2280 {
2281 OHOS::Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
2282 auto callerTokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenType(callerToken);
2283 if (callerTokenType == OHOS::Security::AccessToken::TypeATokenTypeEnum::TOKEN_NATIVE) {
2284 pid_t callerUid = IPCSkeleton::GetCallingUid();
2285 return callerUid == ROOT_UID || callerUid == EDM_UID;
2286 }
2287 return false;
2288 }
2289 // LCOV_EXCL_STOP
InitSerial()2290 bool UsbService::InitSerial()
2291 {
2292 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2293 if (seriald_ == nullptr) {
2294 seriald_ = OHOS::HDI::Usb::Serial::V1_0::ISerialInterface::Get("serial_interface_service", true);
2295 if (seriald_ == nullptr) {
2296 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::InitSerial seriald_ is null");
2297 return false;
2298 }
2299 }
2300
2301 return true;
2302 }
2303
ValidateUsbSerialManagerAndPort(int32_t portId)2304 int32_t UsbService::ValidateUsbSerialManagerAndPort(int32_t portId)
2305 {
2306 if (usbSerialManager_ == nullptr) {
2307 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbSerialManager_ is nullptr", __func__);
2308 return UEC_SERVICE_INVALID_VALUE;
2309 }
2310
2311 if (!usbSerialManager_->IsPortIdExist(portId)) {
2312 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: %{public}d port not exist", __func__, portId);
2313 return UEC_SERIAL_PORT_NOT_EXIST;
2314 }
2315
2316 return UEC_OK;
2317 }
2318
SerialOpen(int32_t portId,const sptr<IRemoteObject> & serialRemote)2319 int32_t UsbService::SerialOpen(int32_t portId, const sptr<IRemoteObject> &serialRemote)
2320 {
2321 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2322 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2323 if (ret != UEC_OK) {
2324 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2325 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", ret, "ValidateUsbSerialManagerAndPort failed");
2326 return ret;
2327 }
2328
2329 bool hasRight = false;
2330 HasSerialRight(portId, hasRight);
2331 if (!hasRight) {
2332 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: There are no permissions", __func__);
2333 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", UEC_SERVICE_PERMISSION_DENIED,
2334 "There are no permissions");
2335 return UEC_SERVICE_PERMISSION_DENIED;
2336 }
2337
2338 uint32_t tokenId;
2339 if (usbSerialManager_->GetTokenId(tokenId) != UEC_OK) {
2340 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: OnRemoteDied GetTokenId failed", __func__);
2341 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", UEC_SERVICE_PERMISSION_DENIED,
2342 "OnRemoteDied GetTokenId failed");
2343 return UEC_SERVICE_PERMISSION_DENIED;
2344 }
2345
2346 sptr<UsbService::SerialDeathRecipient> serialRecipient_ = new SerialDeathRecipient(this, portId, tokenId);
2347 if (serialRecipient_ == nullptr) {
2348 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: serialRecipient_ is nullptr", __func__);
2349 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", UEC_SERVICE_INVALID_VALUE,
2350 "serialRecipient_ is nullptr");
2351 return UEC_SERVICE_INVALID_VALUE;
2352 }
2353
2354 if (!serialRemote->AddDeathRecipient(serialRecipient_)) {
2355 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialOpen add DeathRecipient failed", __func__);
2356 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", UEC_SERVICE_INVALID_VALUE,
2357 "SerialOpen add DeathRecipient failed");
2358 return UEC_SERVICE_INVALID_VALUE;
2359 }
2360
2361 ret = usbSerialManager_->SerialOpen(portId);
2362 if (ret != UEC_OK) {
2363 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialOpen failed", __func__);
2364 ReportUsbSerialOperationFaultSysEvent(portId, "SerialOpen", ret, "SerialOpen failed");
2365 return ret;
2366 }
2367
2368 ReportUsbSerialOperationSysEvent(portId, "SerialOpen");
2369 return UEC_OK;
2370 }
2371
SerialClose(int32_t portId)2372 int32_t UsbService::SerialClose(int32_t portId)
2373 {
2374 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2375 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2376 if (ret != UEC_OK) {
2377 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2378 ReportUsbSerialOperationFaultSysEvent(portId, "SerialClose", ret, "ValidateUsbSerialManagerAndPort failed");
2379 return ret;
2380 }
2381
2382 ReportUsbSerialOperationSysEvent(portId, "SerialClose");
2383 ret = usbSerialManager_->SerialClose(portId);
2384 if (ret != UEC_OK) {
2385 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialClose failed", __func__);
2386 ReportUsbSerialOperationFaultSysEvent(portId, "SerialClose", ret, "SerialClose failed");
2387 }
2388 return ret;
2389 }
2390
SerialRead(int32_t portId,std::vector<uint8_t> & data,uint32_t size,uint32_t & actualSize,uint32_t timeout)2391 int32_t UsbService::SerialRead(int32_t portId, std::vector<uint8_t>& data, uint32_t size,
2392 uint32_t &actualSize, uint32_t timeout)
2393 {
2394 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2395 HITRACE_METER_NAME(HITRACE_TAG_USB, "SerialRead");
2396 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2397 if (ret != UEC_OK) {
2398 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2399 ReportUsbSerialOperationFaultSysEvent(portId, "SerialRead", ret, "ValidateUsbSerialManagerAndPort failed");
2400 return ret;
2401 }
2402
2403 ret = usbSerialManager_->SerialRead(portId, data, size, actualSize, timeout);
2404 if (ret != UEC_OK) {
2405 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialRead failed", __func__);
2406 ReportUsbSerialOperationFaultSysEvent(portId, "SerialRead", ret, "SerialRead failed");
2407 }
2408 return ret;
2409 }
2410
SerialWrite(int32_t portId,const std::vector<uint8_t> & data,uint32_t size,uint32_t & actualSize,uint32_t timeout)2411 int32_t UsbService::SerialWrite(int32_t portId, const std::vector<uint8_t>& data, uint32_t size,
2412 uint32_t &actualSize, uint32_t timeout)
2413 {
2414 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2415 HITRACE_METER_NAME(HITRACE_TAG_USB, "SerialWrite");
2416 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2417 if (ret != UEC_OK) {
2418 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2419 ReportUsbSerialOperationFaultSysEvent(portId, "SerialWrite", ret, "ValidateUsbSerialManagerAndPort failed");
2420 return ret;
2421 }
2422
2423 ret = usbSerialManager_->SerialWrite(portId, data, size, actualSize, timeout);
2424 if (ret != UEC_OK) {
2425 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialWrite failed", __func__);
2426 ReportUsbSerialOperationFaultSysEvent(portId, "SerialWrite", ret, "SerialWrite failed");
2427 }
2428 return ret;
2429 }
2430
SerialAttributeChange(const UsbSerialAttr & serialAttr,OHOS::HDI::Usb::Serial::V1_0::SerialAttribute & attribute)2431 void UsbService::SerialAttributeChange(const UsbSerialAttr &serialAttr,
2432 OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attribute)
2433 {
2434 attribute.baudrate = serialAttr.baudRate_;
2435 attribute.stopBits = serialAttr.stopBits_;
2436 attribute.parity = serialAttr.parity_;
2437 attribute.dataBits = serialAttr.dataBits_;
2438 return;
2439 }
2440
SerialAttributeChange(UsbSerialAttr & serialAttr,OHOS::HDI::Usb::Serial::V1_0::SerialAttribute & attribute)2441 void UsbService::SerialAttributeChange(UsbSerialAttr &serialAttr,
2442 OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attribute)
2443 {
2444 serialAttr.baudRate_ = attribute.baudrate;
2445 serialAttr.stopBits_ = attribute.stopBits;
2446 serialAttr.parity_ = attribute.parity;
2447 serialAttr.dataBits_ = attribute.dataBits;
2448 return;
2449 }
2450
SerialGetAttribute(int32_t portId,UsbSerialAttr & attributeInfo)2451 int32_t UsbService::SerialGetAttribute(int32_t portId, UsbSerialAttr& attributeInfo)
2452 {
2453 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2454 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2455 if (ret != UEC_OK) {
2456 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2457 ReportUsbSerialOperationFaultSysEvent(portId, "SerialGetAttribute", ret,
2458 "ValidateUsbSerialManagerAndPort failed");
2459 return ret;
2460 }
2461 OHOS::HDI::Usb::Serial::V1_0::SerialAttribute serialAttr;
2462 ret = usbSerialManager_->SerialGetAttribute(portId, serialAttr);
2463 if (ret != UEC_OK) {
2464 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialGetAttribute failed", __func__);
2465 ReportUsbSerialOperationFaultSysEvent(portId, "SerialGetAttribute", ret, "SerialGetAttribute failed");
2466 }
2467 SerialAttributeChange(attributeInfo, serialAttr);
2468 return ret;
2469 }
2470
SerialSetAttribute(int32_t portId,const UsbSerialAttr & attributeInfo)2471 int32_t UsbService::SerialSetAttribute(int32_t portId,
2472 const UsbSerialAttr& attributeInfo)
2473 {
2474 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2475 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2476 if (ret != UEC_OK) {
2477 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2478 ReportUsbSerialOperationFaultSysEvent(portId, "SerialSetAttribute", ret,
2479 "ValidateUsbSerialManagerAndPort failed");
2480 return ret;
2481 }
2482 OHOS::HDI::Usb::Serial::V1_0::SerialAttribute serialAttr;
2483 SerialAttributeChange(attributeInfo, serialAttr);
2484 ret = usbSerialManager_->SerialSetAttribute(portId, serialAttr);
2485 if (ret != UEC_OK) {
2486 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialSetAttribute failed", __func__);
2487 ReportUsbSerialOperationFaultSysEvent(portId, "SerialSetAttribute", ret, "SerialSetAttribute failed");
2488 return ret;
2489 }
2490
2491 ReportUsbSerialOperationSysEvent(portId, "SerialSetAttribute");
2492 return UEC_OK;
2493 }
2494
SerialPortChange(std::vector<UsbSerialPort> & serialInfoList,std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort> & serialPortList)2495 void UsbService::SerialPortChange(std::vector<UsbSerialPort> &serialInfoList,
2496 std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort>& serialPortList)
2497 {
2498 for (size_t i = 0; i < serialPortList.size(); i++) {
2499 UsbSerialPort info;
2500 info.portId_ = serialPortList[i].portId;
2501 info.busNum_ = serialPortList[i].deviceInfo.busNum;
2502 info.devAddr_ = serialPortList[i].deviceInfo.devAddr;
2503 info.vid_ = serialPortList[i].deviceInfo.vid;
2504 info.pid_ = serialPortList[i].deviceInfo.pid;
2505 info.serialNum_ = serialPortList[i].deviceInfo.serialNum;
2506 serialInfoList.push_back(info);
2507 }
2508 return;
2509 }
2510
SerialGetPortList(std::vector<UsbSerialPort> & serialInfoList)2511 int32_t UsbService::SerialGetPortList(std::vector<UsbSerialPort>& serialInfoList)
2512 {
2513 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2514 if (usbSerialManager_ == nullptr) {
2515 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbSerialManager_ is nullptr", __func__);
2516 return UEC_SERVICE_INVALID_VALUE;
2517 }
2518 std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort> serialPortList;
2519 int32_t ret = usbSerialManager_->SerialGetPortList(serialPortList);
2520 if (ret != UEC_OK) {
2521 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialGetPortList failed", __func__);
2522 return ret;
2523 }
2524 SerialPortChange(serialInfoList, serialPortList);
2525 UpdateDeviceVidPidMap(serialPortList);
2526 return ret;
2527 }
2528
CheckDbAbility(int32_t portId)2529 int32_t UsbService::CheckDbAbility(int32_t portId)
2530 {
2531 std::shared_ptr<UsbRightDbHelper> helper = OHOS::USB::UsbRightDbHelper::GetInstance();
2532 if (helper == nullptr) {
2533 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: get dbHelper failed", __func__);
2534 ReportUsbSerialOperationFaultSysEvent(portId, "RequestSerialRight", UEC_SERIAL_DATEBASE_ERROR,
2535 "get dbHelper failed");
2536 return UEC_SERIAL_DATEBASE_ERROR;
2537 } else {
2538 return UEC_OK;
2539 }
2540 }
2541
RequestSerialRight(int32_t portId,bool & hasRight)2542 int32_t UsbService::RequestSerialRight(int32_t portId, bool &hasRight)
2543 {
2544 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2545 hasRight = false;
2546 if (usbRightManager_ == nullptr) {
2547 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbRightManager_ is nullptr", __func__);
2548 ReportUsbSerialOperationFaultSysEvent(portId, "RequestSerialRight", UEC_SERVICE_INVALID_VALUE,
2549 "usbRightManager_ is nullptr");
2550 return UEC_SERVICE_INVALID_VALUE;
2551 }
2552 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2553 if (ret != UEC_OK) {
2554 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2555 ReportUsbSerialOperationFaultSysEvent(portId, "RequestSerialRight", ret, "invalid portId");
2556 return ret;
2557 }
2558 if ((ret = CheckDbAbility(portId)) != UEC_OK) {
2559 return ret;
2560 }
2561
2562 std::string deviceName;
2563 std::string deviceVidPidSerialNum;
2564
2565 ret = GetDeviceVidPidSerialNumber(portId, deviceName, deviceVidPidSerialNum);
2566 if (ret != UEC_OK) {
2567 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: can not find deviceName.", __func__);
2568 ReportUsbSerialOperationFaultSysEvent(portId, "RequestSerialRight", ret, "can not find deviceName.");
2569 return ret;
2570 }
2571
2572 if (usbRightManager_->IsSystemAppOrSa()) {
2573 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
2574 hasRight = true;
2575 return UEC_OK;
2576 }
2577
2578 std::string bundleName;
2579 std::string tokenId;
2580 int32_t userId = USB_RIGHT_USERID_INVALID;
2581 if (!GetCallingInfo(bundleName, tokenId, userId)) {
2582 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetCallingInfo false", __func__);
2583 ReportUsbSerialOperationFaultSysEvent(portId, "RequestSerialRight", UEC_SERVICE_INVALID_VALUE,
2584 "GetCallingInfo false");
2585 return UEC_SERVICE_INVALID_VALUE;
2586 }
2587
2588 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s, tokenId=%{public}s",
2589 bundleName.c_str(), deviceName.c_str(), tokenId.c_str());
2590
2591 SerialDeviceIdentity serialDeviceIdentity = { deviceName, deviceVidPidSerialNum };
2592 if (usbRightManager_->RequestRight(portId, serialDeviceIdentity, bundleName, tokenId, userId) != UEC_OK) {
2593 USB_HILOGW(MODULE_USB_SERVICE, "%{public}s:user don't agree", __func__);
2594 return UEC_OK;
2595 }
2596
2597 hasRight = true;
2598 return UEC_OK;
2599 }
2600
CancelSerialRight(int32_t portId)2601 int32_t UsbService::CancelSerialRight(int32_t portId)
2602 {
2603 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2604 if (usbRightManager_ == nullptr) {
2605 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbRightManager_ is nullptr", __func__);
2606 ReportUsbSerialOperationFaultSysEvent(portId, "CancelSerialRight", UEC_SERVICE_INVALID_VALUE,
2607 "usbRightManager_ is nullptr");
2608 return UEC_SERVICE_INVALID_VALUE;
2609 }
2610
2611 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2612 if (ret != UEC_OK) {
2613 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2614 ReportUsbSerialOperationFaultSysEvent(portId, "CancelSerialRight", ret, "validate portId");
2615 return ret;
2616 }
2617 if ((ret = CheckDbAbility(portId)) != UEC_OK) {
2618 return ret;
2619 }
2620
2621 std::string deviceName;
2622 std::string deviceVidPidSerialNum;
2623
2624 ret = GetDeviceVidPidSerialNumber(portId, deviceName, deviceVidPidSerialNum);
2625 if (ret != UEC_OK) {
2626 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: can not find deviceName.", __func__);
2627 ReportUsbSerialOperationFaultSysEvent(portId, "CancelSerialRight", ret, "can not find deviceName.");
2628 return ret;
2629 }
2630
2631 if (usbRightManager_->IsSystemAppOrSa()) {
2632 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
2633 return UEC_OK;
2634 }
2635
2636 std::string bundleName;
2637 std::string tokenId;
2638 int32_t userId = USB_RIGHT_USERID_INVALID;
2639 if (!GetCallingInfo(bundleName, tokenId, userId)) {
2640 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetCallingInfo false", __func__);
2641 ReportUsbSerialOperationFaultSysEvent(portId, "CancelSerialRight", UEC_SERVICE_INVALID_VALUE,
2642 "GetCallingInfo false");
2643 return UEC_SERVICE_INVALID_VALUE;
2644 }
2645
2646 if (!usbRightManager_->RemoveDeviceRight(deviceVidPidSerialNum, bundleName, tokenId, userId) &&
2647 !usbRightManager_->RemoveDeviceRight(deviceVidPidSerialNum, bundleName, USB_DEFAULT_TOKEN, userId)) {
2648 USB_HILOGE(MODULE_USB_SERVICE, "RemoveDeviceRight failed");
2649 ReportUsbSerialOperationFaultSysEvent(portId, "CancelSerialRight", UEC_SERVICE_PERMISSION_DENIED,
2650 "RemoveDeviceRight failed");
2651 return UEC_SERVICE_PERMISSION_DENIED;
2652 }
2653
2654 usbSerialManager_->SerialClose(portId);
2655 return UEC_OK;
2656 }
2657
HasSerialRight(int32_t portId,bool & hasRight)2658 int32_t UsbService::HasSerialRight(int32_t portId, bool &hasRight)
2659 {
2660 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2661 hasRight = false;
2662 if (usbRightManager_ == nullptr) {
2663 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbRightManager_ is nullptr", __func__);
2664 return UEC_SERVICE_INVALID_VALUE;
2665 }
2666 int32_t ret = ValidateUsbSerialManagerAndPort(portId);
2667 if (ret != UEC_OK) {
2668 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2669 return ret;
2670 }
2671 if ((ret = CheckDbAbility(portId)) != UEC_OK) {
2672 return ret;
2673 }
2674
2675 std::string deviceName;
2676 std::string deviceVidPidSerialNum;
2677
2678 ret = GetDeviceVidPidSerialNumber(portId, deviceName, deviceVidPidSerialNum);
2679 if (ret != UEC_OK) {
2680 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: can not find deviceName.", __func__);
2681 return ret;
2682 }
2683
2684 if (usbRightManager_->IsSystemAppOrSa()) {
2685 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s ", deviceName.c_str());
2686 hasRight = true;
2687 return UEC_OK;
2688 }
2689
2690 std::string bundleName;
2691 std::string tokenId;
2692 int32_t userId = USB_RIGHT_USERID_INVALID;
2693 if (!GetCallingInfo(bundleName, tokenId, userId)) {
2694 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: HasRight GetCallingInfo false", __func__);
2695 return UEC_SERVICE_INVALID_VALUE;
2696 }
2697
2698 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s",
2699 bundleName.c_str(), deviceName.c_str());
2700 if (usbRightManager_->HasRight(deviceVidPidSerialNum, bundleName, tokenId, userId)) {
2701 hasRight = true;
2702 return UEC_OK;
2703 } else if (usbRightManager_->HasRight(deviceVidPidSerialNum, bundleName, USB_DEFAULT_TOKEN, userId)) {
2704 hasRight = true;
2705 return UEC_OK;
2706 }
2707
2708 return UEC_OK;
2709 }
2710
AddSerialRight(uint32_t tokenId,int32_t portId)2711 int32_t UsbService::AddSerialRight(uint32_t tokenId, int32_t portId)
2712 {
2713 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2714 if (usbRightManager_ == nullptr) {
2715 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: usbRightManager_ is nullptr", __func__);
2716 ReportUsbSerialOperationFaultSysEvent(portId, "AddSerialRight", UEC_SERVICE_INVALID_VALUE,
2717 "usbRightManager_ is nullptr");
2718 return UEC_SERVICE_INVALID_VALUE;
2719 }
2720
2721 int32_t ret = CheckSysApiPermission();
2722 if (ret != UEC_OK) {
2723 USB_HILOGE(MODULE_USB_SERVICE,
2724 "%{public}s: SerialCheckSysApiPermission failed ret = %{public}d", __func__, ret);
2725 ReportUsbSerialOperationFaultSysEvent(portId, "AddSerialRight", ret, "SerialCheckSysApiPermission failed");
2726 return ret;
2727 }
2728 if ((ret = CheckDbAbility(portId)) != UEC_OK) {
2729 return ret;
2730 }
2731 std::string deviceName;
2732 std::string deviceVidPidSerialNum;
2733 ret = ValidateUsbSerialManagerAndPort(portId);
2734 if (ret != UEC_OK) {
2735 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: ValidateUsbSerialManagerAndPort failed", __func__);
2736 ReportUsbSerialOperationFaultSysEvent(portId, "AddSerialRight", ret, "ValidateUsbSerialManagerAndPort failed");
2737 return ret;
2738 }
2739 ret = GetDeviceVidPidSerialNumber(portId, deviceName, deviceVidPidSerialNum);
2740 if (ret != UEC_OK) {
2741 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: can not find deviceName.", __func__);
2742 ReportUsbSerialOperationFaultSysEvent(portId, "AddSerialRight", ret, "can not find deviceName.");
2743 return ret;
2744 }
2745
2746 if (!usbRightManager_->AddDeviceRight(deviceVidPidSerialNum, std::to_string(tokenId).c_str())) {
2747 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: AddDeviceRight failed", __func__);
2748 ReportUsbSerialOperationFaultSysEvent(portId, "AddSerialRight", UEC_SERIAL_DATEBASE_ERROR,
2749 "AddDeviceRight failed");
2750 return UEC_SERIAL_DATEBASE_ERROR;
2751 }
2752
2753 USB_HILOGI(MODULE_USB_SERVICE, "AddRight done");
2754 return UEC_OK;
2755 }
2756
2757
GetDeviceVidPidSerialNumber(int32_t portId,std::string & deviceName,std::string & strDesc)2758 int32_t UsbService::GetDeviceVidPidSerialNumber(int32_t portId, std::string& deviceName, std::string& strDesc)
2759 {
2760 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2761 int32_t isMatched = UEC_INTERFACE_INVALID_VALUE;
2762 std::lock_guard<std::mutex> guard(serialPidVidMapMutex_);
2763 for (auto it = serialVidPidMap_.begin(); it != serialVidPidMap_.end(); ++it) {
2764 USB_HILOGI(MODULE_USB_SERVICE, " it->first = %{public}d", it->first);
2765 if (it->first == portId) {
2766 deviceName = it->second.first;
2767 strDesc = it->second.second;
2768 isMatched = UEC_OK;
2769 break;
2770 }
2771 }
2772 return isMatched;
2773 }
2774
UpdateDeviceVidPidMap(std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort> & serialPortList)2775 void UsbService::UpdateDeviceVidPidMap(std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort>& serialPortList)
2776 {
2777 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: Start", __func__);
2778 std::lock_guard<std::mutex> guard(serialPidVidMapMutex_);
2779 serialVidPidMap_.clear();
2780 for (auto &ele: serialPortList) {
2781 std::string busNum = std::to_string(ele.deviceInfo.busNum);
2782 std::string devAddr = std::to_string(ele.deviceInfo.devAddr);
2783 std::string vid = std::to_string(ele.deviceInfo.vid);
2784 std::string pid = std::to_string(ele.deviceInfo.pid);
2785 std::string deviceName = busNum + "-" + devAddr;
2786 std::string deviceVidPidSerialNum = vid + "-" + pid + "-" + ele.deviceInfo.serialNum;
2787 serialVidPidMap_.insert({ele.portId, {deviceName, deviceVidPidSerialNum}});
2788 }
2789 USB_HILOGI(MODULE_USB_SERVICE, "deviceVidPidMap size=%{public}zu", serialVidPidMap_.size());
2790 }
2791
ReportUsbSerialOperationSysEvent(int32_t portId,const std::string & operationType)2792 void UsbService::ReportUsbSerialOperationSysEvent(int32_t portId, const std::string &operationType)
2793 {
2794 USB_HILOGI(MODULE_USB_SERVICE, "the behavior of the usb serial");
2795 OHOS::HDI::Usb::Serial::V1_0::SerialPort serialPort;
2796 if (!usbSerialManager_->GetSerialPort(portId, serialPort)) {
2797 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetSerialPort failed", __func__);
2798 return;
2799 }
2800
2801 OHOS::HDI::Usb::Serial::V1_0::SerialAttribute attribute;
2802 if (usbSerialManager_->SerialGetAttribute(portId, attribute) != UEC_OK) {
2803 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: SerialGetAttribute failed", __func__);
2804 return;
2805 }
2806
2807 std::string bundleName;
2808 std::string tokenId;
2809 int32_t userId = USB_RIGHT_USERID_INVALID;
2810 if (!GetCallingInfo(bundleName, tokenId, userId)) {
2811 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetCallingInfo failed", __func__);
2812 return;
2813 }
2814
2815 HiSysEventWrite(HiSysEvent::Domain::USB, "SERIAL_OPERATION",
2816 HiSysEvent::EventType::BEHAVIOR, "OPERATION_TYPE_NAME", operationType,
2817 "CLIENT_NAME", bundleName,
2818 "PORT_VID", serialPort.deviceInfo.vid,
2819 "PORT_PID", serialPort.deviceInfo.pid,
2820 "PORT_ID", serialPort.deviceInfo.serialNum,
2821 "ATTRIBUTE_BAUD_RATE", attribute.baudrate,
2822 "ATTRIBUTE_STOP_BIT", attribute.stopBits,
2823 "ATTRIBUTE_PARITY_CHECK", attribute.parity,
2824 "ATTRIBUTE_DATA_BIT", attribute.dataBits);
2825 }
2826
ReportUsbSerialOperationFaultSysEvent(int32_t portId,const std::string & operationType,int32_t failReason,const std::string & failDescription)2827 void UsbService::ReportUsbSerialOperationFaultSysEvent(int32_t portId, const std::string &operationType,
2828 int32_t failReason, const std::string &failDescription)
2829 {
2830 USB_HILOGI(MODULE_USB_SERVICE, "serial port operation fault");
2831 HiSysEventWrite(HiSysEvent::Domain::USB, "OPERATION_FAULT",
2832 HiSysEvent::EventType::FAULT, "OPERATION_TYPE_NAME", operationType,
2833 "FAIL_REASON", failReason,
2834 "FAIL_DESCRIPTION", failDescription);
2835 }
2836 } // namespace USB
2837 } // namespace OHOS
2838