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 "input_event_transmission/input_event_serialization.h"
17
18 #include "extra_data.h"
19 #ifdef OHOS_BUILD_ENABLE_SECURITY_PART
20 #include "sec_comp_enhance_kit.h"
21 #endif // OHOS_BUILD_ENABLE_SECURITY_PART
22
23 #include "devicestatus_define.h"
24 #include "input_event_transmission/inner_pointer_item.h"
25
26 #undef LOG_TAG
27 #define LOG_TAG "InputEventSerialization"
28
29 namespace OHOS {
30 namespace Msdp {
31 namespace DeviceStatus {
32 namespace Cooperate {
33 namespace {
34 constexpr int32_t MAX_KEY_SIZE { 395 };
35 const std::string HEART_BEAT_PACKET { "heart_beat_packet" };
36 } // namespace
37
KeyEventToNetPacket(const std::shared_ptr<MMI::KeyEvent> key,NetPacket & pkt)38 int32_t InputEventSerialization::KeyEventToNetPacket(
39 const std::shared_ptr<MMI::KeyEvent> key, NetPacket &pkt)
40 {
41 if (SerializeInputEvent(key, pkt) != RET_OK) {
42 FI_HILOGE("Serialize input event failed");
43 return RET_ERR;
44 }
45 pkt << key->GetKeyCode() << key->GetKeyAction() << key->GetKeyIntention();
46 auto keys = key->GetKeyItems();
47 int32_t size = static_cast<int32_t>(keys.size());
48 if (size > MAX_KEY_SIZE) {
49 FI_HILOGE("Key exceeds the max range");
50 return RET_ERR;
51 }
52 pkt << size;
53 for (const auto &item : keys) {
54 pkt << item.GetKeyCode() << item.GetDownTime()
55 << item.GetDeviceId() << item.IsPressed() << item.GetUnicode();
56 }
57 pkt << key->GetFunctionKey(MMI::KeyEvent::NUM_LOCK_FUNCTION_KEY)
58 << key->GetFunctionKey(MMI::KeyEvent::CAPS_LOCK_FUNCTION_KEY)
59 << key->GetFunctionKey(MMI::KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
60 if (pkt.ChkRWError()) {
61 FI_HILOGE("Packet write key event failed");
62 return RET_ERR;
63 }
64 return RET_OK;
65 }
66
NetPacketToKeyEvent(NetPacket & pkt,std::shared_ptr<MMI::KeyEvent> key)67 int32_t InputEventSerialization::NetPacketToKeyEvent(NetPacket &pkt, std::shared_ptr<MMI::KeyEvent> key)
68 {
69 if (DeserializeInputEvent(pkt, key) != RET_OK) {
70 FI_HILOGE("Deserialize input event failed");
71 return RET_ERR;
72 }
73 int32_t data = 0;
74 pkt >> data;
75 key->SetKeyCode(data);
76 pkt >> data;
77 key->SetKeyAction(data);
78 pkt >> data;
79 key->SetKeyIntention(data);
80 int32_t size = 0;
81 pkt >> size;
82 if (size > MAX_KEY_SIZE) {
83 FI_HILOGE("Key exceeds the max range");
84 return RET_ERR;
85 }
86 if (pkt.ChkRWError()) {
87 FI_HILOGE("Packet read size failed");
88 return RET_ERR;
89 }
90 bool isPressed = false;
91 for (int32_t i = 0; i < size; i++) {
92 MMI::KeyEvent::KeyItem keyItem;
93 pkt >> data;
94 keyItem.SetKeyCode(data);
95 int64_t datatime = 0;
96 pkt >> datatime;
97 keyItem.SetDownTime(datatime);
98 pkt >> data;
99 keyItem.SetDeviceId(data);
100 pkt >> isPressed;
101 if (pkt.ChkRWError()) {
102 FI_HILOGE("Packet read item isPressed failed");
103 return RET_ERR;
104 }
105 keyItem.SetPressed(isPressed);
106 uint32_t unicode;
107 pkt >> unicode;
108 keyItem.SetUnicode(unicode);
109 key->AddKeyItem(keyItem);
110 }
111 ReadFunctionKeys(pkt, key);
112 return RET_OK;
113 }
114
ReadFunctionKeys(NetPacket & pkt,std::shared_ptr<MMI::KeyEvent> key)115 void InputEventSerialization::ReadFunctionKeys(NetPacket &pkt, std::shared_ptr<MMI::KeyEvent> key)
116 {
117 CHKPV(key);
118 bool state = false;
119 pkt >> state;
120 key->SetFunctionKey(MMI::KeyEvent::NUM_LOCK_FUNCTION_KEY, state);
121 pkt >> state;
122 key->SetFunctionKey(MMI::KeyEvent::CAPS_LOCK_FUNCTION_KEY, state);
123 pkt >> state;
124 key->SetFunctionKey(MMI::KeyEvent::SCROLL_LOCK_FUNCTION_KEY, state);
125 }
126
SwitchEventToNetPacket(const std::shared_ptr<MMI::SwitchEvent> swEvent,NetPacket & pkt)127 int32_t InputEventSerialization::SwitchEventToNetPacket(
128 const std::shared_ptr<MMI::SwitchEvent> swEvent, NetPacket &pkt)
129 {
130 if (SerializeInputEvent(swEvent, pkt) != RET_OK) {
131 FI_HILOGE("Serialize input event failed");
132 return RET_ERR;
133 }
134 pkt << swEvent->GetSwitchValue() << swEvent->GetSwitchMask();
135 if (pkt.ChkRWError()) {
136 FI_HILOGE("Packet write key event failed");
137 return RET_ERR;
138 }
139 return RET_OK;
140 }
141
NetPacketToSwitchEvent(NetPacket & pkt,std::shared_ptr<MMI::SwitchEvent> swEvent)142 int32_t InputEventSerialization::NetPacketToSwitchEvent(NetPacket &pkt, std::shared_ptr<MMI::SwitchEvent> swEvent)
143 {
144 if (DeserializeInputEvent(pkt, swEvent) != RET_OK) {
145 FI_HILOGE("Deserialize input event failed");
146 return RET_ERR;
147 }
148 int32_t data = 0;
149 pkt >> data;
150 swEvent->SetSwitchValue(data);
151 pkt >> data;
152 swEvent->SetSwitchMask(data);
153 return RET_OK;
154 }
155
SerializeInputEvent(std::shared_ptr<MMI::InputEvent> event,NetPacket & pkt)156 int32_t InputEventSerialization::SerializeInputEvent(std::shared_ptr<MMI::InputEvent> event, NetPacket &pkt)
157 {
158 CHKPR(event, ERROR_NULL_POINTER);
159 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
160 << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
161 << event->GetTargetDisplayId() << event->GetTargetWindowId()
162 << event->GetAgentWindowId() << event->GetFlag();
163 if (pkt.ChkRWError()) {
164 FI_HILOGE("Serialize packet is failed");
165 return RET_ERR;
166 }
167 return RET_OK;
168 }
169
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<MMI::InputEvent> event)170 int32_t InputEventSerialization::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<MMI::InputEvent> event)
171 {
172 CHKPR(event, ERROR_NULL_POINTER);
173 int32_t tField = 0;
174 pkt >> tField;
175 pkt >> tField;
176 event->SetId(tField);
177 int64_t rField = 0;
178 pkt >> rField;
179 event->SetActionTime(rField);
180 pkt >> tField;
181 event->SetAction(tField);
182 pkt >> rField;
183 event->SetActionStartTime(rField);
184 uint64_t sensorTime;
185 pkt >> sensorTime;
186 event->SetSensorInputTime(sensorTime);
187 pkt >> tField;
188 event->SetDeviceId(tField);
189 pkt >> tField;
190 event->SetTargetDisplayId(tField);
191 pkt >> tField;
192 event->SetTargetWindowId(tField);
193 pkt >> tField;
194 event->SetAgentWindowId(tField);
195 uint32_t tFlag = MMI::InputEvent::EVENT_FLAG_NONE;
196 pkt >> tFlag;
197 if (pkt.ChkRWError()) {
198 FI_HILOGE("Deserialize packet is failed");
199 return RET_ERR;
200 }
201 event->AddFlag(tFlag);
202 return RET_OK;
203 }
204
SerializeBaseInfo(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)205 int32_t InputEventSerialization::SerializeBaseInfo(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
206 {
207 int32_t pointerAction = event->GetPointerAction();
208 int32_t pointerId = event->GetPointerId();
209 int32_t sourceType = event->GetSourceType();
210 int32_t btnId = event->GetButtonId();
211 int32_t fingerCnt = event->GetFingerCount();
212 float zOrder = event->GetZOrder();
213
214 pkt << pointerAction << pointerId << sourceType << btnId << fingerCnt << zOrder;
215 if (pkt.ChkRWError()) {
216 FI_HILOGE("Failed to serialize base information of pointer event");
217 return RET_ERR;
218 }
219 return RET_OK;
220 }
221
DeserializeBaseInfo(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)222 int32_t InputEventSerialization::DeserializeBaseInfo(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
223 {
224 int32_t pointerAction {};
225 int32_t pointerId {};
226 int32_t sourceType {};
227 int32_t btnId {};
228 int32_t fingerCnt {};
229 float zOrder {};
230
231 pkt >> pointerAction >> pointerId >> sourceType >> btnId >> fingerCnt >> zOrder;
232 if (pkt.ChkRWError()) {
233 FI_HILOGE("Failed to deserialize base information of pointer event");
234 return RET_ERR;
235 }
236 event->SetPointerAction(pointerAction);
237 event->SetPointerId(pointerId);
238 event->SetSourceType(sourceType);
239 event->SetButtonId(btnId);
240 event->SetFingerCount(fingerCnt);
241 event->SetZOrder(zOrder);
242 return RET_OK;
243 }
244
SerializeAxes(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)245 int32_t InputEventSerialization::SerializeAxes(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
246 {
247 uint32_t axes = event->GetAxes();
248 pkt << axes;
249
250 for (int32_t i = MMI::PointerEvent::AXIS_TYPE_UNKNOWN; i < MMI::PointerEvent::AXIS_TYPE_MAX; ++i) {
251 if (event->HasAxis(static_cast<MMI::PointerEvent::AxisType>(i))) {
252 double axisValue = event->GetAxisValue(static_cast<MMI::PointerEvent::AxisType>(i));
253 pkt << axisValue;
254 }
255 }
256 if (pkt.ChkRWError()) {
257 FI_HILOGE("Failed to serialize axes");
258 return RET_ERR;
259 }
260 return RET_OK;
261 }
262
DeserializeAxes(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)263 int32_t InputEventSerialization::DeserializeAxes(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
264 {
265 uint32_t axes {};
266 double axisValue {};
267
268 pkt >> axes;
269
270 for (int32_t i = MMI::PointerEvent::AXIS_TYPE_UNKNOWN; i < MMI::PointerEvent::AXIS_TYPE_MAX; ++i) {
271 if (MMI::PointerEvent::HasAxis(axes, static_cast<MMI::PointerEvent::AxisType>(i))) {
272 pkt >> axisValue;
273 event->SetAxisValue(static_cast<MMI::PointerEvent::AxisType>(i), axisValue);
274 }
275 }
276 if (pkt.ChkRWError()) {
277 FI_HILOGE("Failed to deserialize axes");
278 return RET_ERR;
279 }
280 return RET_OK;
281 }
282
SerializePressedButtons(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)283 int32_t InputEventSerialization::SerializePressedButtons(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
284 {
285 std::set<int32_t> pressedBtns = event->GetPressedButtons();
286 std::set<int32_t>::size_type nPressed = pressedBtns.size();
287
288 pkt << nPressed;
289
290 for (int32_t btnId : pressedBtns) {
291 pkt << btnId;
292 }
293 if (pkt.ChkRWError()) {
294 FI_HILOGE("Failed to serialize pressed buttons");
295 return RET_ERR;
296 }
297 return RET_OK;
298 }
299
DeserializePressedButtons(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)300 int32_t InputEventSerialization::DeserializePressedButtons(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
301 {
302 std::set<int32_t>::size_type nPressed;
303 int32_t btnId {};
304
305 pkt >> nPressed;
306
307 for (; nPressed > 0; --nPressed) {
308 pkt >> btnId;
309 event->SetButtonPressed(btnId);
310 }
311 if (pkt.ChkRWError()) {
312 FI_HILOGE("Failed to deserialize pressed buttons");
313 return RET_ERR;
314 }
315 return RET_OK;
316 }
317
SerializePointerItem(NetPacket & pkt,MMI::PointerEvent::PointerItem & item)318 int32_t InputEventSerialization::SerializePointerItem(NetPacket &pkt, MMI::PointerEvent::PointerItem &item)
319 {
320 InnerPointerItem innerItem;
321 InnerPointerItem::Transform(item, innerItem);
322 pkt << innerItem;
323 if (pkt.ChkRWError()) {
324 FI_HILOGE("Failed to serialize pointer item");
325 return RET_ERR;
326 }
327 return RET_OK;
328 }
329
DeserializePointerItem(NetPacket & pkt,MMI::PointerEvent::PointerItem & item)330 int32_t InputEventSerialization::DeserializePointerItem(NetPacket &pkt, MMI::PointerEvent::PointerItem &item)
331 {
332 InnerPointerItem innerItem;
333 pkt >> innerItem;
334 InnerPointerItem::Transform(innerItem, item);
335 if (pkt.ChkRWError()) {
336 FI_HILOGE("Failed to deserialize pointer item");
337 return RET_ERR;
338 }
339 return RET_OK;
340 }
341
SerializePointers(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)342 int32_t InputEventSerialization::SerializePointers(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
343 {
344 std::vector<int32_t> pointerIds = event->GetPointerIds();
345 std::vector<int32_t>::size_type nPointers = pointerIds.size();
346
347 pkt << nPointers;
348
349 for (const auto &pointerId : pointerIds) {
350 MMI::PointerEvent::PointerItem item;
351
352 if (!event->GetPointerItem(pointerId, item)) {
353 FI_HILOGE("Get pointer item failed");
354 return RET_ERR;
355 }
356 if (SerializePointerItem(pkt, item) != RET_OK) {
357 FI_HILOGE("Failed to serialize one pointer item");
358 return RET_ERR;
359 }
360 }
361 if (pkt.ChkRWError()) {
362 FI_HILOGE("Failed to serialize pointers");
363 return RET_ERR;
364 }
365 return RET_OK;
366 }
367
DeserializePointers(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)368 int32_t InputEventSerialization::DeserializePointers(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
369 {
370 std::vector<int32_t>::size_type nPointers;
371 pkt >> nPointers;
372
373 for (; nPointers > 0; --nPointers) {
374 MMI::PointerEvent::PointerItem item;
375
376 if (DeserializePointerItem(pkt, item) != RET_OK) {
377 FI_HILOGE("Failed to deserialize one pointer item");
378 return RET_ERR;
379 }
380 event->AddPointerItem(item);
381 }
382 if (pkt.ChkRWError()) {
383 FI_HILOGE("Failed to deserialize pointers");
384 return RET_ERR;
385 }
386 return RET_OK;
387 }
388
SerializePressedKeys(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)389 int32_t InputEventSerialization::SerializePressedKeys(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
390 {
391 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
392 std::vector<int32_t>::size_type nPressed = pressedKeys.size();
393
394 pkt << nPressed;
395
396 for (std::vector<int32_t>::size_type i = 0; i < nPressed; ++i) {
397 int32_t keyCode = pressedKeys[i];
398 pkt << keyCode;
399 }
400 if (pkt.ChkRWError()) {
401 FI_HILOGE("Failed to serialize pressed keys");
402 return RET_ERR;
403 }
404 return RET_OK;
405 }
406
DeserializePressedKeys(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)407 int32_t InputEventSerialization::DeserializePressedKeys(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
408 {
409 std::vector<int32_t>::size_type nPressed {};
410 pkt >> nPressed;
411
412 std::vector<int32_t> pressedKeys;
413 int32_t keyCode {};
414
415 for (; nPressed > 0; --nPressed) {
416 pkt >> keyCode;
417 pressedKeys.push_back(keyCode);
418 }
419 if (pkt.ChkRWError()) {
420 FI_HILOGE("Failed to deserialize pressed keys");
421 return RET_ERR;
422 }
423 event->SetPressedKeys(pressedKeys);
424 return RET_OK;
425 }
426
SerializeBuffer(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)427 int32_t InputEventSerialization::SerializeBuffer(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
428 {
429 std::vector<uint8_t> buffer = event->GetBuffer();
430 if (buffer.size() > MMI::ExtraData::MAX_BUFFER_SIZE) {
431 FI_HILOGE("buffer is oversize:%{public}zu", buffer.size());
432 return RET_ERR;
433 }
434 std::vector<uint8_t>::size_type bufSize = buffer.size();
435 pkt << bufSize;
436
437 for (std::vector<uint8_t>::size_type i = 0; i < bufSize; ++i) {
438 uint8_t item = buffer[i];
439 pkt << item;
440 }
441 if (pkt.ChkRWError()) {
442 FI_HILOGE("Failed to serialize buffer");
443 return RET_ERR;
444 }
445 return RET_OK;
446 }
447
HeartBeatMarshalling(NetPacket & pkt)448 int32_t InputEventSerialization::HeartBeatMarshalling(NetPacket &pkt)
449 {
450 CALL_DEBUG_ENTER;
451 pkt << HEART_BEAT_PACKET;
452 if (pkt.ChkRWError()) {
453 FI_HILOGE("Serialize packet is failed");
454 return RET_ERR;
455 }
456 return RET_OK;
457 }
458
DeserializeBuffer(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)459 int32_t InputEventSerialization::DeserializeBuffer(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
460 {
461 std::vector<uint8_t>::size_type bufSize {};
462 pkt >> bufSize;
463
464 std::vector<uint8_t> buffer;
465 uint8_t item {};
466
467 for (; bufSize > 0; --bufSize) {
468 pkt >> item;
469 buffer.push_back(item);
470 }
471 if (pkt.ChkRWError()) {
472 FI_HILOGE("Failed to deserialize buffer");
473 return RET_ERR;
474 }
475 event->SetBuffer(buffer);
476 return RET_OK;
477 }
478
Marshalling(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)479 int32_t InputEventSerialization::Marshalling(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
480 {
481 CALL_DEBUG_ENTER;
482 CHKPR(event, ERROR_NULL_POINTER);
483
484 if (SerializeInputEvent(event, pkt) != RET_OK) {
485 FI_HILOGE("Serialize input event failed");
486 return RET_ERR;
487 }
488 if (SerializeBaseInfo(event, pkt) != RET_OK) {
489 FI_HILOGE("Failed to serialize base information of pointer event");
490 return RET_ERR;
491 }
492 if (SerializeAxes(event, pkt) != RET_OK) {
493 FI_HILOGE("Failed to serialize axes");
494 return RET_ERR;
495 }
496 if (SerializePressedButtons(event, pkt) != RET_OK) {
497 FI_HILOGE("Failed to serialize pressed buttons");
498 return RET_ERR;
499 }
500 if (SerializePointers(event, pkt) != RET_OK) {
501 FI_HILOGE("Failed to serialize pointers");
502 return RET_ERR;
503 }
504 if (SerializePressedKeys(event, pkt) != RET_OK) {
505 FI_HILOGE("Failed to serialize pressed keys");
506 return RET_ERR;
507 }
508 if (SerializeBuffer(event, pkt) != RET_OK) {
509 FI_HILOGE("Failed to serialize buffer");
510 return RET_ERR;
511 }
512 return RET_OK;
513 }
514
Unmarshalling(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)515 int32_t InputEventSerialization::Unmarshalling(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
516 {
517 CALL_DEBUG_ENTER;
518 CHKPR(event, ERROR_NULL_POINTER);
519
520 if (DeserializeInputEvent(pkt, event) != RET_OK) {
521 FI_HILOGE("Failed to deserialize input event");
522 return RET_ERR;
523 }
524 if (DeserializeBaseInfo(pkt, event) != RET_OK) {
525 FI_HILOGE("Failed to deserialize base information of pointer event");
526 return RET_ERR;
527 }
528 if (DeserializeAxes(pkt, event) != RET_OK) {
529 FI_HILOGE("Failed to deserialize axes");
530 return RET_ERR;
531 }
532 if (DeserializePressedButtons(pkt, event) != RET_OK) {
533 FI_HILOGE("Failed to deserialize pressed buttons");
534 return RET_ERR;
535 }
536 if (DeserializePointers(pkt, event) != RET_OK) {
537 FI_HILOGE("Failed to deserialize pointers");
538 return RET_ERR;
539 }
540 if (DeserializePressedKeys(pkt, event) != RET_OK) {
541 FI_HILOGE("Failed to deserialize pressed keys");
542 return RET_ERR;
543 }
544 if (DeserializeBuffer(pkt, event) != RET_OK) {
545 FI_HILOGE("Failed to deserialize buffer");
546 return RET_ERR;
547 }
548 return RET_OK;
549 }
550
551 #ifdef OHOS_BUILD_ENABLE_SECURITY_PART
MarshallingEnhanceData(std::shared_ptr<MMI::PointerEvent> event,NetPacket & pkt)552 int32_t InputEventSerialization::MarshallingEnhanceData(std::shared_ptr<MMI::PointerEvent> event, NetPacket &pkt)
553 {
554 CHKPR(event, ERROR_NULL_POINTER);
555 int32_t pointerId = event->GetPointerId();
556 MMI::PointerEvent::PointerItem pointerItem;
557 if (!event->GetPointerItem(pointerId, pointerItem)) {
558 FI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
559 return RET_ERR;
560 }
561 SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
562 if (secCompPointEvent == NULL) {
563 FI_HILOGE("Malloc failed");
564 return RET_ERR;
565 }
566 secCompPointEvent->touchX = pointerItem.GetDisplayX();
567 secCompPointEvent->touchY = pointerItem.GetDisplayY();
568 secCompPointEvent->timeStamp = event->GetActionTime();
569 uint32_t dataLen = sizeof(*secCompPointEvent);
570 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
571 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
572 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
573 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
574 dataLen, enHanceData, enHanceDataLen);
575 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
576 pkt << 0;
577 free(secCompPointEvent);
578 secCompPointEvent = nullptr;
579 FI_HILOGD("GetPointerEventEnhanceData failed!");
580 return RET_ERR;
581 }
582 pkt << enHanceDataLen;
583 std::vector<uint8_t> realBuf;
584 for (size_t i = 0; i < enHanceDataLen; i++) {
585 realBuf.push_back(enHanceData[i]);
586 pkt << realBuf[i];
587 }
588 free(secCompPointEvent);
589 secCompPointEvent = nullptr;
590 if (pkt.ChkRWError()) {
591 FI_HILOGE("Marshalling enhanceData failed");
592 return RET_ERR;
593 }
594 return RET_OK;
595 }
596
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<MMI::PointerEvent> event)597 int32_t InputEventSerialization::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<MMI::PointerEvent> event)
598 {
599 uint32_t enHanceDataLen;
600 pkt >> enHanceDataLen;
601 if (enHanceDataLen == 0) {
602 return RET_OK;
603 }
604 uint8_t enhanceDataBuf[enHanceDataLen];
605 std::vector<uint8_t> enhanceData;
606 for (size_t i = 0; i < enHanceDataLen; i++) {
607 pkt >> enhanceDataBuf[i];
608 enhanceData.push_back(enhanceDataBuf[i]);
609 }
610 if (pkt.ChkRWError()) {
611 FI_HILOGE("UnmarshallingEnhanceData pointer event failed");
612 return RET_ERR;
613 }
614 event->SetEnhanceData(enhanceData);
615 return RET_OK;
616 }
617
618 struct keyEventEnhanceData {
619 int64_t timestamp;
620 int32_t keyCode;
621 };
622
MarshallingEnhanceData(std::shared_ptr<MMI::KeyEvent> event,NetPacket & pkt)623 int32_t InputEventSerialization::MarshallingEnhanceData(std::shared_ptr<MMI::KeyEvent> event, NetPacket &pkt)
624 {
625 CHKPR(event, ERROR_NULL_POINTER);
626 struct keyEventEnhanceData secCompKeyEvent;
627 secCompKeyEvent.timestamp = event->GetActionTime();
628 secCompKeyEvent.keyCode = event->GetKeyCode();
629 uint32_t dataLen = sizeof(secCompKeyEvent);
630 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
631 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
632 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
633 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(&secCompKeyEvent,
634 dataLen, enHanceData, enHanceDataLen);
635 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
636 pkt << 0;
637 FI_HILOGD("GetKeyEventEnhanceData failed!");
638 return RET_ERR;
639 }
640 pkt << enHanceDataLen;
641 std::vector<uint8_t> realBuf;
642 for (size_t i = 0; i < enHanceDataLen; i++) {
643 realBuf.push_back(enHanceData[i]);
644 pkt << realBuf[i];
645 }
646 if (pkt.ChkRWError()) {
647 FI_HILOGE("Marshalling enhanceData failed");
648 return RET_ERR;
649 }
650 return RET_OK;
651 }
652
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<MMI::KeyEvent> event)653 int32_t InputEventSerialization::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<MMI::KeyEvent> event)
654 {
655 uint32_t enHanceDataLen;
656 pkt >> enHanceDataLen;
657 if (enHanceDataLen == 0 || enHanceDataLen > MAX_HMAC_SIZE) {
658 return RET_OK;
659 }
660 uint8_t enhanceDataBuf[enHanceDataLen];
661 std::vector<uint8_t> enhanceData;
662 for (size_t i = 0; i < enHanceDataLen; i++) {
663 pkt >> enhanceDataBuf[i];
664 enhanceData.push_back(enhanceDataBuf[i]);
665 }
666 if (pkt.ChkRWError()) {
667 FI_HILOGE("UnmarshallingEnhanceData key event failed");
668 return RET_ERR;
669 }
670 event->SetEnhanceData(enhanceData);
671 return RET_OK;
672 }
673 #endif // OHOS_BUILD_ENABLE_SECURITY_PART
674 } // namespace Cooperate
675 } // namespace DeviceStatus
676 } // namespace Msdp
677 } // namespace OHOS
678