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