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 }
119
SwitchEventToNetPacket(const std::shared_ptr<SwitchEvent> swEvent,NetPacket & pkt)120 int32_t InputEventDataTransformation::SwitchEventToNetPacket(
121 const std::shared_ptr<SwitchEvent> swEvent, NetPacket &pkt)
122 {
123 if (SerializeInputEvent(swEvent, pkt) != RET_OK) {
124 MMI_HILOGE("Serialize input event failed");
125 return RET_ERR;
126 }
127 pkt << swEvent->GetSwitchValue() << swEvent->GetSwitchMask();
128 if (pkt.ChkRWError()) {
129 MMI_HILOGE("Packet write key event failed");
130 return RET_ERR;
131 }
132 return RET_OK;
133 }
134
NetPacketToSwitchEvent(NetPacket & pkt,std::shared_ptr<SwitchEvent> swEvent)135 int32_t InputEventDataTransformation::NetPacketToSwitchEvent(NetPacket &pkt, std::shared_ptr<SwitchEvent> swEvent)
136 {
137 if (DeserializeInputEvent(pkt, swEvent) != RET_OK) {
138 MMI_HILOGE("Deserialize input event failed");
139 return RET_ERR;
140 }
141 int32_t data = 0;
142 pkt >> data;
143 swEvent->SetSwitchValue(data);
144 pkt >> data;
145 swEvent->SetSwitchMask(data);
146 return RET_OK;
147 }
148
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)149 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
150 {
151 CHKPR(event, ERROR_NULL_POINTER);
152 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
153 << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
154 << event->GetTargetDisplayId() << event->GetTargetWindowId()
155 << event->GetAgentWindowId() << event->GetFlag();
156 if (pkt.ChkRWError()) {
157 MMI_HILOGE("Serialize packet is failed");
158 return RET_ERR;
159 }
160 return RET_OK;
161 }
162
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)163 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
164 {
165 CHKPR(event, ERROR_NULL_POINTER);
166 int32_t tField = 0;
167 pkt >> tField;
168 pkt >> tField;
169 event->SetId(tField);
170 int64_t rField = 0;
171 pkt >> rField;
172 event->SetActionTime(rField);
173 pkt >> tField;
174 event->SetAction(tField);
175 pkt >> rField;
176 event->SetActionStartTime(rField);
177 uint64_t sensorTime;
178 pkt >> sensorTime;
179 event->SetSensorInputTime(sensorTime);
180 pkt >> tField;
181 event->SetDeviceId(tField);
182 pkt >> tField;
183 event->SetTargetDisplayId(tField);
184 pkt >> tField;
185 event->SetTargetWindowId(tField);
186 pkt >> tField;
187 event->SetAgentWindowId(tField);
188 uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
189 pkt >> tFlag;
190 if (pkt.ChkRWError()) {
191 MMI_HILOGE("Deserialize packet is failed");
192 return RET_ERR;
193 }
194 event->AddFlag(tFlag);
195 return RET_OK;
196 }
197
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)198 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
199 {
200 CHKPR(event, ERROR_NULL_POINTER);
201 if (SerializeInputEvent(event, pkt) != RET_OK) {
202 MMI_HILOGE("Serialize input event failed");
203 return RET_ERR;
204 }
205 pkt << event->GetPointerAction() << event->GetPointerId() << event->GetSourceType() << event->GetButtonId()
206 << event->GetFingerCount() << event->GetAxes();
207
208 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
209 if (event->HasAxis(static_cast<PointerEvent::AxisType>(i))) {
210 pkt << event->GetAxisValue(static_cast<PointerEvent::AxisType>(i));
211 }
212 }
213 std::set<int32_t> pressedBtns { event->GetPressedButtons() };
214 pkt << pressedBtns.size();
215 for (int32_t btnId : pressedBtns) {
216 pkt << btnId;
217 }
218 std::vector<int32_t> pointerIds { event->GetPointerIds() };
219 pkt << pointerIds.size();
220 for (const auto &pointerId : pointerIds) {
221 PointerEvent::PointerItem item;
222 if (!event->GetPointerItem(pointerId, item)) {
223 MMI_HILOGE("Get pointer item failed");
224 return RET_ERR;
225 }
226 if (SerializePointerItem(pkt, item) != RET_OK) {
227 MMI_HILOGE("Serialize pointer item failed");
228 return RET_ERR;
229 }
230 }
231 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
232 pkt << pressedKeys.size();
233 for (const auto &keyCode : pressedKeys) {
234 pkt << keyCode;
235 }
236 std::vector<uint8_t> buffer = event->GetBuffer();
237 if (buffer.size() > ExtraData::MAX_BUFFER_SIZE) {
238 MMI_HILOGE("buffer is oversize:%{public}zu", buffer.size());
239 return RET_ERR;
240 }
241 pkt << buffer.size();
242 for (const auto &buf : buffer) {
243 pkt << buf;
244 }
245 if (pkt.ChkRWError()) {
246 MMI_HILOGE("Marshalling pointer event failed");
247 return RET_ERR;
248 }
249 return RET_OK;
250 }
251
DeserializePressedButtons(std::shared_ptr<PointerEvent> event,NetPacket & pkt)252 int32_t InputEventDataTransformation::DeserializePressedButtons(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
253 {
254 CHKPR(event, ERROR_NULL_POINTER);
255
256
257
258 int32_t tField;
259 pkt >> tField;
260 event->SetPointerAction(tField);
261 pkt >> tField;
262 event->SetPointerId(tField);
263 pkt >> tField;
264 event->SetSourceType(tField);
265 pkt >> tField;
266 event->SetButtonId(tField);
267 pkt >> tField;
268 event->SetFingerCount(tField);
269 SetAxisInfo(pkt, event);
270
271 std::set<int32_t>::size_type nPressed;
272 pkt >> nPressed;
273 while (nPressed-- > 0) {
274 pkt >> tField;
275 event->SetButtonPressed(tField);
276 }
277 return RET_OK;
278 }
279
DeserializePointerIds(std::shared_ptr<PointerEvent> event,NetPacket & pkt)280 int32_t InputEventDataTransformation::DeserializePointerIds(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
281 {
282 CHKPR(event, ERROR_NULL_POINTER);
283 std::vector<int32_t>::size_type pointerCnt;
284 pkt >> pointerCnt;
285 while (pointerCnt-- > 0) {
286 PointerEvent::PointerItem item;
287 if (DeserializePointerItem(pkt, item) != RET_OK) {
288 MMI_HILOGE("Deserialize pointer item failed");
289 return RET_ERR;
290 }
291 event->AddPointerItem(item);
292 }
293 return RET_OK;
294 }
295
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)296 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
297 {
298 if (DeserializeInputEvent(pkt, event) != RET_OK) {
299 MMI_HILOGE("Deserialize input event failed");
300 return RET_ERR;
301 }
302
303 if (DeserializePressedButtons(event, pkt) != RET_OK) {
304 MMI_HILOGE("Deserialize pressed buttons failed");
305 return RET_ERR;
306 }
307
308 if (DeserializePointerIds(event, pkt) != RET_OK) {
309 MMI_HILOGE("Deserialize pressed ids failed");
310 return RET_ERR;
311 }
312
313 std::vector<int32_t> pressedKeys;
314 std::vector<int32_t>::size_type pressedKeySize;
315 int32_t tField;
316 pkt >> pressedKeySize;
317 while (pressedKeySize-- > 0) {
318 pkt >> tField;
319 pressedKeys.push_back(tField);
320 }
321 if (pkt.ChkRWError()) {
322 MMI_HILOGE("Unmarshalling pointer event failed");
323 return RET_ERR;
324 }
325 event->SetPressedKeys(pressedKeys);
326
327 std::vector<uint8_t> buffer;
328 std::vector<uint8_t>::size_type bufferSize;
329 pkt >> bufferSize;
330 uint8_t buff = 0;
331 while (bufferSize-- > 0) {
332 pkt >> buff;
333 buffer.push_back(buff);
334 }
335 if (pkt.ChkRWError()) {
336 MMI_HILOGE("Unmarshalling pointer event failed");
337 return RET_ERR;
338 }
339 event->SetBuffer(buffer);
340 return RET_OK;
341 }
342
SetAxisInfo(NetPacket & pkt,std::shared_ptr<PointerEvent> event)343 void InputEventDataTransformation::SetAxisInfo(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
344 {
345 uint32_t tAxes;
346 pkt >> tAxes;
347 double axisValue;
348 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
349 if (PointerEvent::HasAxis(tAxes, static_cast<PointerEvent::AxisType>(i))) {
350 pkt >> axisValue;
351 event->SetAxisValue(static_cast<PointerEvent::AxisType>(i), axisValue);
352 }
353 }
354 }
355
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)356 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
357 {
358 pkt << item;
359 if (pkt.ChkRWError()) {
360 MMI_HILOGE("Packet write pointer item failed");
361 return RET_ERR;
362 }
363 return RET_OK;
364 }
365
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)366 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
367 {
368 pkt >> item;
369 if (pkt.ChkRWError()) {
370 MMI_HILOGE("Packet read pointer item failed");
371 return RET_ERR;
372 }
373 return RET_OK;
374 }
375
376 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
MarshallingEnhanceData(std::shared_ptr<PointerEvent> event,NetPacket & pkt)377 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
378 {
379 CHKPR(event, ERROR_NULL_POINTER);
380 int32_t pointerId = event->GetPointerId();
381 PointerEvent::PointerItem pointerItem;
382 if (!event->GetPointerItem(pointerId, pointerItem)) {
383 MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
384 return RET_ERR;
385 }
386 SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
387 if (secCompPointEvent == NULL) {
388 MMI_HILOGE("Malloc failed");
389 return RET_ERR;
390 }
391 secCompPointEvent->touchX = pointerItem.GetDisplayX();
392 secCompPointEvent->touchY = pointerItem.GetDisplayY();
393 secCompPointEvent->timeStamp = event->GetActionTime();
394 uint32_t dataLen = sizeof(*secCompPointEvent);
395 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
396 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
397 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
398 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
399 dataLen, enHanceData, enHanceDataLen);
400 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
401 pkt << 0;
402 free(secCompPointEvent);
403 secCompPointEvent = nullptr;
404 MMI_HILOGD("GetPointerEventEnhanceData failed!");
405 return RET_ERR;
406 }
407 pkt << enHanceDataLen;
408 std::vector<uint8_t> realBuf;
409 for (size_t i = 0; i < enHanceDataLen; i++) {
410 realBuf.push_back(enHanceData[i]);
411 pkt << realBuf[i];
412 }
413 free(secCompPointEvent);
414 secCompPointEvent = nullptr;
415 if (pkt.ChkRWError()) {
416 MMI_HILOGE("Marshalling enhanceData failed");
417 return RET_ERR;
418 }
419 return RET_OK;
420 }
421
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<PointerEvent> event)422 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
423 {
424 uint32_t enHanceDataLen;
425 pkt >> enHanceDataLen;
426 if (enHanceDataLen == 0) {
427 return RET_OK;
428 }
429 uint8_t enhanceDataBuf[enHanceDataLen];
430 std::vector<uint8_t> enhanceData;
431 for (size_t i = 0; i < enHanceDataLen; i++) {
432 pkt >> enhanceDataBuf[i];
433 enhanceData.push_back(enhanceDataBuf[i]);
434 }
435 if (pkt.ChkRWError()) {
436 MMI_HILOGE("UnmarshallingEnhanceData pointer event failed");
437 return RET_ERR;
438 }
439 event->SetEnhanceData(enhanceData);
440 return RET_OK;
441 }
442 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
443 } // namespace MMI
444 } // namespace OHOS
445