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
44 using OHOS::sptr;
45 using namespace OHOS::HDI::Usb::V1_0;
46
47 namespace OHOS {
48 namespace USB {
49 namespace {
50 constexpr const char *USB_SERVICE_NAME = "UsbService";
51 constexpr int32_t COMMEVENT_REGISTER_RETRY_TIMES = 10;
52 constexpr int32_t COMMEVENT_REGISTER_WAIT_DELAY_US = 20000;
53 constexpr uint32_t CURSOR_INIT = 18;
54 constexpr int32_t DESCRIPTOR_TYPE_STRING = 3;
55 constexpr int32_t DESCRIPTOR_VALUE_START_OFFSET = 2;
56 constexpr int32_t HALF = 2;
57 constexpr int32_t BIT_SHIFT_4 = 4;
58 constexpr int32_t BIT_HIGH_4 = 0xF0;
59 constexpr int32_t BIT_LOW_4 = 0x0F;
60 constexpr int32_t SERVICE_STARTUP_MAX_TIME = 30;
61 constexpr uint32_t UNLOAD_SA_TIMER_INTERVAL = 30 * 1000;
62 constexpr uint32_t MANAGE_INTERFACE_INTERVAL = 100;
63 constexpr uint32_t EDM_SA_MAX_TIME_OUT = 5000;
64 constexpr uint32_t EDM_SYSTEM_ABILITY_ID = 1601;
65 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
66 constexpr uint32_t WITHOUT_USERID = 0;
67 constexpr uint32_t WITHOUT_ADMIN = 1;
68 constexpr uint32_t EMD_MASK_CODE = 20;
69 constexpr uint32_t DISABLE_USB = 1043;
70 constexpr uint32_t ALLOWED_USB_DEVICES = 1044;
71 constexpr uint32_t USB_STORAGE_DEVICE_ACCESS_POLICY = 1026;
72 constexpr int32_t WHITELIST_POLICY_MAX_DEVICES = 1000;
73 constexpr uint32_t EDM_SA_TIME_OUT_CODE = 9200007;
74 constexpr int32_t BASECLASS_INDEX = 0;
75 constexpr int32_t SUBCLASS_INDEX = 1;
76 constexpr int32_t PROTOCAL_INDEX = 2;
77 constexpr int32_t GET_EDM_STORAGE_DISABLE_TYPE = 2;
78 constexpr int32_t RANDOM_VALUE_INDICATE = -1;
79
80 std::unordered_map<InterfaceType, std::vector<int32_t>> typeMap = {
81 {InterfaceType::TYPE_STORAGE, {8, -1, -1}},
82 {InterfaceType::TYPE_AUDIO, {1, -1, -1}},
83 {InterfaceType::TYPE_HID, {3, -1, -1}},
84 {InterfaceType::TYPE_PHYSICAL, {5, -1, -1}},
85 {InterfaceType::TYPE_IMAGE, {6, 1, 1}},
86 {InterfaceType::TYPE_PRINTER, {7, -1, -1}}
87 };
88 } // namespace
89
90 auto g_serviceInstance = DelayedSpSingleton<UsbService>::GetInstance();
91 const bool G_REGISTER_RESULT =
92 SystemAbility::MakeAndRegisterAbility(DelayedSpSingleton<UsbService>::GetInstance().GetRefPtr());
93
UsbService()94 UsbService::UsbService() : SystemAbility(USB_SYSTEM_ABILITY_ID, true)
95 {
96 usbHostManager_ = std::make_shared<UsbHostManager>(nullptr);
97 usbRightManager_ = std::make_shared<UsbRightManager>();
98 usbPortManager_ = std::make_shared<UsbPortManager>();
99 usbDeviceManager_ = std::make_shared<UsbDeviceManager>();
100 usbd_ = IUsbInterface::Get();
101 if (usbd_ == nullptr) {
102 USB_HILOGE(MODULE_USB_SERVICE, "IUsbInterface::Get inteface failed");
103 }
104 }
~UsbService()105 UsbService::~UsbService() {}
106
SetUsbd(const sptr<IUsbInterface> & usbd)107 int32_t UsbService::SetUsbd(const sptr<IUsbInterface> &usbd)
108 {
109 if (usbd == nullptr) {
110 USB_HILOGE(MODULE_USB_SERVICE, "UsbService usbd is nullptr");
111 return UEC_SERVICE_INVALID_VALUE;
112 }
113 usbd_ = usbd;
114
115 if (usbPortManager_ == nullptr) {
116 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
117 return UEC_SERVICE_INVALID_VALUE;
118 }
119 usbPortManager_->SetUsbd(usbd);
120
121 if (usbDeviceManager_ == nullptr) {
122 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
123 return UEC_SERVICE_INVALID_VALUE;
124 }
125 usbDeviceManager_->SetUsbd(usbd);
126 return UEC_OK;
127 }
128
SystemAbilityStatusChangeListener(sptr<UsbServiceSubscriber> usbdSubscriber)129 UsbService::SystemAbilityStatusChangeListener::SystemAbilityStatusChangeListener(
130 sptr<UsbServiceSubscriber> usbdSubscriber)
131 : usbdSubscriber_(usbdSubscriber)
132 {
133 }
134
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)135 void UsbService::SystemAbilityStatusChangeListener::OnAddSystemAbility(
136 int32_t systemAbilityId, const std::string &deviceId)
137 {
138 USB_HILOGI(MODULE_USB_SERVICE, "OnAddSystemAbility ID = %{public}d", systemAbilityId);
139 }
140
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)141 void UsbService::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
142 int32_t systemAbilityId, const std::string &deviceId)
143 {
144 USB_HILOGI(MODULE_USB_SERVICE, "OnRemoveSystemAbility ID = %{public}d", systemAbilityId);
145 if (systemAbilityId == USB_SYSTEM_ABILITY_ID) {
146 sptr<IUsbInterface> usbd_ = IUsbInterface::Get();
147 if (usbd_ != nullptr) {
148 usbd_->UnbindUsbdSubscriber(usbdSubscriber_);
149 }
150 }
151 }
152
OnStart()153 void UsbService::OnStart()
154 {
155 USB_HILOGI(MODULE_USB_SERVICE, "usb_service OnStart enter");
156 if (ready_) {
157 USB_HILOGE(MODULE_USB_SERVICE, "OnStart is ready, nothing to do");
158 return;
159 }
160
161 if (!(Init())) {
162 USB_HILOGE(MODULE_USB_SERVICE, "OnStart call init fail");
163 return;
164 }
165
166 // wait for the usbd service to start and bind usb service and usbd service
167 int32_t retryTimes = 0;
168 while (retryTimes < SERVICE_STARTUP_MAX_TIME) {
169 if (InitUsbd()) {
170 break;
171 }
172 sleep(1);
173 retryTimes++;
174
175 if (retryTimes == SERVICE_STARTUP_MAX_TIME) {
176 USB_HILOGE(MODULE_USB_SERVICE, "OnStart call initUsbd failed");
177 return;
178 }
179 }
180
181 if (usbPortManager_ == nullptr) {
182 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
183 return;
184 }
185
186 usbPortManager_->Init();
187 (void)usbDeviceManager_->Init();
188 (void)InitUsbRight();
189 ready_ = true;
190 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
191 sptr<ISystemAbilityStatusChange> status = new (std::nothrow) SystemAbilityStatusChangeListener(usbdSubscriber_);
192 if (samgrProxy == nullptr || status == nullptr) {
193 USB_HILOGE(MODULE_USB_SERVICE, "samgrProxy or SystemAbilityStatusChangeListener is nullptr");
194 return;
195 }
196 int32_t ret = samgrProxy->SubscribeSystemAbility(USB_SYSTEM_ABILITY_ID, status);
197 if (ret != UEC_OK) {
198 USB_HILOGE(MODULE_USB_SERVICE, "SubscribeSystemAbility failed. ret = %{public}d", ret);
199 return;
200 }
201 USB_HILOGE(MODULE_USB_SERVICE, "OnStart and add system ability success");
202 }
203
Init()204 bool UsbService::Init()
205 {
206 USB_HILOGI(MODULE_USB_SERVICE, "usb_service Init enter");
207 if (!eventRunner_) {
208 eventRunner_ = AppExecFwk::EventRunner::Create(USB_SERVICE_NAME);
209 if (eventRunner_ == nullptr) {
210 USB_HILOGE(MODULE_USB_SERVICE, "Init failed due to create EventRunner");
211 return false;
212 }
213 }
214 if (handler_ == nullptr) {
215 handler_ = std::make_shared<UsbServerEventHandler>(eventRunner_, g_serviceInstance);
216
217 if (!Publish(g_serviceInstance)) {
218 USB_HILOGE(MODULE_USB_SERVICE, "OnStart register to system ability manager failed.");
219 return false;
220 }
221 }
222 while (commEventRetryTimes_ <= COMMEVENT_REGISTER_RETRY_TIMES) {
223 if (!IsCommonEventServiceAbilityExist()) {
224 ++commEventRetryTimes_;
225 usleep(COMMEVENT_REGISTER_WAIT_DELAY_US);
226 } else {
227 commEventRetryTimes_ = 0;
228 break;
229 }
230 }
231 USB_HILOGE(MODULE_USB_SERVICE, "Init success");
232 return true;
233 }
234
InitUsbd()235 bool UsbService::InitUsbd()
236 {
237 usbd_ = IUsbInterface::Get();
238 if (usbd_ == nullptr) {
239 USB_HILOGE(MODULE_USB_SERVICE, " get usbd_ is nullptr");
240 return false;
241 }
242
243 usbdSubscriber_ = new (std::nothrow) UsbServiceSubscriber();
244 if (usbdSubscriber_ == nullptr) {
245 USB_HILOGE(MODULE_USB_SERVICE, "Init failed\n");
246 return false;
247 }
248 recipient_ = new UsbdDeathRecipient();
249 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<HDI::Usb::V1_0::IUsbInterface>(usbd_);
250 if (!remote->AddDeathRecipient(recipient_)) {
251 USB_HILOGE(MODULE_USB_SERVICE, "add DeathRecipient failed");
252 return false;
253 }
254
255 ErrCode ret = usbd_->BindUsbdSubscriber(usbdSubscriber_);
256 USB_HILOGI(MODULE_USB_SERVICE, "entry InitUsbd ret: %{public}d", ret);
257 return SUCCEEDED(ret);
258 }
259
OnStop()260 void UsbService::OnStop()
261 {
262 USB_HILOGI(MODULE_USB_SERVICE, "entry stop service %{public}d", ready_);
263 if (!ready_) {
264 return;
265 }
266 eventRunner_.reset();
267 handler_.reset();
268 ready_ = false;
269
270 if (usbd_ == nullptr) {
271 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
272 return;
273 }
274 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<HDI::Usb::V1_0::IUsbInterface>(usbd_);
275 remote->RemoveDeathRecipient(recipient_);
276 recipient_.clear();
277 usbd_->UnbindUsbdSubscriber(usbdSubscriber_);
278 }
279
IsCommonEventServiceAbilityExist()280 bool UsbService::IsCommonEventServiceAbilityExist()
281 {
282 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
283 if (sm == nullptr) {
284 USB_HILOGE(MODULE_USB_SERVICE,
285 "IsCommonEventServiceAbilityExist Get ISystemAbilityManager "
286 "failed, no SystemAbilityManager");
287 return false;
288 }
289 sptr<IRemoteObject> remote = sm->CheckSystemAbility(COMMON_EVENT_SERVICE_ID);
290 if (!remote) {
291 USB_HILOGE(MODULE_USB_SERVICE, "No CesServiceAbility");
292 return false;
293 }
294 return true;
295 }
296
OpenDevice(uint8_t busNum,uint8_t devAddr)297 int32_t UsbService::OpenDevice(uint8_t busNum, uint8_t devAddr)
298 {
299 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
300 if (!UsbService::HasRight(name)) {
301 USB_HILOGE(MODULE_USB_SERVICE, "No permission");
302 return UEC_SERVICE_PERMISSION_DENIED;
303 }
304
305 const UsbDev dev = {busNum, devAddr};
306 if (usbd_ == nullptr) {
307 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
308 return UEC_SERVICE_INVALID_VALUE;
309 }
310 int32_t ret = usbd_->OpenDevice(dev);
311 if (ret != UEC_OK) {
312 USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret:%{public}d", ret);
313 }
314
315 return ret;
316 }
317
GetDeviceVidPidSerialNumber(std::string deviceName)318 std::string UsbService::GetDeviceVidPidSerialNumber(std::string deviceName)
319 {
320 std::string strDesc = "test";
321 std::lock_guard<std::mutex> guard(mutex_);
322 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
323 USB_HILOGI(MODULE_USB_SERVICE, " it->first = %{public}s", it->first.c_str());
324 if (it->first == deviceName) {
325 strDesc = it->second;
326 break;
327 }
328 }
329 return strDesc;
330 }
331
GetDeviceVidPidSerialNumber(std::string deviceName,std::string & strDesc)332 int32_t UsbService::GetDeviceVidPidSerialNumber(std::string deviceName, std::string& strDesc)
333 {
334 int32_t isMatched = UEC_INTERFACE_INVALID_VALUE;
335 std::lock_guard<std::mutex> guard(mutex_);
336 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
337 USB_HILOGI(MODULE_USB_SERVICE, " it->first = %{public}s", it->first.c_str());
338 if (it->first == deviceName) {
339 strDesc = it->second;
340 isMatched = UEC_OK;
341 break;
342 }
343 }
344 return isMatched;
345 }
346
HasRight(std::string deviceName)347 bool UsbService::HasRight(std::string deviceName)
348 {
349 USB_HILOGI(MODULE_USB_SERVICE, "calling usbRightManager HasRight");
350 if (usbRightManager_ == nullptr) {
351 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
352 return false;
353 }
354
355 std::string deviceVidPidSerialNum = "";
356 if (GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum) != UEC_OK) {
357 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
358 return false;
359 }
360
361 if (usbRightManager_->IsSystemHap()) {
362 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
363 return true;
364 }
365
366 std::string bundleName;
367 if (!GetBundleName(bundleName)) {
368 USB_HILOGE(MODULE_USB_SERVICE, "HasRight GetBundleName false");
369 return false;
370 }
371
372 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s", bundleName.c_str(), deviceName.c_str());
373 return usbRightManager_->HasRight(deviceVidPidSerialNum, bundleName);
374 }
375
RequestRight(std::string deviceName)376 int32_t UsbService::RequestRight(std::string deviceName)
377 {
378 USB_HILOGI(MODULE_USB_SERVICE, "calling usbRightManager RequestRight");
379 if (usbRightManager_ == nullptr) {
380 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
381 return UEC_SERVICE_INNER_ERR;
382 }
383 std::string deviceVidPidSerialNum = "";
384 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
385 if (ret != UEC_OK) {
386 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
387 return ret;
388 }
389 if (usbRightManager_->IsSystemHap()) {
390 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
391 return UEC_OK;
392 }
393 std::string bundleName;
394 if (!GetBundleName(bundleName)) {
395 USB_HILOGI(MODULE_USB_SERVICE, "RequestRight GetBundleName false");
396 return UEC_SERVICE_INNER_ERR;
397 }
398
399 USB_HILOGI(MODULE_USB_SERVICE, "bundle=%{public}s, device=%{public}s", bundleName.c_str(), deviceName.c_str());
400 return usbRightManager_->RequestRight(deviceName, deviceVidPidSerialNum, bundleName);
401 }
402
RemoveRight(std::string deviceName)403 int32_t UsbService::RemoveRight(std::string deviceName)
404 {
405 if (usbRightManager_ == nullptr) {
406 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
407 return UEC_SERVICE_INVALID_VALUE;
408 }
409 std::string deviceVidPidSerialNum = "";
410 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
411 if (ret != UEC_OK) {
412 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
413 return ret;
414 }
415 if (usbRightManager_->IsSystemHap()) {
416 USB_HILOGW(MODULE_USB_SERVICE, "system app, bypass: dev=%{public}s", deviceName.c_str());
417 return UEC_OK;
418 }
419 std::string bundleName;
420 if (!GetBundleName(bundleName)) {
421 USB_HILOGE(MODULE_USB_SERVICE, "RequestRight GetBundleName false");
422 return UEC_SERVICE_INNER_ERR;
423 }
424
425 if (!usbRightManager_->RemoveDeviceRight(deviceVidPidSerialNum, bundleName)) {
426 USB_HILOGE(MODULE_USB_SERVICE, "RemoveDeviceRight failed");
427 return UEC_SERVICE_INNER_ERR;
428 }
429 USB_HILOGI(MODULE_USB_SERVICE, "RemoveRight done");
430 return UEC_OK;
431 }
432
GetDevices(std::vector<UsbDevice> & deviceList)433 int32_t UsbService::GetDevices(std::vector<UsbDevice> &deviceList)
434 {
435 std::map<std::string, UsbDevice *> devices;
436
437 if (usbHostManager_ == nullptr) {
438 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_");
439 return UEC_SERVICE_INVALID_VALUE;
440 }
441
442 usbHostManager_->GetDevices(devices);
443 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
444 for (auto it = devices.begin(); it != devices.end(); ++it) {
445 if (!(usbRightManager_->IsSystemHap())) {
446 it->second->SetmSerial("");
447 }
448 deviceList.push_back(*it->second);
449 }
450 return UEC_OK;
451 }
452
GetCurrentFunctions(int32_t & functions)453 int32_t UsbService::GetCurrentFunctions(int32_t &functions)
454 {
455 if (usbRightManager_ == nullptr) {
456 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
457 return UEC_SERVICE_INVALID_VALUE;
458 }
459 if (!(usbRightManager_->IsSystemHap())) {
460 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
461 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
462 }
463 if (usbd_ == nullptr) {
464 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
465 return UEC_SERVICE_INVALID_VALUE;
466 }
467 return usbd_->GetCurrentFunctions(functions);
468 }
469
SetCurrentFunctions(int32_t functions)470 int32_t UsbService::SetCurrentFunctions(int32_t functions)
471 {
472 USB_HILOGI(MODULE_USB_SERVICE, "func = %{public}d", functions);
473 if (usbRightManager_ == nullptr) {
474 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
475 return UEC_SERVICE_INVALID_VALUE;
476 }
477
478 int32_t ret = usbRightManager_->HasSetFuncRight(functions);
479 if (ret != 0) {
480 USB_HILOGE(MODULE_USB_SERVICE, "HasSetFuncRight fail");
481 return ret;
482 }
483 if (usbDeviceManager_ == nullptr) {
484 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
485 return UEC_SERVICE_INVALID_VALUE;
486 }
487 usbDeviceManager_->UpdateFunctions(functions);
488
489 if (usbd_ == nullptr) {
490 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
491 return UEC_SERVICE_INVALID_VALUE;
492 }
493 return usbd_->SetCurrentFunctions(functions);
494 }
495
UsbFunctionsFromString(std::string_view funcs)496 int32_t UsbService::UsbFunctionsFromString(std::string_view funcs)
497 {
498 if (usbRightManager_ == nullptr) {
499 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
500 return UEC_SERVICE_INVALID_VALUE;
501 }
502 if (!(usbRightManager_->IsSystemHap())) {
503 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
504 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
505 }
506 USB_HILOGI(MODULE_USB_SERVICE, "calling UsbFunctionsFromString");
507 return UsbDeviceManager::ConvertFromString(funcs);
508 }
509
UsbFunctionsToString(int32_t funcs)510 std::string UsbService::UsbFunctionsToString(int32_t funcs)
511 {
512 if (usbRightManager_ == nullptr) {
513 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
514 return "";
515 }
516 if (!(usbRightManager_->IsSystemHap())) {
517 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
518 return PERMISSION_DENIED_SYSAPI;
519 }
520 USB_HILOGI(MODULE_USB_SERVICE, "calling UsbFunctionsToString");
521 return UsbDeviceManager::ConvertToString(funcs);
522 }
523
GetPorts(std::vector<UsbPort> & ports)524 int32_t UsbService::GetPorts(std::vector<UsbPort> &ports)
525 {
526 USB_HILOGI(MODULE_USB_SERVICE, "calling usbPortManager getPorts");
527 if (usbRightManager_ == nullptr) {
528 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
529 return UEC_SERVICE_INVALID_VALUE;
530 }
531 if (!(usbRightManager_->IsSystemHap())) {
532 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
533 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
534 }
535 if (usbPortManager_ == nullptr) {
536 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
537 return UEC_SERVICE_INVALID_VALUE;
538 }
539 return usbPortManager_->GetPorts(ports);
540 }
541
GetSupportedModes(int32_t portId,int32_t & supportedModes)542 int32_t UsbService::GetSupportedModes(int32_t portId, int32_t &supportedModes)
543 {
544 USB_HILOGI(MODULE_USB_SERVICE, "calling usbPortManager getSupportedModes");
545 if (usbRightManager_ == nullptr) {
546 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
547 return UEC_SERVICE_INVALID_VALUE;
548 }
549 if (!(usbRightManager_->IsSystemHap())) {
550 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
551 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
552 }
553 if (usbPortManager_ == nullptr) {
554 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
555 return UEC_SERVICE_INVALID_VALUE;
556 }
557 return usbPortManager_->GetSupportedModes(portId, supportedModes);
558 }
559
SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)560 int32_t UsbService::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole)
561 {
562 USB_HILOGI(MODULE_USB_SERVICE, "calling usbd getPorts");
563 if (usbRightManager_ == nullptr) {
564 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
565 return UEC_SERVICE_INVALID_VALUE;
566 }
567 if (!(usbRightManager_->IsSystemHap())) {
568 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
569 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
570 }
571 if (usbd_ == nullptr) {
572 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
573 return UEC_SERVICE_INVALID_VALUE;
574 }
575 auto ret = usbd_->SetPortRole(portId, powerRole, dataRole);
576 if (ret == HDF_ERR_NOT_SUPPORT) {
577 USB_HILOGE(MODULE_USB_SERVICE, "SetPortRole not support");
578 return UEC_SERVICE_NOT_SUPPORT_SWITCH_PORT;
579 }
580 return ret;
581 }
582
ClaimInterface(uint8_t busNum,uint8_t devAddr,uint8_t interface,uint8_t force)583 int32_t UsbService::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface, uint8_t force)
584 {
585 const UsbDev dev = {busNum, devAddr};
586 if (usbd_ == nullptr) {
587 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
588 return UEC_SERVICE_INVALID_VALUE;
589 }
590 return usbd_->ClaimInterface(dev, interface, force);
591 }
592
ReleaseInterface(uint8_t busNum,uint8_t devAddr,uint8_t interface)593 int32_t UsbService::ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_t interface)
594 {
595 const UsbDev dev = {busNum, devAddr};
596 if (usbd_ == nullptr) {
597 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
598 return UEC_SERVICE_INVALID_VALUE;
599 }
600 return usbd_->ReleaseInterface(dev, interface);
601 }
602
BulkTransferRead(const UsbDev & devInfo,const UsbPipe & pipe,std::vector<uint8_t> & bufferData,int32_t timeOut)603 int32_t UsbService::BulkTransferRead(
604 const UsbDev &devInfo, const UsbPipe &pipe, std::vector<uint8_t> &bufferData, int32_t timeOut)
605 {
606 if (usbd_ == nullptr) {
607 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
608 return UEC_SERVICE_INVALID_VALUE;
609 }
610 int32_t ret = usbd_->BulkTransferRead(devInfo, pipe, timeOut, bufferData);
611 if (ret != UEC_OK) {
612 USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferRead error ret:%{public}d", ret);
613 }
614 return ret;
615 }
616
BulkTransferWrite(const UsbDev & dev,const UsbPipe & pipe,const std::vector<uint8_t> & bufferData,int32_t timeOut)617 int32_t UsbService::BulkTransferWrite(
618 const UsbDev &dev, const UsbPipe &pipe, const std::vector<uint8_t> &bufferData, int32_t timeOut)
619 {
620 if (usbd_ == nullptr) {
621 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
622 return UEC_SERVICE_INVALID_VALUE;
623 }
624 int32_t ret = usbd_->BulkTransferWrite(dev, pipe, timeOut, bufferData);
625 if (ret != UEC_OK) {
626 USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferWrite error ret:%{public}d", ret);
627 }
628 return ret;
629 }
630
ControlTransfer(const UsbDev & dev,const UsbCtrlTransfer & ctrl,std::vector<uint8_t> & bufferData)631 int32_t UsbService::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector<uint8_t> &bufferData)
632 {
633 if (usbd_ == nullptr) {
634 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
635 return UEC_SERVICE_INVALID_VALUE;
636 }
637
638 int32_t ret = UEC_SERVICE_INNER_ERR;
639 if (((uint32_t)ctrl.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
640 ret = usbd_->ControlTransferWrite(dev, ctrl, bufferData);
641 if (ret != UEC_OK) {
642 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferWrite error ret:%{public}d", ret);
643 }
644 } else {
645 bufferData.clear();
646 ret = usbd_->ControlTransferRead(dev, ctrl, bufferData);
647 if (ret != UEC_OK) {
648 USB_HILOGE(MODULE_USB_SERVICE, "ControlTransferRead error ret:%{public}d", ret);
649 }
650 }
651 return ret;
652 }
653
SetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t configIndex)654 int32_t UsbService::SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t configIndex)
655 {
656 const UsbDev dev = {busNum, devAddr};
657 if (usbd_ == nullptr) {
658 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
659 return UEC_SERVICE_INVALID_VALUE;
660 }
661 return usbd_->SetConfig(dev, configIndex);
662 }
663
GetActiveConfig(uint8_t busNum,uint8_t devAddr,uint8_t & configIndex)664 int32_t UsbService::GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t &configIndex)
665 {
666 const UsbDev dev = {busNum, devAddr};
667 if (usbd_ == nullptr) {
668 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
669 return UEC_SERVICE_INVALID_VALUE;
670 }
671 return usbd_->GetConfig(dev, configIndex);
672 }
673
SetInterface(uint8_t busNum,uint8_t devAddr,uint8_t interfaceid,uint8_t altIndex)674 int32_t UsbService::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t interfaceid, uint8_t altIndex)
675 {
676 const UsbDev dev = {busNum, devAddr};
677 if (usbd_ == nullptr) {
678 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
679 return UEC_SERVICE_INVALID_VALUE;
680 }
681 return usbd_->SetInterface(dev, interfaceid, altIndex);
682 }
683
GetRawDescriptor(uint8_t busNum,uint8_t devAddr,std::vector<uint8_t> & bufferData)684 int32_t UsbService::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vector<uint8_t> &bufferData)
685 {
686 const UsbDev dev = {busNum, devAddr};
687 if (usbd_ == nullptr) {
688 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
689 return UEC_SERVICE_INVALID_VALUE;
690 }
691 int32_t ret = usbd_->GetRawDescriptor(dev, bufferData);
692 if (ret != UEC_OK) {
693 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
694 }
695 return ret;
696 }
697
GetFileDescriptor(uint8_t busNum,uint8_t devAddr,int32_t & fd)698 int32_t UsbService::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &fd)
699 {
700 const UsbDev dev = {busNum, devAddr};
701 if (usbd_ == nullptr) {
702 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
703 return UEC_SERVICE_INVALID_VALUE;
704 }
705 int32_t ret = usbd_->GetFileDescriptor(dev, fd);
706 if (ret != UEC_OK) {
707 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
708 }
709 return ret;
710 }
711
RequestQueue(const UsbDev & dev,const UsbPipe & pipe,const std::vector<uint8_t> & clientData,const std::vector<uint8_t> & bufferData)712 int32_t UsbService::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, const std::vector<uint8_t> &clientData,
713 const std::vector<uint8_t> &bufferData)
714 {
715 if (usbd_ == nullptr) {
716 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
717 return UEC_SERVICE_INVALID_VALUE;
718 }
719 int32_t ret = usbd_->RequestQueue(dev, pipe, clientData, bufferData);
720 if (ret != UEC_OK) {
721 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
722 }
723 return ret;
724 }
725
RequestWait(const UsbDev & dev,int32_t timeOut,std::vector<uint8_t> & clientData,std::vector<uint8_t> & bufferData)726 int32_t UsbService::RequestWait(
727 const UsbDev &dev, int32_t timeOut, std::vector<uint8_t> &clientData, std::vector<uint8_t> &bufferData)
728 {
729 if (usbd_ == nullptr) {
730 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
731 return UEC_SERVICE_INVALID_VALUE;
732 }
733 int32_t ret = usbd_->RequestWait(dev, clientData, bufferData, timeOut);
734 if (ret != UEC_OK) {
735 USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
736 }
737 return ret;
738 }
739
RequestCancel(uint8_t busNum,uint8_t devAddr,uint8_t interfaceId,uint8_t endpointId)740 int32_t UsbService::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t interfaceId, uint8_t endpointId)
741 {
742 const UsbDev dev = {busNum, devAddr};
743 const UsbPipe pipe = {interfaceId, endpointId};
744 if (usbd_ == nullptr) {
745 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
746 return UEC_SERVICE_INVALID_VALUE;
747 }
748 return usbd_->RequestCancel(dev, pipe);
749 }
750
Close(uint8_t busNum,uint8_t devAddr)751 int32_t UsbService::Close(uint8_t busNum, uint8_t devAddr)
752 {
753 const UsbDev dev = {busNum, devAddr};
754 if (usbd_ == nullptr) {
755 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
756 return UEC_SERVICE_INVALID_VALUE;
757 }
758 return usbd_->CloseDevice(dev);
759 }
760
GetDevStringValFromIdx(uint8_t busNum,uint8_t devAddr,uint8_t idx)761 std::string UsbService::GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8_t idx)
762 {
763 const UsbDev dev = {busNum, devAddr};
764 std::vector<uint8_t> strV;
765 std::string strDesc = " ";
766
767 if (idx == 0) {
768 return strDesc;
769 }
770
771 if (usbd_ == nullptr) {
772 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
773 return nullptr;
774 }
775 int32_t ret = usbd_->GetStringDescriptor(dev, idx, strV);
776 if (ret != UEC_OK) {
777 USB_HILOGE(MODULE_USB_SERVICE, "get string[%{public}hhu] failed ret:%{public}d", idx, ret);
778 return strDesc;
779 }
780 uint32_t length = strV.size();
781 if ((length < DESCRIPTOR_VALUE_START_OFFSET) || (strV[1] != DESCRIPTOR_TYPE_STRING)) {
782 USB_HILOGI(MODULE_USB_SERVICE, "type or length error, len:%{public}u", length);
783 return strDesc;
784 }
785
786 uint16_t *tbuf = new (std::nothrow) uint16_t[length + 1]();
787 if (tbuf == nullptr) {
788 USB_HILOGI(MODULE_USB_SERVICE, "new failed\n");
789 return strDesc;
790 }
791
792 for (uint32_t i = 0; i < length - DESCRIPTOR_VALUE_START_OFFSET; ++i) {
793 tbuf[i] = strV[i + DESCRIPTOR_VALUE_START_OFFSET];
794 }
795 std::wstring wstr(reinterpret_cast<wchar_t *>(tbuf), (length - DESCRIPTOR_VALUE_START_OFFSET) / HALF);
796 strDesc = std::string(wstr.begin(), wstr.end());
797 USB_HILOGI(MODULE_USB_SERVICE, "getString idx:%{public}d length:%{public}d", idx, length);
798 delete[] tbuf;
799 return strDesc;
800 }
801
BcdToString(const std::vector<uint8_t> & bcd)802 static std::string BcdToString(const std::vector<uint8_t> &bcd)
803 {
804 std::string tstr;
805 for (uint32_t i = 0; i < bcd.size(); ++i) {
806 tstr += std::to_string((bcd[i] & BIT_HIGH_4) >> BIT_SHIFT_4);
807 tstr += std::to_string((bcd[i] & BIT_LOW_4));
808 }
809 return tstr;
810 }
811
FillDevStrings(UsbDevice & dev)812 int32_t UsbService::FillDevStrings(UsbDevice &dev)
813 {
814 uint8_t busNum;
815 uint8_t devAddr;
816 uint8_t offsetValue = 8;
817
818 busNum = dev.GetBusNum();
819 devAddr = dev.GetDevAddr();
820 uint16_t bcdDevice = dev.GetbcdDevice();
821 const std::vector<uint8_t> bcdData {(bcdDevice & 0xff), ((bcdDevice >> offsetValue) & 0xff)};
822 dev.SetVersion(BcdToString(bcdData));
823 dev.SetManufacturerName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiManufacturer()));
824 dev.SetProductName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiProduct()));
825 dev.SetmSerial(GetDevStringValFromIdx(busNum, devAddr, dev.GetiSerialNumber()));
826 USB_HILOGI(MODULE_USB_SERVICE,
827 "iSerial:%{public}d Manufactur:%{public}s product:%{public}s "
828 "version:%{public}s",
829 dev.GetiSerialNumber(), dev.GetManufacturerName().c_str(), dev.GetProductName().c_str(),
830 dev.GetVersion().c_str());
831
832 std::vector<USBConfig> configs;
833 configs = dev.GetConfigs();
834 for (auto it = configs.begin(); it != configs.end(); ++it) {
835 it->SetName(GetDevStringValFromIdx(busNum, devAddr, it->GetiConfiguration()));
836 USB_HILOGI(MODULE_USB_SERVICE, "Config:%{public}d %{public}s", it->GetiConfiguration(), it->GetName().c_str());
837 std::vector<UsbInterface> interfaces = it->GetInterfaces();
838 for (auto itIF = interfaces.begin(); itIF != interfaces.end(); ++itIF) {
839 itIF->SetName(GetDevStringValFromIdx(busNum, devAddr, itIF->GetiInterface()));
840 USB_HILOGI(MODULE_USB_SERVICE, "interface:%{public}hhu %{public}s", itIF->GetiInterface(),
841 itIF->GetName().c_str());
842 }
843 it->SetInterfaces(interfaces);
844 }
845 dev.SetConfigs(configs);
846
847 return UEC_OK;
848 }
849
GetDeviceInfoDescriptor(const UsbDev & uDev,std::vector<uint8_t> & descriptor,UsbDevice & dev)850 int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint8_t> &descriptor, UsbDevice &dev)
851 {
852 if (usbd_ == nullptr) {
853 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
854 return UEC_SERVICE_INVALID_VALUE;
855 }
856 int32_t ret = usbd_->GetRawDescriptor(uDev, descriptor);
857 if (ret != UEC_OK) {
858 usbd_->CloseDevice(uDev);
859 USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed ret=%{public}d busNum:%{public}d devAddr:%{public}d",
860 ret, uDev.busNum, uDev.devAddr);
861 return ret;
862 }
863 uint8_t *buffer = descriptor.data();
864 uint32_t length = descriptor.size();
865 if ((!buffer) || (length == 0)) {
866 USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed len=%{public}d busNum:%{public}d devAddr:%{public}d",
867 length, uDev.busNum, uDev.devAddr);
868 return UEC_SERVICE_INVALID_VALUE;
869 }
870 dev.SetBusNum(uDev.busNum);
871 dev.SetDevAddr(uDev.devAddr);
872 dev.SetName(std::to_string(uDev.busNum) + "-" + std::to_string(uDev.devAddr));
873
874 ret = UsbDescriptorParser::ParseDeviceDescriptor(buffer, length, dev);
875 if (ret != UEC_OK) {
876 usbd_->CloseDevice(uDev);
877 USB_HILOGE(MODULE_USB_SERVICE, "ParseDeviceDescriptor failed ret=%{public}d", ret);
878 return ret;
879 }
880 return ret;
881 }
882
GetConfigDescriptor(UsbDevice & dev,std::vector<uint8_t> & descriptor)883 int32_t UsbService::GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &descriptor)
884 {
885 std::vector<USBConfig> configs;
886 uint8_t *buffer = descriptor.data();
887 uint32_t length = descriptor.size();
888 uint32_t cursor = CURSOR_INIT;
889 int32_t ret = UEC_OK;
890 for (uint8_t i = 0; i < dev.GetDescConfigCount(); ++i) {
891 if (length <= cursor) {
892 USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor[%{public}d] length=%{public}d", i, length);
893 break;
894 }
895 USB_HILOGI(MODULE_USB_SERVICE, "GetConfigDescriptor length=%{public}d", length);
896 uint32_t configCursor = 0;
897 USBConfig config;
898 ret = UsbDescriptorParser::ParseConfigDescriptor(buffer + cursor, length - cursor, configCursor, config);
899 if (ret != UEC_OK) {
900 USB_HILOGE(MODULE_USB_SERVICE, "ParseConfigDescriptor failed ret=%{public}d", ret);
901 return ret;
902 }
903 cursor += configCursor;
904 configs.push_back(config);
905 }
906 dev.SetConfigs(configs);
907 ret = FillDevStrings(dev);
908 USB_HILOGI(MODULE_USB_SERVICE, "FillDevStrings ret=%{public}d", ret);
909 return ret;
910 }
911
GetDeviceInfo(uint8_t busNum,uint8_t devAddr,UsbDevice & dev)912 int32_t UsbService::GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev)
913 {
914 USB_HILOGI(MODULE_USB_SERVICE, "busNum:%{public}d devAddr:%{public}d", busNum, devAddr);
915 const UsbDev uDev = {busNum, devAddr};
916 std::vector<uint8_t> descriptor;
917
918 if (usbd_ == nullptr) {
919 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
920 return UEC_SERVICE_INVALID_VALUE;
921 }
922 int32_t ret = usbd_->OpenDevice(uDev);
923 if (ret != UEC_OK) {
924 USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret=%{public}d", ret);
925 return ret;
926 }
927
928 ret = GetDeviceInfoDescriptor(uDev, descriptor, dev);
929 if (ret != UEC_OK) {
930 USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfoDescriptor ret=%{public}d", ret);
931 }
932 ret = GetConfigDescriptor(dev, descriptor);
933 if (ret != UEC_OK) {
934 USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor ret=%{public}d", ret);
935 return ret;
936 }
937
938 usbd_->CloseDevice(uDev);
939 USB_HILOGI(MODULE_USB_SERVICE, "CloseDevice=%{public}s", dev.ToString().c_str());
940
941 return UEC_OK;
942 }
943
GetEdmGlobalPolicy(sptr<IRemoteObject> remote,bool & IsGlobalDisabled)944 int32_t UsbService::GetEdmGlobalPolicy(sptr<IRemoteObject> remote, bool &IsGlobalDisabled)
945 {
946 MessageParcel data;
947 MessageParcel reply;
948 MessageOption option;
949 data.WriteInterfaceToken(DESCRIPTOR);
950 data.WriteInt32(WITHOUT_USERID);
951 data.WriteInt32(WITHOUT_ADMIN);
952
953 uint32_t funcCode = (1 << EMD_MASK_CODE) | DISABLE_USB;
954 int32_t ErrCode = remote->SendRequest(funcCode, data, reply, option);
955 int32_t ret = ERR_INVALID_VALUE;
956 bool isSuccess = reply.ReadInt32(ret) && (ret == UEC_OK);
957 if (!isSuccess) {
958 USB_HILOGE(MODULE_USB_SERVICE, "GetGlobalPolicy failed. ErrCode = %{public}d, ret = %{public}d",
959 ErrCode, ret);
960 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
961 }
962
963 reply.ReadBool(IsGlobalDisabled);
964 return UEC_OK;
965 }
966
GetEdmTypePolicy(sptr<IRemoteObject> remote,std::unordered_map<InterfaceType,bool> & typeDisableMap)967 int32_t UsbService::GetEdmTypePolicy(sptr<IRemoteObject> remote,
968 std::unordered_map<InterfaceType, bool> &typeDisableMap)
969 {
970 int32_t StorageDisableType = 0;
971 bool IsStorageDisabled = false;
972 MessageParcel data;
973 MessageParcel reply;
974 MessageOption option;
975 data.WriteInterfaceToken(DESCRIPTOR);
976 data.WriteInt32(WITHOUT_USERID);
977 data.WriteInt32(WITHOUT_ADMIN);
978
979 uint32_t funcCode = (1 << EMD_MASK_CODE) | USB_STORAGE_DEVICE_ACCESS_POLICY;
980 int32_t ErrCode = remote->SendRequest(funcCode, data, reply, option);
981 int32_t ret = ERR_INVALID_VALUE;
982 bool isSuccess = reply.ReadInt32(ret) && (ret == ERR_OK);
983 if (!isSuccess) {
984 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmTypePolicy failed. ErrCode = %{public}d, ret = %{public}d",
985 ErrCode, ret);
986 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
987 }
988
989 reply.ReadInt32(StorageDisableType);
990 if (StorageDisableType == GET_EDM_STORAGE_DISABLE_TYPE) {
991 IsStorageDisabled = true;
992 }
993 typeDisableMap[InterfaceType::TYPE_STORAGE] = IsStorageDisabled;
994 return UEC_OK;
995 }
996
GetEdmWhiteListPolicy(sptr<IRemoteObject> remote,std::vector<UsbDeviceId> & trustUsbDeviceIds)997 int32_t UsbService::GetEdmWhiteListPolicy(sptr<IRemoteObject> remote, std::vector<UsbDeviceId> &trustUsbDeviceIds)
998 {
999 MessageParcel data;
1000 MessageParcel reply;
1001 MessageOption option;
1002 data.WriteInterfaceToken(DESCRIPTOR);
1003 data.WriteInt32(WITHOUT_USERID);
1004 data.WriteInt32(WITHOUT_ADMIN);
1005
1006 uint32_t funcCode = (1 << EMD_MASK_CODE) | ALLOWED_USB_DEVICES;
1007 int32_t ErrCode = remote->SendRequest(funcCode, data, reply, option);
1008 int32_t ret = ERR_INVALID_VALUE;
1009 bool IsSuccess = reply.ReadInt32(ret) && (ret == ERR_OK);
1010 if (!IsSuccess) {
1011 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy failed. ErrCode = %{public}d, ret = %{public}d",
1012 ErrCode, ret);
1013 return UEC_SERVICE_EDM_SEND_REQUEST_FAILED;
1014 }
1015
1016 int32_t size = reply.ReadInt32();
1017 if (size > WHITELIST_POLICY_MAX_DEVICES) {
1018 USB_HILOGE(MODULE_USB_SERVICE, "EdmWhiteList size=[%{public}d] is too large", size);
1019 return UEC_SERVICE_EDM_DEVICE_SIZE_EXCEED;
1020 }
1021 USB_HILOGI(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy return size:%{public}d", size);
1022 for (int32_t i = 0; i < size; i++) {
1023 UsbDeviceId usbDeviceId;
1024 usbDeviceId.vendorId = reply.ReadInt32();
1025 usbDeviceId.productId = reply.ReadInt32();
1026 trustUsbDeviceIds.emplace_back(usbDeviceId);
1027 }
1028 return UEC_OK;
1029 }
1030
GetEdmPolicy(bool & IsGlobalDisabled,std::unordered_map<InterfaceType,bool> & typeDisableMap,std::vector<UsbDeviceId> & trustUsbDeviceIds)1031 int32_t UsbService::GetEdmPolicy(bool &IsGlobalDisabled, std::unordered_map<InterfaceType, bool> &typeDisableMap,
1032 std::vector<UsbDeviceId> &trustUsbDeviceIds)
1033 {
1034 sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1035 if (sm == nullptr) {
1036 USB_HILOGE(MODULE_USB_SERVICE, "fail to get SystemAbilityManager");
1037 return UEC_SERVICE_GET_SYSTEM_ABILITY_MANAGER_FAILED;
1038 }
1039 sptr<IRemoteObject> remote = sm->CheckSystemAbility(EDM_SYSTEM_ABILITY_ID);
1040 if (remote == nullptr) {
1041 USB_HILOGE(MODULE_USB_SERVICE, "Get Edm SystemAbility failed.");
1042 return UEC_SERVICE_GET_EDM_SERVICE_FAILED;
1043 }
1044
1045 int32_t ret = GetEdmGlobalPolicy(remote, IsGlobalDisabled);
1046 if (ret != UEC_OK) {
1047 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmGlobalPolicy failed.");
1048 return ret;
1049 }
1050 ret = GetEdmTypePolicy(remote, typeDisableMap);
1051 if (ret != UEC_OK) {
1052 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmTypePolicy failed.");
1053 return ret;
1054 }
1055 ret = GetEdmWhiteListPolicy(remote, trustUsbDeviceIds);
1056 if (ret != UEC_OK) {
1057 USB_HILOGE(MODULE_USB_SERVICE, "GetEdmWhiteListPolicy failed.");
1058 return ret;
1059 }
1060 return UEC_OK;
1061 }
1062
GetUsbPolicy(bool & IsGlobalDisabled,std::unordered_map<InterfaceType,bool> & typeDisableMap,std::vector<UsbDeviceId> & trustUsbDeviceIds)1063 int32_t UsbService::GetUsbPolicy(bool &IsGlobalDisabled, std::unordered_map<InterfaceType, bool> &typeDisableMap,
1064 std::vector<UsbDeviceId> &trustUsbDeviceIds)
1065 {
1066 auto startTime = std::chrono::steady_clock::now();
1067 while (true) {
1068 int32_t ret = GetEdmPolicy(IsGlobalDisabled, typeDisableMap, trustUsbDeviceIds);
1069 if (ret == UEC_OK) {
1070 USB_HILOGI(MODULE_USB_SERVICE, "GetUsbPolicy succeed");
1071 break;
1072 } else if (ret == EDM_SA_TIME_OUT_CODE) {
1073 auto currentTime = std::chrono::steady_clock::now();
1074 auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - startTime).count();
1075 if (elapsedTime >= EDM_SA_MAX_TIME_OUT) {
1076 USB_HILOGE(MODULE_USB_SERVICE, "Time out, exit loop");
1077 return UEC_SERVICE_EDM_SA_TIME_OUT_FAILED;
1078 }
1079 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1080 } else {
1081 USB_HILOGE(MODULE_USB_SERVICE, "EDM sa failed");
1082 return UEC_SERVICE_PREPARE_EDM_SA_FAILED;
1083 }
1084 }
1085 return UEC_OK;
1086 }
1087
ExecuteManageDevicePolicy(std::vector<UsbDeviceId> & whiteList)1088 int32_t UsbService::ExecuteManageDevicePolicy(std::vector<UsbDeviceId> &whiteList)
1089 {
1090 std::map<std::string, UsbDevice *> devices;
1091 usbHostManager_->GetDevices(devices);
1092 int32_t ret;
1093 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
1094 for (auto it = devices.begin(); it != devices.end(); ++it) {
1095 for (auto dev : whiteList) {
1096 if (it->second->GetProductId() == dev.productId && it->second->GetVendorId() == dev.vendorId) {
1097 ret = ManageDeviceImpl(it->second->GetVendorId(), it->second->GetProductId(), false);
1098 } else {
1099 ret = ManageDeviceImpl(it->second->GetVendorId(), it->second->GetProductId(), true);
1100 }
1101 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1102 }
1103 }
1104 if (ret != UEC_OK) {
1105 USB_HILOGI(MODULE_USB_SERVICE, "ManageDevice failed");
1106 return UEC_SERVICE_EXECUTE_POLICY_FAILED;
1107 }
1108 return UEC_OK;
1109 }
1110
IsEdmEnabled()1111 bool UsbService::IsEdmEnabled()
1112 {
1113 std::string edmParaValue = OHOS::system::GetParameter("persist.edm.edm_enable", "false");
1114 USB_HILOGI(MODULE_USB_SERVICE, "edmParaValue is %{public}s", edmParaValue.c_str());
1115 return edmParaValue == "true";
1116 }
1117
ExecuteStrategy(UsbDevice * devInfo)1118 void UsbService::ExecuteStrategy(UsbDevice *devInfo)
1119 {
1120 USB_HILOGI(MODULE_USB_SERVICE, "start");
1121 if (!IsEdmEnabled()) {
1122 USB_HILOGE(MODULE_USB_SERVICE, "edm is not activate, skip");
1123 return;
1124 }
1125 bool isGlobalDisabled = false;
1126 std::unordered_map<InterfaceType, bool> typeDisableMap{};
1127 std::vector<UsbDeviceId> trustUsbDeviceIds{};
1128
1129 int32_t ret = GetUsbPolicy(isGlobalDisabled, typeDisableMap, trustUsbDeviceIds);
1130 if (ret == UEC_SERVICE_EDM_SA_TIME_OUT_FAILED || ret == UEC_SERVICE_PREPARE_EDM_SA_FAILED) {
1131 USB_HILOGE(MODULE_USB_SERVICE, "EDM sa time out or prepare failed, ret = %{public}d", ret);
1132 return;
1133 }
1134
1135 if (isGlobalDisabled) {
1136 ret = ManageGlobalInterfaceImpl(isGlobalDisabled);
1137 if (ret != UEC_OK) {
1138 USB_HILOGE(MODULE_USB_SERVICE, "ManageGlobalInterface failed");
1139 }
1140 return;
1141 }
1142 bool flag = false;
1143 for (auto result : typeDisableMap) {
1144 flag |= result.second;
1145 if (result.second) {
1146 ret = ManageInterfaceTypeImpl(result.first, true);
1147 }
1148 if (ret != UEC_OK) {
1149 USB_HILOGE(MODULE_USB_SERVICE, "ManageInterfaceType failed, type is %{public}d", (int32_t)result.first);
1150 }
1151 }
1152 if (flag) {
1153 USB_HILOGI(MODULE_USB_SERVICE, "Execute ManageInterfaceType finish");
1154 return;
1155 }
1156 if (trustUsbDeviceIds.empty()) {
1157 USB_HILOGI(MODULE_USB_SERVICE, "trustUsbDeviceIds is empty, no devices disable");
1158 return;
1159 }
1160 ret = ExecuteManageDevicePolicy(trustUsbDeviceIds);
1161 if (ret != UEC_OK) {
1162 USB_HILOGE(MODULE_USB_SERVICE, "ExecuteManageDevicePolicy failed");
1163 }
1164 return;
1165 }
1166
AddDevice(uint8_t busNum,uint8_t devAddr)1167 bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
1168 {
1169 UsbDevice *devInfo = new (std::nothrow) UsbDevice();
1170 if (devInfo == nullptr) {
1171 USB_HILOGE(MODULE_USB_SERVICE, "new failed");
1172 return false;
1173 }
1174
1175 errno_t retSafe = memset_s(devInfo, sizeof(UsbDevice), 0, sizeof(UsbDevice));
1176 if (retSafe != EOK) {
1177 USB_HILOGI(MODULE_USB_SERVICE, "memset_s failed");
1178 return false;
1179 }
1180
1181 int32_t ret = GetDeviceInfo(busNum, devAddr, *devInfo);
1182 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceInfo ret=%{public}d", ret);
1183 if (ret != UEC_OK) {
1184 delete devInfo;
1185 return false;
1186 }
1187
1188 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
1189 std::string uniqueName = std::to_string(devInfo->GetVendorId()) + "-" + std::to_string(devInfo->GetProductId()) +
1190 "-" + devInfo->GetmSerial();
1191 USB_HILOGI(MODULE_USB_SERVICE, "map+: %{public}s", name.c_str());
1192 {
1193 std::lock_guard<std::mutex> guard(mutex_);
1194 deviceVidPidMap_.insert(std::pair<std::string, std::string>(name, uniqueName));
1195 }
1196
1197 if (usbHostManager_ == nullptr) {
1198 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_");
1199 return false;
1200 }
1201
1202 usbHostManager_->AddDevice(devInfo);
1203 ExecuteStrategy(devInfo);
1204 return true;
1205 }
1206
DelDevice(uint8_t busNum,uint8_t devAddr)1207 bool UsbService::DelDevice(uint8_t busNum, uint8_t devAddr)
1208 {
1209 USB_HILOGI(MODULE_USBD, "entry");
1210 int32_t ret = Close(busNum, devAddr);
1211 if (ret != UEC_OK) {
1212 USB_HILOGE(MODULE_USBD, "Close device failed width ret = %{public}d", ret);
1213 }
1214
1215 if (usbHostManager_ == nullptr || usbRightManager_ == nullptr) {
1216 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_ or usbRightManager_");
1217 return false;
1218 }
1219
1220 std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
1221 if (!usbRightManager_->RemoveDeviceAllRight(GetDeviceVidPidSerialNumber(name))) {
1222 USB_HILOGW(MODULE_USB_SERVICE, "remove right failed: %{public}s", name.c_str());
1223 }
1224
1225 {
1226 std::lock_guard<std::mutex> guard(mutex_);
1227 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
1228 if (it->first == name) {
1229 deviceVidPidMap_.erase(it);
1230 break;
1231 }
1232 }
1233 }
1234
1235 return usbHostManager_->DelDevice(busNum, devAddr);
1236 }
1237
InitUsbRight()1238 int32_t UsbService::InitUsbRight()
1239 {
1240 int32_t ret = usbRightManager_->Init();
1241 if (ret != UEC_OK) {
1242 USB_HILOGE(MODULE_USBD, "Init usb right manager failed: %{public}d", ret);
1243 return ret;
1244 }
1245 std::vector<std::string> devices;
1246 for (auto it = deviceVidPidMap_.begin(); it != deviceVidPidMap_.end(); ++it) {
1247 devices.push_back(it->second);
1248 }
1249 USB_HILOGI(MODULE_USBD, "clean: %{public}zu/%{public}zu", devices.size(), deviceVidPidMap_.size());
1250 ret = usbRightManager_->CleanUpRightExpired(devices);
1251 if (ret != USB_RIGHT_OK) {
1252 USB_HILOGE(MODULE_USBD, "clean expired usb right failed: %{public}d", ret);
1253 }
1254 return ret;
1255 }
1256
UpdateUsbPort(int32_t portId,int32_t powerRole,int32_t dataRole,int32_t mode)1257 void UsbService::UpdateUsbPort(int32_t portId, int32_t powerRole, int32_t dataRole, int32_t mode)
1258 {
1259 if (usbPortManager_ == nullptr) {
1260 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbPortManager_");
1261 return;
1262 }
1263
1264 usbPortManager_->UpdatePort(portId, powerRole, dataRole, mode);
1265 }
1266
UpdateDeviceState(int32_t status)1267 void UsbService::UpdateDeviceState(int32_t status)
1268 {
1269 if (usbDeviceManager_ == nullptr) {
1270 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbDeviceManager_");
1271 return;
1272 }
1273
1274 usbDeviceManager_->HandleEvent(status);
1275 }
1276
GetBundleName(std::string & bundleName)1277 bool UsbService::GetBundleName(std::string &bundleName)
1278 {
1279 #ifdef USB_RIGHT_TEST
1280 bundleName = "com.usb.right";
1281 return true;
1282 #endif
1283 pid_t uid = GetCallingUid();
1284 sptr<ISystemAbilityManager> systemAbilityManager =
1285 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1286 if (systemAbilityManager == nullptr) {
1287 return false;
1288 }
1289 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
1290 if (remoteObject == nullptr) {
1291 return false;
1292 }
1293
1294 sptr<AppExecFwk::IBundleMgr> bundleMgr(new AppExecFwk::BundleMgrProxy(remoteObject));
1295 if (bundleMgr == nullptr) {
1296 return false;
1297 }
1298
1299 ErrCode ret = bundleMgr->GetNameForUid(uid, bundleName);
1300 if (ret != ERR_OK) {
1301 USB_HILOGE(MODULE_USB_SERVICE, "failed to obtain bundleName");
1302 return false;
1303 }
1304 return true;
1305 }
1306
RegBulkCallback(const UsbDev & devInfo,const UsbPipe & pipe,const sptr<IRemoteObject> & cb)1307 int32_t UsbService::RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const sptr<IRemoteObject> &cb)
1308 {
1309 if (cb == nullptr) {
1310 USB_HILOGE(MODULE_USB_SERVICE, "cb is nullptr");
1311 return UEC_SERVICE_INVALID_VALUE;
1312 }
1313 if (hdiCb_ == nullptr) {
1314 hdiCb_ = new UsbdBulkCallbackImpl(cb);
1315 }
1316 if (usbd_ == nullptr) {
1317 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
1318 return UEC_SERVICE_INVALID_VALUE;
1319 }
1320
1321 int32_t ret = usbd_->RegBulkCallback(devInfo, pipe, hdiCb_);
1322 if (ret != UEC_OK) {
1323 USB_HILOGE(MODULE_USB_SERVICE, "RegBulkCallback error ret:%{public}d", ret);
1324 }
1325 return ret;
1326 }
1327
UnRegBulkCallback(const UsbDev & devInfo,const UsbPipe & pipe)1328 int32_t UsbService::UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
1329 {
1330 if (usbd_ == nullptr) {
1331 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
1332 return UEC_SERVICE_INVALID_VALUE;
1333 }
1334
1335 hdiCb_ = nullptr;
1336 int32_t ret = usbd_->UnRegBulkCallback(devInfo, pipe);
1337 if (ret != UEC_OK) {
1338 USB_HILOGE(MODULE_USB_SERVICE, "UnRegBulkCallback error ret:%{public}d", ret);
1339 }
1340 return ret;
1341 }
1342
BulkRead(const UsbDev & devInfo,const UsbPipe & pipe,sptr<Ashmem> & ashmem)1343 int32_t UsbService::BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
1344 {
1345 if (ashmem == nullptr) {
1346 USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ashmem");
1347 return UEC_SERVICE_INVALID_VALUE;
1348 }
1349
1350 if (usbd_ == nullptr) {
1351 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
1352 return UEC_SERVICE_INVALID_VALUE;
1353 }
1354 int32_t ret = usbd_->BulkRead(devInfo, pipe, ashmem);
1355 if (ret != UEC_OK) {
1356 USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ret:%{public}d", ret);
1357 }
1358 return ret;
1359 }
1360
BulkWrite(const UsbDev & devInfo,const UsbPipe & pipe,sptr<Ashmem> & ashmem)1361 int32_t UsbService::BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
1362 {
1363 if (ashmem == nullptr) {
1364 USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ashmem");
1365 return UEC_SERVICE_INVALID_VALUE;
1366 }
1367
1368 if (usbd_ == nullptr) {
1369 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
1370 return UEC_SERVICE_INVALID_VALUE;
1371 }
1372 int32_t ret = usbd_->BulkWrite(devInfo, pipe, ashmem);
1373 if (ret != UEC_OK) {
1374 USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ret:%{public}d", ret);
1375 }
1376 return ret;
1377 }
1378
BulkCancel(const UsbDev & devInfo,const UsbPipe & pipe)1379 int32_t UsbService::BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
1380 {
1381 if (usbd_ == nullptr) {
1382 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::usbd_ is nullptr");
1383 return UEC_SERVICE_INVALID_VALUE;
1384 }
1385 int32_t ret = usbd_->BulkCancel(devInfo, pipe);
1386 if (ret != UEC_OK) {
1387 USB_HILOGE(MODULE_USB_SERVICE, "BulkCancel error ret:%{public}d", ret);
1388 }
1389 return ret;
1390 }
1391
AddRight(const std::string & bundleName,const std::string & deviceName)1392 int32_t UsbService::AddRight(const std::string &bundleName, const std::string &deviceName)
1393 {
1394 USB_HILOGI(MODULE_USB_SERVICE, "calling AddRight");
1395 if (usbRightManager_ == nullptr) {
1396 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1397 return UEC_SERVICE_INVALID_VALUE;
1398 }
1399 std::string deviceVidPidSerialNum = "";
1400 int32_t ret = GetDeviceVidPidSerialNumber(deviceName, deviceVidPidSerialNum);
1401 if (ret != UEC_OK) {
1402 USB_HILOGE(MODULE_USB_SERVICE, "can not find deviceName.");
1403 return ret;
1404 }
1405 if (!(usbRightManager_->IsSystemHap())) {
1406 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
1407 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
1408 }
1409 USB_HILOGI(MODULE_USB_SERVICE, "AddRight bundleName = %{public}s, deviceName = %{public}s", bundleName.c_str(),
1410 deviceName.c_str());
1411 if (!usbRightManager_->AddDeviceRight(deviceVidPidSerialNum, bundleName)) {
1412 USB_HILOGE(MODULE_USB_SERVICE, "AddDeviceRight failed");
1413 return UEC_SERVICE_INNER_ERR;
1414 }
1415 USB_HILOGI(MODULE_USB_SERVICE, "AddRight done");
1416 return UEC_OK;
1417 }
1418
Dump(int fd,const std::vector<std::u16string> & args)1419 int UsbService::Dump(int fd, const std::vector<std::u16string> &args)
1420 {
1421 if (fd < 0) {
1422 USB_HILOGE(MODULE_USB_SERVICE, "fd is invalid fd:%{public}d", fd);
1423 return UEC_SERVICE_INVALID_VALUE;
1424 }
1425
1426 std::vector<std::string> argList;
1427 std::transform(args.begin(), args.end(), std::back_inserter(argList), [](const std::u16string &arg) {
1428 return Str16ToStr8(arg);
1429 });
1430
1431 if (argList.empty()) {
1432 USB_HILOGE(MODULE_USB_SERVICE, "argList is empty");
1433 DumpHelp(fd);
1434 return UEC_SERVICE_INVALID_VALUE;
1435 }
1436
1437 if (argList[0] == USB_HOST) {
1438 usbHostManager_->Dump(fd, argList[1]);
1439 } else if (argList[0] == USB_DEVICE) {
1440 usbDeviceManager_->Dump(fd, argList);
1441 } else if (argList[0] == USB_PORT) {
1442 usbPortManager_->Dump(fd, argList);
1443 } else if (argList[0] == USB_HELP) {
1444 DumpHelp(fd);
1445 } else {
1446 dprintf(fd, "Usb Dump service:invalid parameter.\n");
1447 DumpHelp(fd);
1448 }
1449 return UEC_OK;
1450 }
1451
DumpHelp(int32_t fd)1452 void UsbService::DumpHelp(int32_t fd)
1453 {
1454 dprintf(fd, "Refer to the following usage:\n");
1455 dprintf(fd, "-h: dump help\n");
1456 dprintf(fd, "============= dump the all device ==============\n");
1457 dprintf(fd, "usb_host -a: dump the all device list info\n");
1458 dprintf(fd, "------------------------------------------------\n");
1459 usbDeviceManager_->GetDumpHelp(fd);
1460 usbPortManager_->GetDumpHelp(fd);
1461 }
1462
UnLoadSelf(UnLoadSaType type)1463 void UsbService::UnLoadSelf(UnLoadSaType type)
1464 {
1465 auto task = []() {
1466 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1467 if (samgrProxy == nullptr) {
1468 USB_HILOGE(MODULE_USB_SERVICE, "get samgr failed");
1469 return;
1470 }
1471
1472 auto ret = samgrProxy->UnloadSystemAbility(USB_SYSTEM_ABILITY_ID);
1473 if (ret != UEC_OK) {
1474 USB_HILOGE(MODULE_USB_SERVICE, "unload failed");
1475 }
1476 };
1477
1478 if (type == UNLOAD_SA_IMMEDIATELY) {
1479 task();
1480 return;
1481 }
1482
1483 if (usbHostManager_ == nullptr || usbDeviceManager_ == nullptr) {
1484 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_ or usbDeviceManager_");
1485 return;
1486 }
1487
1488 unloadSelfTimer_.Unregister(unloadSelfTimerId_);
1489 unloadSelfTimer_.Shutdown();
1490
1491 std::map<std::string, UsbDevice *> devices;
1492 usbHostManager_->GetDevices(devices);
1493 if (devices.size() != 0 || usbDeviceManager_->IsGadgetConnected()) { // delay unload conditions
1494 USB_HILOGW(MODULE_USB_SERVICE, "not need unload");
1495 return;
1496 }
1497
1498 if (auto ret = unloadSelfTimer_.Setup(); ret != Utils::TIMER_ERR_OK) {
1499 USB_HILOGE(MODULE_USB_SERVICE, "set up timer failed %{public}u", ret);
1500 return;
1501 }
1502 unloadSelfTimerId_ = unloadSelfTimer_.Register(task, UNLOAD_SA_TIMER_INTERVAL, true);
1503 }
1504
OnRemoteDied(const wptr<IRemoteObject> & object)1505 void UsbService::UsbdDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
1506 {
1507 auto pms = DelayedSpSingleton<UsbService>::GetInstance();
1508 if (pms == nullptr) {
1509 USB_HILOGE(MODULE_USB_SERVICE, "failed to GetInstance");
1510 return;
1511 }
1512 pms->UnLoadSelf(UNLOAD_SA_IMMEDIATELY);
1513 }
1514
PreManageInterface()1515 int32_t UsbService::PreManageInterface()
1516 {
1517 usbd_ = IUsbInterface::Get();
1518 if (usbRightManager_ == nullptr) {
1519 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbRightManager_");
1520 return UEC_SERVICE_INVALID_VALUE;
1521 }
1522 if (!(usbRightManager_->IsSystemHap())) {
1523 USB_HILOGW(MODULE_USB_SERVICE, "is not system app");
1524 return UEC_SERVICE_PERMISSION_DENIED_SYSAPI;
1525 }
1526
1527 if (usbHostManager_ == nullptr) {
1528 USB_HILOGE(MODULE_USB_SERVICE, "invalid usbHostManager_");
1529 return UEC_SERVICE_INVALID_VALUE;
1530 }
1531
1532 if (usbd_ == nullptr) {
1533 USB_HILOGE(MODULE_USB_SERVICE, "usbd_ is nullptr");
1534 return UEC_SERVICE_INVALID_VALUE;
1535 }
1536 return UEC_OK;
1537 }
1538
ManageGlobalInterface(bool disable)1539 int32_t UsbService::ManageGlobalInterface(bool disable)
1540 {
1541 if (PreManageInterface() != UEC_OK) {
1542 USB_HILOGE(MODULE_USB_SERVICE, "PreManageInterface failed");
1543 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
1544 }
1545
1546 return ManageGlobalInterfaceImpl(disable);
1547 }
1548
ManageDevice(int32_t vendorId,int32_t productId,bool disable)1549 int32_t UsbService::ManageDevice(int32_t vendorId, int32_t productId, bool disable)
1550 {
1551 if (PreManageInterface() != UEC_OK) {
1552 USB_HILOGE(MODULE_USB_SERVICE, "PreManageInterface failed");
1553 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
1554 }
1555
1556 return ManageDeviceImpl(vendorId, productId, disable);
1557 }
1558
ManageInterfaceType(InterfaceType interfaceType,bool disable)1559 int32_t UsbService::ManageInterfaceType(InterfaceType interfaceType, bool disable)
1560 {
1561 if (PreManageInterface() != UEC_OK) {
1562 USB_HILOGE(MODULE_USB_SERVICE, "PreManageInterface failed");
1563 return UEC_SERVICE_PRE_MANAGE_INTERFACE_FAILED;
1564 }
1565 return ManageInterfaceTypeImpl(interfaceType, disable);
1566 }
1567
ManageGlobalInterfaceImpl(bool disable)1568 int32_t UsbService::ManageGlobalInterfaceImpl(bool disable)
1569 {
1570 std::map<std::string, UsbDevice *> devices;
1571 usbHostManager_->GetDevices(devices);
1572 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
1573 for (auto it = devices.begin(); it != devices.end(); ++it) {
1574 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1575 uint8_t configIndex = 0;
1576 if (usbd_->GetConfig(dev, configIndex)) {
1577 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1578 continue;
1579 }
1580 USBConfig configs;
1581 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1582 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1583 continue;
1584 }
1585
1586 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1587 for (uint32_t i = 0; i < interfaces.size(); i++) {
1588 ManageInterface(dev, interfaces[i].GetId(), disable);
1589 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1590 }
1591 }
1592 return UEC_OK;
1593 }
ManageDeviceImpl(int32_t vendorId,int32_t productId,bool disable)1594 int32_t UsbService::ManageDeviceImpl(int32_t vendorId, int32_t productId, bool disable)
1595 {
1596 std::map<std::string, UsbDevice *> devices;
1597 usbHostManager_->GetDevices(devices);
1598 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
1599 for (auto it = devices.begin(); it != devices.end(); ++it) {
1600 if (it->second->GetVendorId() == vendorId && it->second->GetProductId() == productId) {
1601 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1602 uint8_t configIndex = 0;
1603 if (usbd_->GetConfig(dev, configIndex)) {
1604 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1605 continue;
1606 }
1607 USBConfig configs;
1608 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1609 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1610 continue;
1611 }
1612 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1613 for (uint32_t i = 0; i < interfaces.size(); i++) {
1614 ManageInterface(dev, interfaces[i].GetId(), disable);
1615 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1616 }
1617 }
1618 }
1619 return UEC_OK;
1620 }
ManageInterfaceTypeImpl(InterfaceType interfaceType,bool disable)1621 int32_t UsbService::ManageInterfaceTypeImpl(InterfaceType interfaceType, bool disable)
1622 {
1623 auto iterInterface = typeMap.find(interfaceType);
1624 if (iterInterface == typeMap.end()) {
1625 USB_HILOGE(MODULE_USB_SERVICE, "UsbService::not find interface type");
1626 return UEC_SERVICE_INVALID_VALUE;
1627 }
1628
1629 std::map<std::string, UsbDevice *> devices;
1630 usbHostManager_->GetDevices(devices);
1631 USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
1632 for (auto it = devices.begin(); it != devices.end(); ++it) {
1633 UsbDev dev = {it->second->GetBusNum(), it->second->GetDevAddr()};
1634 uint8_t configIndex = 0;
1635 if (usbd_->GetConfig(dev, configIndex)) {
1636 USB_HILOGW(MODULE_USB_SERVICE, "get device active config failed.");
1637 continue;
1638 }
1639 USBConfig configs;
1640 if (it->second->GetConfig(static_cast<uint8_t>(configIndex) - 1, configs)) {
1641 USB_HILOGW(MODULE_USB_SERVICE, "get device config info failed.");
1642 continue;
1643 }
1644 std::vector<UsbInterface> interfaces = configs.GetInterfaces();
1645
1646 for (uint32_t i = 0; i < interfaces.size(); i++) {
1647 // 0 indicate base class, 1 indicate subclass, 2 indicate protocal. -1 indicate any value.
1648 if (interfaces[i].GetClass() == iterInterface->second[BASECLASS_INDEX] && (interfaces[i].GetClass() ==
1649 iterInterface->second[SUBCLASS_INDEX] || iterInterface->second[SUBCLASS_INDEX] ==
1650 RANDOM_VALUE_INDICATE) && (interfaces[i].GetProtocol() == iterInterface->second[PROTOCAL_INDEX] ||
1651 iterInterface->second[PROTOCAL_INDEX] == RANDOM_VALUE_INDICATE)) {
1652 ManageInterface(dev, interfaces[i].GetId(), disable);
1653 std::this_thread::sleep_for(std::chrono::milliseconds(MANAGE_INTERFACE_INTERVAL));
1654 }
1655 }
1656 }
1657 return UEC_OK;
1658 }
1659
ManageInterface(const HDI::Usb::V1_0::UsbDev & dev,uint8_t interfaceId,bool disable)1660 int32_t UsbService::ManageInterface(const HDI::Usb::V1_0::UsbDev &dev, uint8_t interfaceId, bool disable)
1661 {
1662 if (usbd_ == nullptr) {
1663 USB_HILOGE(MODULE_USB_SERVICE, "usbd_ is nullptr");
1664 return UEC_SERVICE_INVALID_VALUE;
1665 }
1666 return usbd_->ManageInterface(dev, interfaceId, disable);
1667 }
1668 } // namespace USB
1669 } // namespace OHOS
1670