1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "driver_ext_mgr_types.h"
16 #include <sstream>
17
18 #include "hilog_wrapper.h"
19
20 namespace OHOS {
21 namespace ExternalDeviceManager {
Marshalling(MessageParcel & parcel) const22 bool ErrMsg::Marshalling(MessageParcel &parcel) const
23 {
24 if (!parcel.WriteInt32(errCode)) {
25 EDM_LOGE(MODULE_DEV_MGR, "failed to write errCode");
26 return false;
27 }
28
29 if (!parcel.WriteString(msg)) {
30 EDM_LOGE(MODULE_DEV_MGR, "failed to write msg");
31 return false;
32 }
33 return true;
34 }
35
UnMarshalling(MessageParcel & parcel,ErrMsg & data)36 bool ErrMsg::UnMarshalling(MessageParcel &parcel, ErrMsg &data)
37 {
38 int32_t err = 0;
39 if (!parcel.ReadInt32(err)) {
40 EDM_LOGE(MODULE_DEV_MGR, "failed to read errCode");
41 return false;
42 }
43 data.errCode = static_cast<UsbErrCode>(err);
44
45 if (!parcel.ReadString(data.msg)) {
46 EDM_LOGE(MODULE_DEV_MGR, "failed to read msg");
47 return false;
48 }
49 return true;
50 }
51
Marshalling(MessageParcel & parcel) const52 bool DeviceData::Marshalling(MessageParcel &parcel) const
53 {
54 if (!parcel.WriteUint32(static_cast<uint32_t>(busType))) {
55 EDM_LOGE(MODULE_DEV_MGR, "failed to write busType");
56 return false;
57 }
58
59 if (!parcel.WriteUint64(deviceId)) {
60 EDM_LOGE(MODULE_DEV_MGR, "failed to write deviceId");
61 return false;
62 }
63
64 if (!parcel.WriteString(descripton)) {
65 EDM_LOGE(MODULE_DEV_MGR, "failed to write descripton");
66 return false;
67 }
68
69 return true;
70 }
71
Marshalling(MessageParcel & parcel) const72 bool USBDevice::Marshalling(MessageParcel &parcel) const
73 {
74 if (!DeviceData::Marshalling(parcel)) {
75 return false;
76 }
77
78 if (!parcel.WriteUint16(productId)) {
79 EDM_LOGE(MODULE_DEV_MGR, "failed to write productId");
80 return false;
81 }
82
83 if (!parcel.WriteUint16(vendorId)) {
84 EDM_LOGE(MODULE_DEV_MGR, "failed to write vendorId");
85 return false;
86 }
87
88 return true;
89 }
90
UnMarshalling(MessageParcel & parcel)91 std::shared_ptr<DeviceData> DeviceData::UnMarshalling(MessageParcel &parcel)
92 {
93 uint32_t busTypeData = 0;
94 if (!parcel.ReadUint32(busTypeData)) {
95 EDM_LOGE(MODULE_DEV_MGR, "failed to read busType");
96 return nullptr;
97 }
98
99 BusType busType = static_cast<BusType>(busTypeData);
100 if (busType == BusType::BUS_TYPE_INVALID) {
101 EDM_LOGE(MODULE_DEV_MGR, "invalid busType:%{public}u", busTypeData);
102 return nullptr;
103 }
104
105 // if you need to extend the DeviceData type, please add code to read it here
106 std::shared_ptr<DeviceData> device;
107 switch (busType) {
108 case BusType::BUS_TYPE_USB: {
109 device = USBDevice::UnMarshalling(parcel);
110 break;
111 }
112 default:
113 break;
114 }
115
116 if (device != nullptr) {
117 device->busType = busType;
118 }
119 return device;
120 }
121
Dump()122 std::string DeviceData::Dump()
123 {
124 std::stringstream os;
125 os << "{busType:" << busType << ", ";
126 os << "deviceId:" << deviceId << ", ";
127 os << "descripton:" << descripton << "}";
128 return os.str();
129 }
130
UnMarshalling(MessageParcel & parcel)131 std::shared_ptr<DeviceData> USBDevice::UnMarshalling(MessageParcel &parcel)
132 {
133 // the busType has been read
134 std::shared_ptr<USBDevice> device = std::make_shared<USBDevice>();
135 if (!parcel.ReadUint64(device->deviceId)) {
136 EDM_LOGE(MODULE_DEV_MGR, "failed to read deviceId");
137 return nullptr;
138 }
139
140 if (!parcel.ReadString(device->descripton)) {
141 EDM_LOGE(MODULE_DEV_MGR, "failed to read descripton");
142 return nullptr;
143 }
144
145 if (!parcel.ReadUint16(device->productId)) {
146 EDM_LOGE(MODULE_DEV_MGR, "failed to read productId");
147 return nullptr;
148 }
149
150 if (!parcel.ReadUint16(device->vendorId)) {
151 EDM_LOGE(MODULE_DEV_MGR, "failed to read vendorId");
152 return nullptr;
153 }
154
155 return device;
156 }
157
Dump()158 std::string USBDevice::Dump()
159 {
160 std::stringstream os;
161 os << "{busType:" << busType << ", ";
162 os << "deviceId:" << deviceId << ", ";
163 os << "descripton:" << descripton << ", ";
164 os << "productId:" << productId << ", ";
165 os << "vendorId:" << vendorId << "}";
166 return os.str();
167 }
168
Marshalling(MessageParcel & parcel) const169 bool DeviceInfoData::Marshalling(MessageParcel &parcel) const
170 {
171 EDM_LOGD(MODULE_DEV_MGR, "DeviceInfoData Marshalling enter");
172 if (!parcel.WriteUint64(deviceId)) {
173 EDM_LOGE(MODULE_DEV_MGR, "failed to write deviceId");
174 return false;
175 }
176
177 if (!parcel.WriteBool(isDriverMatched)) {
178 EDM_LOGE(MODULE_DEV_MGR, "failed to write isDriverMatched");
179 return false;
180 }
181
182 if (!parcel.WriteString(driverUid)) {
183 EDM_LOGE(MODULE_DEV_MGR, "failed to write driverUid");
184 return false;
185 }
186 return true;
187 }
188
Marshalling(MessageParcel & parcel) const189 bool USBDeviceInfoData::Marshalling(MessageParcel &parcel) const
190 {
191 EDM_LOGD(MODULE_DEV_MGR, "USBDeviceInfoData Marshalling enter");
192 if (!DeviceInfoData::Marshalling(parcel)) {
193 return false;
194 }
195
196 if (!parcel.WriteUint16(productId)) {
197 EDM_LOGE(MODULE_DEV_MGR, "failed to write productId");
198 return false;
199 }
200
201 if (!parcel.WriteUint16(vendorId)) {
202 EDM_LOGE(MODULE_DEV_MGR, "failed to write vendorId");
203 return false;
204 }
205
206 EDM_LOGD(MODULE_DEV_MGR, "interfaceDescList size: %{public}zu", interfaceDescList.size());
207 if (!parcel.WriteUint64(static_cast<uint64_t>(interfaceDescList.size()))) {
208 EDM_LOGE(MODULE_DEV_MGR, "failed to write interfaceDescList size");
209 return false;
210 }
211
212 for (auto &desc : interfaceDescList) {
213 if (desc == nullptr) {
214 EDM_LOGE(MODULE_DEV_MGR, "invalid usb interface desc");
215 return false;
216 }
217
218 if (!desc->Marshalling(parcel)) {
219 return false;
220 }
221 }
222
223 return true;
224 }
225
Marshalling(MessageParcel & parcel) const226 bool USBInterfaceDesc::Marshalling(MessageParcel &parcel) const
227 {
228 EDM_LOGD(MODULE_DEV_MGR, "USBInterfaceDesc Marshalling enter");
229 if (!parcel.WriteUint8(bInterfaceNumber)) {
230 EDM_LOGE(MODULE_DEV_MGR, "failed to write bInterfaceNumber");
231 return false;
232 }
233
234 if (!parcel.WriteUint8(bClass)) {
235 EDM_LOGE(MODULE_DEV_MGR, "failed to write bClass");
236 return false;
237 }
238
239 if (!parcel.WriteUint8(bSubClass)) {
240 EDM_LOGE(MODULE_DEV_MGR, "failed to write bSubClass");
241 return false;
242 }
243
244 if (!parcel.WriteUint8(bProtocol)) {
245 EDM_LOGE(MODULE_DEV_MGR, "failed to write bProtocol");
246 return false;
247 }
248 return true;
249 }
250
UnMarshalling(MessageParcel & parcel)251 std::shared_ptr<DeviceInfoData> DeviceInfoData::UnMarshalling(MessageParcel &parcel)
252 {
253 uint64_t deviceId = 0;
254 if (!parcel.ReadUint64(deviceId)) {
255 EDM_LOGE(MODULE_DEV_MGR, "failed to read deviceId");
256 return nullptr;
257 }
258
259 BusType busType = DeviceInfoData::GetBusTypeByDeviceId(deviceId);
260 if (busType <= BusType::BUS_TYPE_INVALID || busType >= BusType::BUS_TYPE_MAX) {
261 EDM_LOGE(MODULE_DEV_MGR, "invalid busType:%{public}u", busType);
262 return nullptr;
263 }
264
265 bool isDriverMatched = false;
266 if (!parcel.ReadBool(isDriverMatched)) {
267 EDM_LOGE(MODULE_DEV_MGR, "failed to read isDriverMatched");
268 return nullptr;
269 }
270
271 std::string driverUid = "";
272 if (!parcel.ReadString(driverUid)) {
273 EDM_LOGE(MODULE_DEV_MGR, "failed to read driverUid");
274 return nullptr;
275 }
276 std::shared_ptr<DeviceInfoData> deviceInfo = nullptr;
277 switch (busType) {
278 case BusType::BUS_TYPE_USB: {
279 deviceInfo = USBDeviceInfoData::UnMarshalling(parcel);
280 break;
281 }
282 default:
283 break;
284 }
285 if (deviceInfo != nullptr) {
286 deviceInfo->deviceId = deviceId;
287 deviceInfo->isDriverMatched = isDriverMatched;
288 deviceInfo->driverUid = driverUid;
289 }
290 return deviceInfo;
291 }
292
DeviceInfosUnMarshalling(MessageParcel & parcel,std::vector<std::shared_ptr<DeviceInfoData>> & deviceInfos)293 bool DeviceInfoData::DeviceInfosUnMarshalling(MessageParcel &parcel,
294 std::vector<std::shared_ptr<DeviceInfoData>> &deviceInfos)
295 {
296 uint64_t deviceInfoSize = 0;
297 if (!parcel.ReadUint64(deviceInfoSize)) {
298 EDM_LOGE(MODULE_FRAMEWORK, "failed to read size of DeviceInfoData");
299 return false;
300 }
301
302 if (deviceInfoSize > deviceInfos.max_size()) {
303 EDM_LOGE(MODULE_FRAMEWORK, "invalid size of DeviceInfoData");
304 return false;
305 }
306
307 for (uint64_t i = 0; i < deviceInfoSize; i++) {
308 std::shared_ptr<DeviceInfoData> deviceInfo = DeviceInfoData::UnMarshalling(parcel);
309 if (deviceInfo == nullptr) {
310 EDM_LOGE(MODULE_FRAMEWORK, "failed to read deviceInfo");
311 return false;
312 }
313 deviceInfos.push_back(deviceInfo);
314 }
315 return true;
316 }
317
GetBusTypeByDeviceId(uint64_t deviceId)318 BusType DeviceInfoData::GetBusTypeByDeviceId(uint64_t deviceId)
319 {
320 return static_cast<BusType>(deviceId & 0x00000000FFFFFFF);
321 }
322
UnMarshalling(MessageParcel & parcel)323 std::shared_ptr<USBDeviceInfoData> USBDeviceInfoData::UnMarshalling(MessageParcel &parcel)
324 {
325 std::shared_ptr<USBDeviceInfoData> deviceInfo = std::make_shared<USBDeviceInfoData>();
326 if (!parcel.ReadUint16(deviceInfo->productId)) {
327 EDM_LOGE(MODULE_DEV_MGR, "failed to read productId");
328 return nullptr;
329 }
330 if (!parcel.ReadUint16(deviceInfo->vendorId)) {
331 EDM_LOGE(MODULE_DEV_MGR, "failed to read vendorId");
332 return nullptr;
333 }
334
335 uint64_t interfaceDescSize = 0;
336 if (!parcel.ReadUint64(interfaceDescSize)) {
337 EDM_LOGE(MODULE_DEV_MGR, "failed to read interfaceDescList size");
338 return nullptr;
339 }
340 for (uint64_t i = 0; i < interfaceDescSize; i++) {
341 std::shared_ptr<USBInterfaceDesc> desc = USBInterfaceDesc::UnMarshalling(parcel);
342 if (desc == nullptr) {
343 return nullptr;
344 }
345 deviceInfo->interfaceDescList.push_back(desc);
346 }
347
348 return deviceInfo;
349 }
350
UnMarshalling(MessageParcel & parcel)351 std::shared_ptr<USBInterfaceDesc> USBInterfaceDesc::UnMarshalling(MessageParcel &parcel)
352 {
353 std::shared_ptr<USBInterfaceDesc> desc = std::make_shared<USBInterfaceDesc>();
354
355 if (!parcel.ReadUint8(desc->bInterfaceNumber)) {
356 EDM_LOGE(MODULE_DEV_MGR, "failed to read bInterfaceNumber");
357 return nullptr;
358 }
359 if (!parcel.ReadUint8(desc->bClass)) {
360 EDM_LOGE(MODULE_DEV_MGR, "failed to read bClass");
361 return nullptr;
362 }
363 if (!parcel.ReadUint8(desc->bSubClass)) {
364 EDM_LOGE(MODULE_DEV_MGR, "failed to read bSubClass");
365 return nullptr;
366 }
367 if (!parcel.ReadUint8(desc->bProtocol)) {
368 EDM_LOGE(MODULE_DEV_MGR, "failed to read bProtocol");
369 return nullptr;
370 }
371 return desc;
372 }
373
Marshalling(MessageParcel & parcel) const374 bool DriverInfoData::Marshalling(MessageParcel &parcel) const
375 {
376 if (!parcel.WriteUint32(static_cast<uint32_t>(busType))) {
377 EDM_LOGE(MODULE_DEV_MGR, "failed to write busType");
378 return false;
379 }
380
381 if (!parcel.WriteString(driverUid)) {
382 EDM_LOGE(MODULE_DEV_MGR, "failed to write driverUid");
383 return false;
384 }
385
386 if (!parcel.WriteString(driverName)) {
387 EDM_LOGE(MODULE_DEV_MGR, "failed to write driverName");
388 return false;
389 }
390
391 if (!parcel.WriteString(bundleSize)) {
392 EDM_LOGE(MODULE_DEV_MGR, "failed to write bundleSize");
393 return false;
394 }
395
396 if (!parcel.WriteString(version)) {
397 EDM_LOGE(MODULE_DEV_MGR, "failed to write version");
398 return false;
399 }
400
401 if (!parcel.WriteString(description)) {
402 EDM_LOGE(MODULE_DEV_MGR, "failed to write description");
403 return false;
404 }
405
406 return true;
407 }
408
Marshalling(MessageParcel & parcel) const409 bool USBDriverInfoData::Marshalling(MessageParcel &parcel) const
410 {
411 if (!DriverInfoData::Marshalling(parcel)) {
412 return false;
413 }
414
415 if (!parcel.WriteUInt16Vector(pids)) {
416 EDM_LOGE(MODULE_DEV_MGR, "failed to write pids");
417 return false;
418 }
419
420 if (!parcel.WriteUInt16Vector(vids)) {
421 EDM_LOGE(MODULE_DEV_MGR, "failed to write vids");
422 return false;
423 }
424
425 return true;
426 }
427
ReadDriverInfoData(MessageParcel & parcel)428 static std::shared_ptr<DriverInfoData> ReadDriverInfoData(MessageParcel &parcel)
429 {
430 std::shared_ptr<DriverInfoData> driverInfo = std::make_shared<DriverInfoData>();
431
432 if (!parcel.ReadUint32(reinterpret_cast<uint32_t &>(driverInfo->busType))) {
433 EDM_LOGE(MODULE_DEV_MGR, "failed to read busType");
434 return nullptr;
435 }
436
437 if (driverInfo->busType <= BusType::BUS_TYPE_INVALID || driverInfo->busType >= BusType::BUS_TYPE_MAX) {
438 EDM_LOGE(MODULE_DEV_MGR, "invalid busType:%{public}u", driverInfo->busType);
439 return nullptr;
440 }
441
442 if (!parcel.ReadString(driverInfo->driverUid)) {
443 EDM_LOGE(MODULE_DEV_MGR, "failed to read driverUid");
444 return nullptr;
445 }
446
447 if (!parcel.ReadString(driverInfo->driverName)) {
448 EDM_LOGE(MODULE_DEV_MGR, "failed to read driverName");
449 return nullptr;
450 }
451
452 if (!parcel.ReadString(driverInfo->bundleSize)) {
453 EDM_LOGE(MODULE_DEV_MGR, "failed to read bundleSize");
454 return nullptr;
455 }
456
457 if (!parcel.ReadString(driverInfo->version)) {
458 EDM_LOGE(MODULE_DEV_MGR, "failed to read version");
459 return nullptr;
460 }
461
462 if (!parcel.ReadString(driverInfo->description)) {
463 EDM_LOGE(MODULE_DEV_MGR, "failed to read description");
464 return nullptr;
465 }
466 return driverInfo;
467 }
468
UnMarshalling(MessageParcel & parcel)469 std::shared_ptr<DriverInfoData> DriverInfoData::UnMarshalling(MessageParcel &parcel)
470 {
471 std::shared_ptr<DriverInfoData> baseDriverInfo = ReadDriverInfoData(parcel);
472 if (baseDriverInfo == nullptr) {
473 return nullptr;
474 }
475 std::shared_ptr<DriverInfoData> driverInfo = nullptr;
476 switch (baseDriverInfo->busType) {
477 case BusType::BUS_TYPE_USB: {
478 driverInfo = USBDriverInfoData::UnMarshalling(parcel);
479 break;
480 }
481 default:
482 break;
483 }
484 if (driverInfo != nullptr) {
485 driverInfo->busType = baseDriverInfo->busType;
486 driverInfo->driverUid = baseDriverInfo->driverUid;
487 driverInfo->driverName = baseDriverInfo->driverName;
488 driverInfo->bundleSize = baseDriverInfo->bundleSize;
489 driverInfo->version = baseDriverInfo->version;
490 driverInfo->description = baseDriverInfo->description;
491 }
492 return driverInfo;
493 }
494
DriverInfosUnMarshalling(MessageParcel & parcel,std::vector<std::shared_ptr<DriverInfoData>> & driverInfos)495 bool DriverInfoData::DriverInfosUnMarshalling(MessageParcel &parcel,
496 std::vector<std::shared_ptr<DriverInfoData>> &driverInfos)
497 {
498 uint64_t driverInfoSize = 0;
499 if (!parcel.ReadUint64(driverInfoSize)) {
500 EDM_LOGE(MODULE_FRAMEWORK, "failed to read size of DriverInfoData");
501 return false;
502 }
503
504 if (driverInfoSize > driverInfos.max_size()) {
505 EDM_LOGE(MODULE_FRAMEWORK, "invalid size of DriverInfoData");
506 return false;
507 }
508
509 for (uint64_t i = 0; i < driverInfoSize; i++) {
510 std::shared_ptr<DriverInfoData> driverInfo = DriverInfoData::UnMarshalling(parcel);
511 if (driverInfo == nullptr) {
512 EDM_LOGE(MODULE_FRAMEWORK, "failed to read driverInfo");
513 return false;
514 }
515 driverInfos.push_back(driverInfo);
516 }
517 return true;
518 }
519
UnMarshalling(MessageParcel & parcel)520 std::shared_ptr<USBDriverInfoData> USBDriverInfoData::UnMarshalling(MessageParcel &parcel)
521 {
522 std::shared_ptr<USBDriverInfoData> driverInfo = std::make_shared<USBDriverInfoData>();
523
524 if (!parcel.ReadUInt16Vector(&driverInfo->pids)) {
525 EDM_LOGE(MODULE_DEV_MGR, "failed to read pids");
526 return nullptr;
527 }
528
529 if (!parcel.ReadUInt16Vector(&driverInfo->vids)) {
530 EDM_LOGE(MODULE_DEV_MGR, "failed to read vids");
531 return nullptr;
532 }
533
534 return driverInfo;
535 }
536 } // namespace ExternalDeviceManager
537 } // namespace OHOS