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