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_data_transformation.h"
17
18 #include "define_multimodal.h"
19 #include "extra_data.h"
20 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
21 #include "sec_comp_enhance_kit.h"
22 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
23
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "KeyEventDataTransformation" };
28 } // namespace
29
KeyEventToNetPacket(const std::shared_ptr<KeyEvent> key,NetPacket & pkt)30 int32_t InputEventDataTransformation::KeyEventToNetPacket(
31 const std::shared_ptr<KeyEvent> key, NetPacket &pkt)
32 {
33 if (SerializeInputEvent(key, pkt) != RET_OK) {
34 MMI_HILOGE("Serialize input event failed");
35 return RET_ERR;
36 }
37 pkt << key->GetKeyCode() << key->GetKeyAction() << key->GetKeyIntention();
38 auto keys = key->GetKeyItems();
39 int32_t size = static_cast<int32_t>(keys.size());
40 if (size > MAX_KEY_SIZE) {
41 MMI_HILOGE("Key exceeds the max range");
42 return RET_ERR;
43 }
44 pkt << size;
45 for (const auto &item : keys) {
46 pkt << item.GetKeyCode() << item.GetDownTime()
47 << item.GetDeviceId() << item.IsPressed() << item.GetUnicode();
48 }
49 pkt << key->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY)
50 << key->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY)
51 << key->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
52 if (pkt.ChkRWError()) {
53 MMI_HILOGE("Packet write key event failed");
54 return RET_ERR;
55 }
56 return RET_OK;
57 }
58
NetPacketToKeyEvent(NetPacket & pkt,std::shared_ptr<KeyEvent> key)59 int32_t InputEventDataTransformation::NetPacketToKeyEvent(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
60 {
61 if (DeserializeInputEvent(pkt, key) != RET_OK) {
62 MMI_HILOGE("Deserialize input event failed");
63 return RET_ERR;
64 }
65 int32_t data = 0;
66 pkt >> data;
67 key->SetKeyCode(data);
68 pkt >> data;
69 key->SetKeyAction(data);
70 pkt >> data;
71 key->SetKeyIntention(data);
72 int32_t size = 0;
73 pkt >> size;
74 if (size > MAX_KEY_SIZE) {
75 MMI_HILOGE("Key exceeds the max range");
76 return RET_ERR;
77 }
78 if (pkt.ChkRWError()) {
79 MMI_HILOGE("Packet read size failed");
80 return RET_ERR;
81 }
82 bool isPressed = false;
83 for (int32_t i = 0; i < size; i++) {
84 KeyEvent::KeyItem keyItem;
85 pkt >> data;
86 keyItem.SetKeyCode(data);
87 int64_t datatime = 0;
88 pkt >> datatime;
89 keyItem.SetDownTime(datatime);
90 pkt >> data;
91 keyItem.SetDeviceId(data);
92 pkt >> isPressed;
93 if (pkt.ChkRWError()) {
94 MMI_HILOGE("Packet read item isPressed failed");
95 return RET_ERR;
96 }
97 keyItem.SetPressed(isPressed);
98 uint32_t unicode;
99 pkt >> unicode;
100 keyItem.SetUnicode(unicode);
101 key->AddKeyItem(keyItem);
102 }
103 ReadFunctionKeys(pkt, key);
104 return RET_OK;
105 }
106
ReadFunctionKeys(NetPacket & pkt,std::shared_ptr<KeyEvent> key)107 void InputEventDataTransformation::ReadFunctionKeys(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
108 {
109 CHKPV(key);
110 bool state = false;
111 pkt >> state;
112 key->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, state);
113 pkt >> state;
114 key->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, state);
115 pkt >> state;
116 key->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, state);
117 }
118
SwitchEventToNetPacket(const std::shared_ptr<SwitchEvent> swEvent,NetPacket & pkt)119 int32_t InputEventDataTransformation::SwitchEventToNetPacket(
120 const std::shared_ptr<SwitchEvent> swEvent, NetPacket &pkt)
121 {
122 if (SerializeInputEvent(swEvent, pkt) != RET_OK) {
123 MMI_HILOGE("Serialize input event failed");
124 return RET_ERR;
125 }
126 pkt << swEvent->GetSwitchValue() << swEvent->GetSwitchMask();
127 if (pkt.ChkRWError()) {
128 MMI_HILOGE("Packet write key event failed");
129 return RET_ERR;
130 }
131 return RET_OK;
132 }
133
NetPacketToSwitchEvent(NetPacket & pkt,std::shared_ptr<SwitchEvent> swEvent)134 int32_t InputEventDataTransformation::NetPacketToSwitchEvent(NetPacket &pkt, std::shared_ptr<SwitchEvent> swEvent)
135 {
136 if (DeserializeInputEvent(pkt, swEvent) != RET_OK) {
137 MMI_HILOGE("Deserialize input event failed");
138 return RET_ERR;
139 }
140 int32_t data = 0;
141 pkt >> data;
142 swEvent->SetSwitchValue(data);
143 pkt >> data;
144 swEvent->SetSwitchMask(data);
145 return RET_OK;
146 }
147
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)148 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
149 {
150 CHKPR(event, ERROR_NULL_POINTER);
151 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
152 << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
153 << event->GetTargetDisplayId() << event->GetTargetWindowId()
154 << event->GetAgentWindowId() << event->GetFlag();
155 if (pkt.ChkRWError()) {
156 MMI_HILOGE("Serialize packet is failed");
157 return RET_ERR;
158 }
159 return RET_OK;
160 }
161
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)162 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
163 {
164 CHKPR(event, ERROR_NULL_POINTER);
165 int32_t tField = 0;
166 pkt >> tField;
167 pkt >> tField;
168 event->SetId(tField);
169 int64_t rField = 0;
170 pkt >> rField;
171 event->SetActionTime(rField);
172 pkt >> tField;
173 event->SetAction(tField);
174 pkt >> rField;
175 event->SetActionStartTime(rField);
176 uint64_t sensorTime;
177 pkt >> sensorTime;
178 event->SetSensorInputTime(sensorTime);
179 pkt >> tField;
180 event->SetDeviceId(tField);
181 pkt >> tField;
182 event->SetTargetDisplayId(tField);
183 pkt >> tField;
184 event->SetTargetWindowId(tField);
185 pkt >> tField;
186 event->SetAgentWindowId(tField);
187 uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
188 pkt >> tFlag;
189 if (pkt.ChkRWError()) {
190 MMI_HILOGE("Deserialize packet is failed");
191 return RET_ERR;
192 }
193 event->AddFlag(tFlag);
194 return RET_OK;
195 }
196
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)197 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
198 {
199 CHKPR(event, ERROR_NULL_POINTER);
200 if (SerializeInputEvent(event, pkt) != RET_OK) {
201 MMI_HILOGE("Serialize input event failed");
202 return RET_ERR;
203 }
204 pkt << event->GetPointerAction() << event->GetPointerId() << event->GetSourceType() << event->GetButtonId()
205 << event->GetFingerCount() << event->GetAxes();
206
207 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
208 if (event->HasAxis(static_cast<PointerEvent::AxisType>(i))) {
209 pkt << event->GetAxisValue(static_cast<PointerEvent::AxisType>(i));
210 }
211 }
212 std::set<int32_t> pressedBtns { event->GetPressedButtons() };
213 pkt << pressedBtns.size();
214 for (int32_t btnId : pressedBtns) {
215 pkt << btnId;
216 }
217 std::vector<int32_t> pointerIds { event->GetPointerIds() };
218 pkt << pointerIds.size();
219 for (const auto &pointerId : pointerIds) {
220 PointerEvent::PointerItem item;
221 if (!event->GetPointerItem(pointerId, item)) {
222 MMI_HILOGE("Get pointer item failed");
223 return RET_ERR;
224 }
225 if (SerializePointerItem(pkt, item) != RET_OK) {
226 MMI_HILOGE("Serialize pointer item failed");
227 return RET_ERR;
228 }
229 }
230 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
231 pkt << pressedKeys.size();
232 for (const auto &keyCode : pressedKeys) {
233 pkt << keyCode;
234 }
235 std::vector<uint8_t> buffer = event->GetBuffer();
236 if (buffer.size() > ExtraData::MAX_BUFFER_SIZE) {
237 MMI_HILOGE("buffer is oversize:%{public}zu", buffer.size());
238 return RET_ERR;
239 }
240 pkt << buffer.size();
241 for (const auto &buf : buffer) {
242 pkt << buf;
243 }
244 if (pkt.ChkRWError()) {
245 MMI_HILOGE("Marshalling pointer event failed");
246 return RET_ERR;
247 }
248 return RET_OK;
249 }
250
DeserializePressedButtons(std::shared_ptr<PointerEvent> event,NetPacket & pkt)251 int32_t InputEventDataTransformation::DeserializePressedButtons(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
252 {
253 CHKPR(event, ERROR_NULL_POINTER);
254 int32_t tField;
255 pkt >> tField;
256 event->SetPointerAction(tField);
257 pkt >> tField;
258 event->SetPointerId(tField);
259 pkt >> tField;
260 event->SetSourceType(tField);
261 pkt >> tField;
262 event->SetButtonId(tField);
263 pkt >> tField;
264 event->SetFingerCount(tField);
265 SetAxisInfo(pkt, event);
266
267 std::set<int32_t>::size_type nPressed;
268 pkt >> nPressed;
269 while (nPressed-- > 0) {
270 pkt >> tField;
271 event->SetButtonPressed(tField);
272 }
273 return RET_OK;
274 }
275
DeserializePointerIds(std::shared_ptr<PointerEvent> event,NetPacket & pkt)276 int32_t InputEventDataTransformation::DeserializePointerIds(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
277 {
278 CHKPR(event, ERROR_NULL_POINTER);
279 std::vector<int32_t>::size_type pointerCnt;
280 pkt >> pointerCnt;
281 while (pointerCnt-- > 0) {
282 PointerEvent::PointerItem item;
283 if (DeserializePointerItem(pkt, item) != RET_OK) {
284 MMI_HILOGE("Deserialize pointer item failed");
285 return RET_ERR;
286 }
287 event->AddPointerItem(item);
288 }
289 return RET_OK;
290 }
291
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)292 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
293 {
294 if (DeserializeInputEvent(pkt, event) != RET_OK) {
295 MMI_HILOGE("Deserialize input event failed");
296 return RET_ERR;
297 }
298
299 if (DeserializePressedButtons(event, pkt) != RET_OK) {
300 MMI_HILOGE("Deserialize pressed buttons failed");
301 return RET_ERR;
302 }
303
304 if (DeserializePointerIds(event, pkt) != RET_OK) {
305 MMI_HILOGE("Deserialize pressed ids failed");
306 return RET_ERR;
307 }
308
309 std::vector<int32_t> pressedKeys;
310 std::vector<int32_t>::size_type pressedKeySize;
311 int32_t tField;
312 pkt >> pressedKeySize;
313 while (pressedKeySize-- > 0) {
314 pkt >> tField;
315 pressedKeys.push_back(tField);
316 }
317 if (pkt.ChkRWError()) {
318 MMI_HILOGE("Unmarshalling pointer event failed");
319 return RET_ERR;
320 }
321 event->SetPressedKeys(pressedKeys);
322
323 std::vector<uint8_t> buffer;
324 std::vector<uint8_t>::size_type bufferSize;
325 pkt >> bufferSize;
326 uint8_t buff = 0;
327 while (bufferSize-- > 0) {
328 pkt >> buff;
329 buffer.push_back(buff);
330 }
331 if (pkt.ChkRWError()) {
332 MMI_HILOGE("Unmarshalling pointer event failed");
333 return RET_ERR;
334 }
335 event->SetBuffer(buffer);
336 return RET_OK;
337 }
338
SetAxisInfo(NetPacket & pkt,std::shared_ptr<PointerEvent> event)339 void InputEventDataTransformation::SetAxisInfo(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
340 {
341 uint32_t tAxes;
342 pkt >> tAxes;
343 double axisValue;
344 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
345 if (PointerEvent::HasAxis(tAxes, static_cast<PointerEvent::AxisType>(i))) {
346 pkt >> axisValue;
347 event->SetAxisValue(static_cast<PointerEvent::AxisType>(i), axisValue);
348 }
349 }
350 }
351
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)352 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
353 {
354 pkt << item;
355 if (pkt.ChkRWError()) {
356 MMI_HILOGE("Packet write pointer item failed");
357 return RET_ERR;
358 }
359 return RET_OK;
360 }
361
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)362 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
363 {
364 pkt >> item;
365 if (pkt.ChkRWError()) {
366 MMI_HILOGE("Packet read pointer item failed");
367 return RET_ERR;
368 }
369 return RET_OK;
370 }
371
372 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
MarshallingEnhanceData(std::shared_ptr<PointerEvent> event,NetPacket & pkt)373 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
374 {
375 CHKPR(event, ERROR_NULL_POINTER);
376 int32_t pointerId = event->GetPointerId();
377 PointerEvent::PointerItem pointerItem;
378 if (!event->GetPointerItem(pointerId, pointerItem)) {
379 MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
380 return RET_ERR;
381 }
382 SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
383 if (secCompPointEvent == NULL) {
384 MMI_HILOGE("Malloc failed");
385 return RET_ERR;
386 }
387 secCompPointEvent->touchX = pointerItem.GetDisplayX();
388 secCompPointEvent->touchY = pointerItem.GetDisplayY();
389 secCompPointEvent->timeStamp = event->GetActionTime();
390 uint32_t dataLen = sizeof(*secCompPointEvent);
391 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
392 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
393 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
394 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
395 dataLen, enHanceData, enHanceDataLen);
396 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
397 pkt << 0;
398 free(secCompPointEvent);
399 secCompPointEvent = nullptr;
400 MMI_HILOGD("GetPointerEventEnhanceData failed!");
401 return RET_ERR;
402 }
403 pkt << enHanceDataLen;
404 std::vector<uint8_t> realBuf;
405 for (size_t i = 0; i < enHanceDataLen; i++) {
406 realBuf.push_back(enHanceData[i]);
407 pkt << realBuf[i];
408 }
409 free(secCompPointEvent);
410 secCompPointEvent = nullptr;
411 if (pkt.ChkRWError()) {
412 MMI_HILOGE("Marshalling enhanceData failed");
413 return RET_ERR;
414 }
415 return RET_OK;
416 }
417
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<PointerEvent> event)418 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
419 {
420 uint32_t enHanceDataLen;
421 pkt >> enHanceDataLen;
422 if (enHanceDataLen == 0) {
423 return RET_OK;
424 }
425 uint8_t enhanceDataBuf[enHanceDataLen];
426 std::vector<uint8_t> enhanceData;
427 for (size_t i = 0; i < enHanceDataLen; i++) {
428 pkt >> enhanceDataBuf[i];
429 enhanceData.push_back(enhanceDataBuf[i]);
430 }
431 if (pkt.ChkRWError()) {
432 MMI_HILOGE("UnmarshallingEnhanceData pointer event failed");
433 return RET_ERR;
434 }
435 event->SetEnhanceData(enhanceData);
436 return RET_OK;
437 }
438 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
439 } // namespace MMI
440 } // namespace OHOS
441