1 /*
2  * Copyright (c) 2021 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 
17 #include "serializer.h"
18 #include "serializer_inner.h"
19 
20 #include <stdlib.h>
21 #include <string.h>
22 #include "rpc_log.h"
23 #include "securec.h"
24 
25 #define ALIGN_SZ 4
26 #define IPC_IO_ALIGN(sz) (((sz) + ALIGN_SZ - 1) & (~(ALIGN_SZ - 1)))
27 
28 #define IPC_IO_RETURN_IF_FAIL(value)                                             \
29     do {                                                                         \
30         if (!(value)) {                                                          \
31             printf("IPC_CHECK failed: %s:%d\n", __FUNCTION__, __LINE__);        \
32             if (io != NULL) {                                                    \
33                 io->flag |= IPC_IO_OVERFLOW;                                     \
34             }                                                                    \
35             return NULL;                                                         \
36         }                                                                        \
37     } while (0)
38 
39 
IpcIoInit(IpcIo * io,void * buffer,size_t bufferSize,size_t maxobjects)40 void IpcIoInit(IpcIo *io, void *buffer, size_t bufferSize, size_t maxobjects)
41 {
42     if ((io == NULL) || (buffer == NULL) || (bufferSize == 0) ||
43         (bufferSize > MAX_IO_SIZE) || (maxobjects > MAX_OBJ_NUM)) {
44         return;
45     }
46     size_t objectsSize = maxobjects * sizeof(size_t);
47 
48     if (objectsSize > bufferSize) {
49         io->flag = IPC_IO_OVERFLOW;
50         io->bufferLeft = 0;
51         io->offsetsLeft = 0;
52         return;
53     }
54 
55     io->bufferCur = io->bufferBase = (char *)buffer + objectsSize;
56     io->offsetsCur = io->offsetsBase = (size_t *)buffer;
57     io->bufferLeft = bufferSize - objectsSize;
58     io->offsetsLeft = maxobjects;
59     io->flag = IPC_IO_INITIALIZED;
60 }
61 
IpcIoAvailable(IpcIo * io)62 static bool IpcIoAvailable(IpcIo *io)
63 {
64     bool ret = false;
65     if (io != NULL) {
66         ret = (io->flag & IPC_IO_INITIALIZED) && !(io->flag & IPC_IO_OVERFLOW);
67     }
68     return ret;
69 }
70 
IoPush(IpcIo * io,size_t size)71 void *IoPush(IpcIo *io, size_t size)
72 {
73     IPC_IO_RETURN_IF_FAIL(io != NULL);
74     IPC_IO_RETURN_IF_FAIL(IpcIoAvailable(io));
75     size = IPC_IO_ALIGN(size);
76     if (size > io->bufferLeft) {
77         io->flag |= IPC_IO_OVERFLOW;
78         RPC_LOG_ERROR("IoPush IPC_IO_OVERFLOW.");
79         return NULL;
80     } else {
81         void *ptr = io->bufferCur;
82         io->bufferCur += size;
83         io->bufferLeft -= size;
84         return ptr;
85     }
86 }
87 
IoPop(IpcIo * io,size_t size)88 void *IoPop(IpcIo *io, size_t size)
89 {
90     IPC_IO_RETURN_IF_FAIL(io != NULL);
91     IPC_IO_RETURN_IF_FAIL(IpcIoAvailable(io));
92     size = IPC_IO_ALIGN(size);
93 
94     if (io->bufferLeft < size) {
95         io->bufferLeft = 0;
96         io->flag |= IPC_IO_OVERFLOW;
97         return NULL;
98     } else {
99         void *ptr = io->bufferCur;
100         io->bufferCur += size;
101         io->bufferLeft -= size;
102         return ptr;
103     }
104 }
105 
IoPushUnaligned(IpcIo * io,size_t size)106 static void *IoPushUnaligned(IpcIo *io, size_t size)
107 {
108     IPC_IO_RETURN_IF_FAIL(io != NULL);
109     IPC_IO_RETURN_IF_FAIL(IpcIoAvailable(io));
110     if (size > io->bufferLeft) {
111         io->flag |= IPC_IO_OVERFLOW;
112         return NULL;
113     } else {
114         void *ptr = io->bufferCur;
115         io->bufferCur += size;
116         io->bufferLeft -= size;
117         return ptr;
118     }
119 }
120 
IpcIoAppend(IpcIo * dst,IpcIo * src)121 bool IpcIoAppend(IpcIo *dst, IpcIo *src)
122 {
123     if (!IpcIoAvailable(dst) || !IpcIoAvailable(src)) {
124         RPC_LOG_ERROR("IpcIo dst or src not available: %s:%d\n", __FUNCTION__, __LINE__);
125         return false;
126     }
127     size_t srcUsedBufferSize = src->bufferCur - src->bufferBase;
128     size_t srcUsedOffsetsNum = src->offsetsCur - src->offsetsBase;
129     if (srcUsedBufferSize == 0 && srcUsedOffsetsNum != 0) {
130         RPC_LOG_ERROR("IpcIo src not available: %s:%d\n", __FUNCTION__, __LINE__);
131         return false;
132     }
133     if (dst->bufferLeft < srcUsedBufferSize || dst->offsetsLeft < srcUsedOffsetsNum) {
134         RPC_LOG_ERROR("IpcIo dst buffer space is not enough: %s:%d\n", __FUNCTION__, __LINE__);
135         return false;
136     }
137     if (srcUsedBufferSize > 0) {
138         char *ptr = (uint8_t *)IoPush(dst, srcUsedBufferSize);
139         if (ptr == NULL) {
140             return false;
141         }
142         size_t offsetAdjust = ptr - dst->bufferBase;
143         if (memset_s(ptr, IPC_IO_ALIGN(srcUsedBufferSize), 0, IPC_IO_ALIGN(srcUsedBufferSize)) != EOK) {
144             dst->flag |= IPC_IO_OVERFLOW;
145             return false;
146         }
147         if (memcpy_s(ptr, IPC_IO_ALIGN(srcUsedBufferSize), src->bufferBase, srcUsedBufferSize) != EOK) {
148             dst->flag |= IPC_IO_OVERFLOW;
149             return false;
150         }
151         for (int i = 0; i < srcUsedOffsetsNum; i++) {
152             dst->offsetsLeft--;
153             *(dst->offsetsCur) = *(src->offsetsBase + i) + offsetAdjust;
154             dst->offsetsCur++;
155         }
156     }
157     return true;
158 }
159 
WriteInt32(IpcIo * io,int32_t value)160 bool WriteInt32(IpcIo *io, int32_t value)
161 {
162     if (io == NULL) {
163         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
164         return false;
165     }
166     int32_t *ptr = (int32_t *)IoPush(io, sizeof(value));
167     if (ptr != NULL) {
168         *ptr = value;
169         return true;
170     }
171     return false;
172 }
173 
WriteUint32(IpcIo * io,uint32_t value)174 bool WriteUint32(IpcIo *io, uint32_t value)
175 {
176     if (io == NULL) {
177         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
178         return false;
179     }
180     uint32_t *ptr = (uint32_t *)IoPush(io, sizeof(value));
181     if (ptr != NULL) {
182         *ptr = value;
183         return true;
184     }
185     return false;
186 }
187 
WriteBool(IpcIo * io,bool value)188 bool WriteBool(IpcIo *io, bool value)
189 {
190     if (io == NULL) {
191         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
192         return false;
193     }
194     return WriteInt32(io, (int32_t)value);
195 }
196 
WriteBoolUnaligned(IpcIo * io,bool value)197 bool WriteBoolUnaligned(IpcIo *io, bool value)
198 {
199     if (io == NULL) {
200         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
201         return false;
202     }
203     bool *ptr = (bool *)IoPushUnaligned(io, sizeof(value));
204     if (ptr != NULL) {
205         *ptr = value;
206         return true;
207     }
208     return false;
209 }
210 
WritePointer(IpcIo * io,uintptr_t value)211 bool WritePointer(IpcIo *io, uintptr_t value)
212 {
213     if (io == NULL) {
214         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
215         return false;
216     }
217     uintptr_t *ptr = (uintptr_t *)IoPush(io, sizeof(value));
218     if (ptr != NULL) {
219         *ptr = value;
220         return true;
221     }
222     return false;
223 }
224 
WriteInt8(IpcIo * io,int8_t value)225 bool WriteInt8(IpcIo *io, int8_t value)
226 {
227     if (io == NULL) {
228         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
229         return false;
230     }
231     return WriteInt32(io, (int32_t)value);
232 }
233 
WriteInt8Unaligned(IpcIo * io,int8_t value)234 bool WriteInt8Unaligned(IpcIo *io, int8_t value)
235 {
236     if (io == NULL) {
237         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
238         return false;
239     }
240     int8_t *ptr = (int8_t *)IoPushUnaligned(io, sizeof(value));
241     if (ptr != NULL) {
242         *ptr = value;
243         return true;
244     }
245     return false;
246 }
247 
WriteUint8(IpcIo * io,uint8_t value)248 bool WriteUint8(IpcIo *io, uint8_t value)
249 {
250     if (io == NULL) {
251         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
252         return false;
253     }
254     return WriteUint32(io, (uint32_t)value);
255 }
256 
WriteUint8Unaligned(IpcIo * io,uint8_t value)257 bool WriteUint8Unaligned(IpcIo *io,  uint8_t value)
258 {
259     if (io == NULL) {
260         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
261         return false;
262     }
263     uint8_t *ptr = (uint8_t *)IoPushUnaligned(io, sizeof(value));
264     if (ptr != NULL) {
265         *ptr = value;
266         return true;
267     }
268     return false;
269 }
270 
WriteInt16(IpcIo * io,int16_t value)271 bool WriteInt16(IpcIo *io, int16_t value)
272 {
273     if (io == NULL) {
274         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
275         return false;
276     }
277     return WriteInt32(io, (int32_t)value);
278 }
279 
WriteInt16Unaligned(IpcIo * io,int16_t value)280 bool WriteInt16Unaligned(IpcIo *io, int16_t value)
281 {
282     if (io == NULL) {
283         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
284         return false;
285     }
286     int16_t *ptr = (int16_t *)IoPushUnaligned(io, sizeof(value));
287     if (ptr != NULL) {
288         *ptr = value;
289         return true;
290     }
291     return false;
292 }
293 
WriteUint16(IpcIo * io,uint16_t value)294 bool WriteUint16(IpcIo *io, uint16_t value)
295 {
296     if (io == NULL) {
297         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
298         return false;
299     }
300     return WriteUint32(io, (uint32_t)value);
301 }
302 
WriteUint16Unaligned(IpcIo * io,uint16_t value)303 bool WriteUint16Unaligned(IpcIo *io, uint16_t value)
304 {
305     if (io == NULL) {
306         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
307         return false;
308     }
309     uint16_t *ptr = (uint16_t *)IoPushUnaligned(io, sizeof(value));
310     if (ptr != NULL) {
311         *ptr = value;
312         return true;
313     }
314     return false;
315 }
316 
WriteInt64(IpcIo * io,int64_t value)317 bool WriteInt64(IpcIo *io, int64_t value)
318 {
319     if (io == NULL) {
320         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
321         return false;
322     }
323     int64_t *ptr = (int64_t *)IoPush(io, sizeof(value));
324     if (ptr != NULL) {
325         *ptr = value;
326         return true;
327     }
328     return false;
329 }
330 
WriteUint64(IpcIo * io,uint64_t value)331 bool WriteUint64(IpcIo *io, uint64_t value)
332 {
333     if (io == NULL) {
334         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
335         return false;
336     }
337     uint64_t *ptr = (uint64_t *)IoPush(io, sizeof(value));
338     if (ptr != NULL) {
339         *ptr = value;
340         return true;
341     }
342     return false;
343 }
344 
WriteFloat(IpcIo * io,float value)345 bool WriteFloat(IpcIo *io, float value)
346 {
347     if (io == NULL) {
348         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
349         return false;
350     }
351     float *ptr = (float *)IoPush(io, sizeof(value));
352     if (ptr != NULL) {
353         *ptr = value;
354         return true;
355     }
356     return false;
357 }
358 
WriteDouble(IpcIo * io,double value)359 bool WriteDouble(IpcIo *io, double value)
360 {
361     if (io == NULL) {
362         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
363         return false;
364     }
365     double *ptr = (double *)IoPush(io, sizeof(value));
366     if (ptr != NULL) {
367         *ptr = value;
368         return true;
369     }
370     return false;
371 }
372 
WriteString(IpcIo * io,const char * value)373 bool WriteString(IpcIo *io, const char *value)
374 {
375     if (io == NULL || value == NULL) {
376         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
377         return false;
378     }
379     unsigned char *str = (unsigned char *)value;
380     size_t len;
381     uint8_t *ptr = NULL;
382 
383     len = strnlen(value, MAX_IO_SIZE);
384     if (len == MAX_IO_SIZE) {
385         io->flag |= IPC_IO_OVERFLOW;
386         return false;
387     }
388     /* Note: The payload will carry 32bit size instead of size_t */
389     if (!WriteUint32(io, (uint32_t)len)) {
390         return false;
391     }
392 
393     ptr = (uint8_t *)IoPush(io, len + 1);
394     if (ptr != NULL) {
395         if (memset_s(ptr, IPC_IO_ALIGN(len + 1), 0, IPC_IO_ALIGN(len + 1)) != EOK) {
396             io->flag |= IPC_IO_OVERFLOW;
397             return false;
398         }
399         if (memcpy_s(ptr, IPC_IO_ALIGN(len + 1), str, len + 1) != EOK) {
400             io->flag |= IPC_IO_OVERFLOW;
401             return false;
402         }
403         return true;
404     }
405     return false;
406 }
407 
IoPopUnaligned(IpcIo * io,size_t size)408 static void *IoPopUnaligned(IpcIo *io, size_t size)
409 {
410     IPC_IO_RETURN_IF_FAIL(io != NULL);
411     IPC_IO_RETURN_IF_FAIL(IpcIoAvailable(io));
412 
413     if (io->bufferLeft < size) {
414         io->bufferLeft = 0;
415         io->flag |= IPC_IO_OVERFLOW;
416         return NULL;
417     } else {
418         void *ptr = io->bufferCur;
419         io->bufferCur += size;
420         io->bufferLeft -= size;
421         return ptr;
422     }
423 }
424 
ReadBool(IpcIo * io,bool * value)425 bool ReadBool(IpcIo *io, bool *value)
426 {
427     if (io == NULL || value == NULL) {
428         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
429         return false;
430     }
431     bool *ptr = (bool *)IoPop(io, sizeof(*ptr));
432     if (ptr != NULL) {
433         *value = *ptr;
434         return true;
435     }
436     return false;
437 }
438 
ReadBoolUnaligned(IpcIo * io,bool * value)439 bool ReadBoolUnaligned(IpcIo *io, bool *value)
440 {
441     if (io == NULL || value == NULL) {
442         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
443         return false;
444     }
445     bool *ptr = (bool *)IoPopUnaligned(io, sizeof(*ptr));
446     if (ptr != NULL) {
447         *value = *ptr;
448         return true;
449     }
450     return false;
451 }
452 
ReadPointer(IpcIo * io)453 uintptr_t ReadPointer(IpcIo *io)
454 {
455     if (io == NULL) {
456         RPC_LOG_ERROR("IPC io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
457         return false;
458     }
459     uintptr_t *ptr = (uintptr_t *)IoPop(io, sizeof(*ptr));
460     return ptr ? *ptr : 0;
461 }
462 
ReadInt8(IpcIo * io,int8_t * value)463 bool ReadInt8(IpcIo *io, int8_t *value)
464 {
465     if (io == NULL || value == NULL) {
466         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
467         return false;
468     }
469     int8_t *ptr = (int8_t *)IoPop(io, sizeof(*ptr));
470     if (ptr != NULL) {
471         *value = *ptr;
472         return true;
473     }
474     return false;
475 }
476 
ReadInt8Unaligned(IpcIo * io,int8_t * value)477 bool ReadInt8Unaligned(IpcIo *io, int8_t *value)
478 {
479     if (io == NULL || value == NULL) {
480         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
481         return false;
482     }
483     int8_t *ptr = (int8_t *)IoPopUnaligned(io, sizeof(*ptr));
484     if (ptr != NULL) {
485         *value = *ptr;
486         return true;
487     }
488     return false;
489 }
490 
ReadUint8(IpcIo * io,uint8_t * value)491 bool ReadUint8(IpcIo *io, uint8_t *value)
492 {
493     if (io == NULL || value == NULL) {
494         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
495         return false;
496     }
497     uint8_t *ptr = (uint8_t *)IoPop(io, sizeof(*ptr));
498     if (ptr != NULL) {
499         *value = *ptr;
500         return true;
501     }
502     return false;
503 }
504 
ReadUInt8Unaligned(IpcIo * io,uint8_t * value)505 bool ReadUInt8Unaligned(IpcIo *io, uint8_t *value)
506 {
507     if (io == NULL || value == NULL) {
508         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
509         return false;
510     }
511     uint8_t *ptr = (uint8_t*)IoPopUnaligned(io, sizeof(*ptr));
512     if (ptr != NULL) {
513         *value = *ptr;
514         return true;
515     }
516     return false;
517 }
518 
ReadInt16(IpcIo * io,int16_t * value)519 bool ReadInt16(IpcIo *io, int16_t *value)
520 {
521     if (io == NULL || value == NULL) {
522         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
523         return false;
524     }
525     int16_t *ptr = (int16_t *)IoPop(io, sizeof(*ptr));
526     if (ptr != NULL) {
527         *value = *ptr;
528         return true;
529     }
530     return false;
531 }
532 
ReadInt16Unaligned(IpcIo * io,int16_t * value)533 bool ReadInt16Unaligned(IpcIo *io, int16_t *value)
534 {
535     if (io == NULL || value == NULL) {
536         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
537         return false;
538     }
539     int16_t *ptr = (int16_t *)IoPopUnaligned(io, sizeof(*ptr));
540     if (ptr != NULL) {
541         *value = *ptr;
542         return true;
543     }
544     return false;
545 }
546 
ReadUint16(IpcIo * io,uint16_t * value)547 bool ReadUint16(IpcIo *io, uint16_t *value)
548 {
549     if (io == NULL || value == NULL) {
550         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
551         return false;
552     }
553     uint16_t *ptr = (uint16_t *)IoPop(io, sizeof(*ptr));
554     if (ptr != NULL) {
555         *value = *ptr;
556         return true;
557     }
558     return false;
559 }
560 
ReadUInt16Unaligned(IpcIo * io,uint16_t * value)561 bool ReadUInt16Unaligned(IpcIo *io, uint16_t *value)
562 {
563     if (io == NULL || value == NULL) {
564         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
565         return false;
566     }
567     uint16_t *ptr = (uint16_t *)IoPopUnaligned(io, sizeof(*ptr));
568     if (ptr != NULL) {
569         *value = *ptr;
570         return true;
571     }
572     return false;
573 }
574 
ReadInt32(IpcIo * io,int32_t * value)575 bool ReadInt32(IpcIo *io, int32_t *value)
576 {
577     if (io == NULL || value == NULL) {
578         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
579         return false;
580     }
581     int32_t *ptr = (int32_t *)IoPop(io, sizeof(*ptr));
582     if (ptr != NULL) {
583         *value = *ptr;
584         return true;
585     }
586     return false;
587 }
588 
ReadUint32(IpcIo * io,uint32_t * value)589 bool ReadUint32(IpcIo *io, uint32_t *value)
590 {
591     if (io == NULL || value == NULL) {
592         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
593         return false;
594     }
595     uint32_t *ptr = (uint32_t *)IoPop(io, sizeof(*ptr));
596     if (ptr != NULL) {
597         *value = *ptr;
598         return true;
599     }
600     return false;
601 }
602 
ReadInt64(IpcIo * io,int64_t * value)603 bool ReadInt64(IpcIo *io, int64_t *value)
604 {
605     if (io == NULL || value == NULL) {
606         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
607         return false;
608     }
609     int64_t *ptr = (int64_t *)IoPop(io, sizeof(*ptr));
610     if (ptr != NULL) {
611         *value = *ptr;
612         return true;
613     }
614     return false;
615 }
616 
ReadUint64(IpcIo * io,uint64_t * value)617 bool ReadUint64(IpcIo *io, uint64_t *value)
618 {
619     if (io == NULL || value == NULL) {
620         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
621         return false;
622     }
623     uint64_t *ptr = (uint64_t*)IoPop(io, sizeof(*ptr));
624     if (ptr != NULL) {
625         *value = *ptr;
626         return true;
627     }
628     return false;
629 }
630 
ReadFloat(IpcIo * io,float * value)631 bool ReadFloat(IpcIo *io, float *value)
632 {
633     if (io == NULL || value == NULL) {
634         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
635         return false;
636     }
637     float *ptr = (float *)IoPop(io, sizeof(*ptr));
638     if (ptr != NULL) {
639         *value = *ptr;
640         return true;
641     }
642     return false;
643 }
644 
ReadDouble(IpcIo * io,double * value)645 bool ReadDouble(IpcIo *io, double *value)
646 {
647     if (io == NULL || value == NULL) {
648         RPC_LOG_ERROR("IPC io == NULL || value == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
649         return false;
650     }
651     double *ptr = (double *)IoPop(io, sizeof(*ptr));
652     if (ptr != NULL) {
653         *value = *ptr;
654         return true;
655     }
656     return false;
657 }
658 
ReadString(IpcIo * io,size_t * len)659 uint8_t *ReadString(IpcIo *io, size_t *len)
660 {
661     if (io == NULL) {
662         RPC_LOG_ERROR("IPC io == NULL  failed: %s:%d\n", __FUNCTION__, __LINE__);
663         return NULL;
664     }
665     uint32_t value;
666     bool ret = ReadUint32(io, &value);
667     if (ret) {
668         if (value > MAX_IO_SIZE) {
669             return NULL;
670         }
671         if (len != NULL) {
672             *len = value;
673         }
674     } else {
675         RPC_LOG_ERROR("IPC ReadUint32 failed: %s:%d\n", __FUNCTION__, __LINE__);
676         return NULL;
677     }
678     return (uint8_t *)IoPop(io, value + 1);
679 }
680 
WriteBufferAddTerminator(IpcIo * io,const void * value,size_t size,size_t sizeType)681 static bool WriteBufferAddTerminator(IpcIo *io, const void *value, size_t size, size_t sizeType)
682 {
683     if (value == NULL || size < sizeType || io == NULL) {
684         RPC_LOG_ERROR("IPC value == NULL || size < sizeType || io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
685         return false;
686     }
687 
688     if (size > MAX_IO_SIZE) {
689         RPC_LOG_ERROR("IPC size > MAX_IO_SIZE failed: %s:%d\n", __FUNCTION__, __LINE__);
690         io->flag |= IPC_IO_OVERFLOW;
691         return false;
692     }
693 
694     size_t desireCapacity = IPC_IO_ALIGN(size);
695     uint8_t *ptr = (uint8_t *)IoPush(io, desireCapacity);
696     if (ptr != NULL) {
697         if (memcpy_s(ptr, desireCapacity, value, size - sizeType) != EOK) {
698             io->flag |= IPC_IO_OVERFLOW;
699             return false;
700         }
701         if (memset_s(ptr + (size - sizeType), desireCapacity - size + sizeType, 0,
702             desireCapacity - size + sizeType) != EOK) {
703             io->flag |= IPC_IO_OVERFLOW;
704             return false;
705         }
706 
707         return true;
708     }
709     return false;
710 }
711 
WriteString16(IpcIo * io,const uint16_t * value,size_t len)712 bool WriteString16(IpcIo *io, const uint16_t *value, size_t len)
713 {
714     if (io == NULL || value == NULL || len <= 0) {
715         RPC_LOG_ERROR("IPC io == NULL || value == NULL || len <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
716         return false;
717     }
718 
719     size_t typeSize = sizeof(uint16_t);
720     size_t desireCapacity = (len + 1) * typeSize;
721 
722     if (desireCapacity > MAX_IO_SIZE) {
723         io->flag |= IPC_IO_OVERFLOW;
724         RPC_LOG_ERROR("IPC desireCapacity > MAX_IO_SIZE failed: %s:%d\n", __FUNCTION__, __LINE__);
725         return false;
726     }
727 
728     /* Note: The payload will carry 32bit size instead of size_t */
729     bool ret = WriteUint32(io, (uint32_t)len);
730     if (ret) {
731         ret = WriteBufferAddTerminator(io, value, desireCapacity, typeSize);
732     }
733     return ret;
734 }
735 
WriteBuffer(IpcIo * io,const void * data,size_t size)736 bool WriteBuffer(IpcIo *io, const void *data, size_t size)
737 {
738     if (data == NULL || size <= 0 || io == NULL) {
739         RPC_LOG_ERROR("IPC data == NULL || size <= 0 || io == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
740         return false;
741     }
742 
743     if (size > MAX_IO_SIZE) {
744         RPC_LOG_ERROR("IPC size > MAX_IO_SIZE failed: %s:%d\n", __FUNCTION__, __LINE__);
745         io->flag |= IPC_IO_OVERFLOW;
746         return false;
747     }
748 
749     size_t desireCapacity = IPC_IO_ALIGN(size);
750     uint8_t *ptr = (uint8_t *)IoPush(io, desireCapacity);
751     if (ptr != NULL) {
752         if (memcpy_s(ptr, desireCapacity, data, size) != EOK) {
753             io->flag |= IPC_IO_OVERFLOW;
754             return false;
755         }
756         if (memset_s(ptr + size, desireCapacity - size, 0, desireCapacity - size) != EOK) {
757             io->flag |= IPC_IO_OVERFLOW;
758             return false;
759         }
760 
761         return true;
762     }
763     return false;
764 }
765 
WriteInterfaceToken(IpcIo * io,const uint16_t * name,size_t len)766 bool WriteInterfaceToken(IpcIo *io, const uint16_t *name, size_t len)
767 {
768     if (io == NULL || name == NULL || len <= 0) {
769         RPC_LOG_ERROR("IPC io == NULL || name == NULL || len <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
770         return false;
771     }
772 
773     size_t typeSize = sizeof(uint16_t);
774     size_t desireCapacity = (len + 1) * typeSize;
775 
776     if (desireCapacity > MAX_IO_SIZE) {
777         io->flag |= IPC_IO_OVERFLOW;
778         RPC_LOG_ERROR("IPC desireCapacity > MAX_IO_SIZE failed: %s:%d\n", __FUNCTION__, __LINE__);
779         return false;
780     }
781 
782     return  WriteString16(io, name, len);
783 }
784 
WriteRawData(IpcIo * io,const void * data,size_t size)785 bool WriteRawData(IpcIo *io, const void *data, size_t size)
786 {
787     if (io == NULL || data == NULL || size <= 0) {
788         RPC_LOG_ERROR("IPC io == NULL || data == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
789         return false;
790     }
791 
792     if (size > MAX_IO_SIZE) {
793         io->flag |= IPC_IO_OVERFLOW;
794         RPC_LOG_ERROR("IPC size > MAX_IO_SIZE failed: %s:%d\n", __FUNCTION__, __LINE__);
795         return false;
796     }
797 
798     bool ret = WriteUint32(io, (uint32_t)size);
799     if (ret) {
800         ret = WriteBuffer(io, data, size);
801     }
802     return ret;
803 }
804 
WriteBoolVector(IpcIo * io,const bool * val,size_t size)805 bool WriteBoolVector(IpcIo *io, const bool *val, size_t size)
806 {
807     if (io == NULL || val == NULL || size <= 0) {
808         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
809         return false;
810     }
811 
812     bool ret = WriteUint32(io, (uint32_t)size);
813     if (ret) {
814         for (int32_t i = 0; i != size; i++) {
815             ret = WriteBool(io, val[i]);
816             if (!ret) {
817                 return false;
818             }
819         }
820         return true;
821     }
822     return false;
823 }
824 
WriteInt8Vector(IpcIo * io,const int8_t * val,size_t size)825 bool WriteInt8Vector(IpcIo *io, const int8_t *val, size_t size)
826 {
827     if (io == NULL || val == NULL || size <= 0) {
828         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
829         return false;
830     }
831 
832     bool ret = WriteUint32(io, (uint32_t)size);
833     if (ret) {
834         size_t desireCapacity = size * sizeof(int8_t);
835         int8_t *ptr = (int8_t *)IoPushUnaligned(io, desireCapacity);
836         if (ptr == NULL) {
837             return false;
838         }
839 
840         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
841             io->flag |= IPC_IO_OVERFLOW;
842             return false;
843         }
844         return true;
845     }
846     return false;
847 }
848 
WriteInt16Vector(IpcIo * io,const int16_t * val,size_t size)849 bool WriteInt16Vector(IpcIo *io, const int16_t *val, size_t size)
850 {
851     if (io == NULL || val == NULL || size <= 0) {
852         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
853         return false;
854     }
855 
856     bool ret = WriteUint32(io, (uint32_t)size);
857     if (ret) {
858         for (int32_t i = 0; i != size; i++) {
859             ret = WriteInt16(io, val[i]);
860             if (!ret) {
861                 return false;
862             }
863         }
864         return true;
865     }
866     return false;
867 }
868 
WriteInt32Vector(IpcIo * io,const int32_t * val,size_t size)869 bool WriteInt32Vector(IpcIo *io, const int32_t *val, size_t size)
870 {
871     if (io == NULL || val == NULL || size <= 0) {
872         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
873         return false;
874     }
875 
876     bool ret = WriteUint32(io, (uint32_t)size);
877     if (ret) {
878         size_t desireCapacity = size * sizeof(int32_t);
879         int32_t *ptr = (int32_t *)IoPushUnaligned(io, desireCapacity);
880         if (ptr == NULL) {
881             return false;
882         }
883 
884         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
885             io->flag |= IPC_IO_OVERFLOW;
886             return false;
887         }
888         return true;
889     }
890     return false;
891 }
892 
WriteInt64Vector(IpcIo * io,const int64_t * val,size_t size)893 bool WriteInt64Vector(IpcIo *io, const int64_t *val, size_t size)
894 {
895     if (io == NULL || val == NULL || size <= 0) {
896         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
897         return false;
898     }
899 
900     bool ret = WriteUint32(io, (uint32_t)size);
901     if (ret) {
902         size_t desireCapacity = size * sizeof(int64_t);
903         int64_t *ptr = (int64_t *)IoPushUnaligned(io, desireCapacity);
904         if (ptr == NULL) {
905             return false;
906         }
907 
908         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
909             io->flag |= IPC_IO_OVERFLOW;
910             return false;
911         }
912         return true;
913     }
914     return false;
915 }
916 
WriteUInt8Vector(IpcIo * io,const uint8_t * val,size_t size)917 bool WriteUInt8Vector(IpcIo *io, const uint8_t *val, size_t size)
918 {
919     if (io == NULL || val == NULL || size <= 0) {
920         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
921         return false;
922     }
923 
924     bool ret = WriteUint32(io, (uint32_t)size);
925     if (ret) {
926         size_t desireCapacity = size * sizeof(uint8_t);
927         uint8_t *ptr = (uint8_t *)IoPushUnaligned(io, desireCapacity);
928         if (ptr == NULL) {
929             return false;
930         }
931 
932         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
933             io->flag |= IPC_IO_OVERFLOW;
934             return false;
935         }
936         return true;
937     }
938     return false;
939 }
940 
WriteUInt16Vector(IpcIo * io,const uint16_t * val,size_t size)941 bool WriteUInt16Vector(IpcIo *io, const uint16_t *val, size_t size)
942 {
943     if (io == NULL || val == NULL || size <= 0) {
944         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
945         return false;
946     }
947 
948     bool ret = WriteUint32(io, (uint32_t)size);
949     if (ret) {
950         size_t desireCapacity = size * sizeof(uint16_t);
951         uint16_t *ptr = (uint16_t *)IoPushUnaligned(io, desireCapacity);
952         if (ptr == NULL) {
953             return false;
954         }
955 
956         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
957             io->flag |= IPC_IO_OVERFLOW;
958             return false;
959         }
960         return true;
961     }
962     return false;
963 }
964 
WriteUInt32Vector(IpcIo * io,const uint32_t * val,size_t size)965 bool WriteUInt32Vector(IpcIo *io, const uint32_t *val, size_t size)
966 {
967     if (io == NULL || val == NULL || size <= 0) {
968         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
969         return false;
970     }
971 
972     bool ret = WriteUint32(io, (uint32_t)size);
973     if (ret) {
974         size_t desireCapacity = size * sizeof(uint32_t);
975         uint32_t *ptr = (uint32_t *)IoPushUnaligned(io, desireCapacity);
976         if (ptr == NULL) {
977             return false;
978         }
979 
980         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
981             io->flag |= IPC_IO_OVERFLOW;
982             return false;
983         }
984         return true;
985     }
986     return false;
987 }
988 
WriteUInt64Vector(IpcIo * io,const uint64_t * val,size_t size)989 bool WriteUInt64Vector(IpcIo *io, const uint64_t *val, size_t size)
990 {
991     if (io == NULL || val == NULL || size <= 0) {
992         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
993         return false;
994     }
995 
996     bool ret = WriteUint32(io, (uint32_t)size);
997     if (ret) {
998         size_t desireCapacity = size * sizeof(uint64_t);
999         uint64_t *ptr = (uint64_t *)IoPushUnaligned(io, desireCapacity);
1000         if (ptr == NULL) {
1001             return false;
1002         }
1003 
1004         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
1005             io->flag |= IPC_IO_OVERFLOW;
1006             return false;
1007         }
1008         return true;
1009     }
1010     return false;
1011 }
1012 
WriteFloatVector(IpcIo * io,const float * val,size_t size)1013 bool WriteFloatVector(IpcIo *io, const float *val, size_t size)
1014 {
1015     if (io == NULL || val == NULL || size <= 0) {
1016         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
1017         return false;
1018     }
1019 
1020     bool ret = WriteUint32(io, (uint32_t)size);
1021     if (ret) {
1022         size_t desireCapacity = size * sizeof(float);
1023         float *ptr = (float *)IoPushUnaligned(io, desireCapacity);
1024         if (ptr == NULL) {
1025             return false;
1026         }
1027 
1028         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
1029             io->flag |= IPC_IO_OVERFLOW;
1030             return false;
1031         }
1032         return true;
1033     }
1034     return false;
1035 }
1036 
WriteDoubleVector(IpcIo * io,const double * val,size_t size)1037 bool WriteDoubleVector(IpcIo *io, const double *val, size_t size)
1038 {
1039     if (io == NULL || val == NULL || size <= 0) {
1040         RPC_LOG_ERROR("IPC io == NULL || val == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
1041         return false;
1042     }
1043 
1044     bool ret = WriteUint32(io, (uint32_t)size);
1045     if (ret) {
1046         size_t desireCapacity = size * sizeof(double);
1047         double *ptr = (double *)IoPushUnaligned(io, desireCapacity);
1048         if (ptr == NULL) {
1049             return false;
1050         }
1051 
1052         if (memcpy_s(ptr, desireCapacity, val, desireCapacity) != EOK) {
1053             io->flag |= IPC_IO_OVERFLOW;
1054             return false;
1055         }
1056         return true;
1057     }
1058     return false;
1059 }
1060 
ReadString16(IpcIo * io,size_t * len)1061 uint16_t *ReadString16(IpcIo *io, size_t *len)
1062 {
1063     if (io == NULL || len == NULL) {
1064         RPC_LOG_ERROR("IPC io == NULL || len == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1065         return NULL;
1066     }
1067     bool ret = ReadUint32(io, (uint32_t *)len);
1068     if (!ret) {
1069         return NULL;
1070     }
1071 
1072     size_t readCapacity = (*len + 1) * sizeof(uint16_t);
1073     uint16_t *ptr = (uint16_t *)IoPop(io, readCapacity);
1074     if (ptr[*len] == 0) {
1075         return ptr;
1076     } else {
1077         return NULL;
1078     }
1079 }
1080 
ReadInterfaceToken(IpcIo * io,size_t * len)1081 uint16_t *ReadInterfaceToken(IpcIo *io, size_t *len)
1082 {
1083     if (io == NULL || len == NULL) {
1084         RPC_LOG_ERROR("IPC io == NULL || len == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1085         return NULL;
1086     }
1087     bool ret = ReadUint32(io, (uint32_t *)len);
1088     if (!ret) {
1089         return NULL;
1090     }
1091 
1092     size_t readCapacity = (*len + 1) * sizeof(uint16_t);
1093     uint16_t *ptr = (uint16_t *)IoPop(io, readCapacity);
1094     if (ptr != NULL && ptr[*len] == 0) {
1095         return ptr;
1096     } else {
1097         return NULL;
1098     }
1099 }
1100 
ReadBuffer(IpcIo * io,size_t size)1101 const uint8_t *ReadBuffer(IpcIo *io, size_t size)
1102 {
1103     if (io == NULL || size <= 0) {
1104         RPC_LOG_ERROR("IPC io == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
1105         return NULL;
1106     }
1107     return (uint8_t *)IoPop(io, size);
1108 }
1109 
ReadRawData(IpcIo * io,size_t size)1110 void *ReadRawData(IpcIo *io, size_t size)
1111 {
1112     if (io == NULL || size <= 0) {
1113         RPC_LOG_ERROR("IPC io == NULL || size <= 0 failed: %s:%d\n", __FUNCTION__, __LINE__);
1114         return NULL;
1115     }
1116     uint32_t len = 0;
1117     ReadUint32(io, &len);
1118     if (len != (uint32_t)size) {
1119         return NULL;
1120     }
1121     return (void *)ReadBuffer(io, (size_t)len);
1122 }
1123 
ReadBoolVector(IpcIo * io,size_t * size)1124 bool *ReadBoolVector(IpcIo *io, size_t *size)
1125 {
1126     if (io == NULL || size == NULL) {
1127         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1128         return NULL;
1129     }
1130 
1131     bool ret = ReadUint32(io, (uint32_t *)size);
1132     if (!ret) {
1133         return NULL;
1134     }
1135 
1136     bool *val = (bool *)malloc((*size) * sizeof(bool));
1137     if (val == NULL) {
1138         RPC_LOG_ERROR("IPC malloc failed: %s:%d\n", __FUNCTION__, __LINE__);
1139         return NULL;
1140     }
1141 
1142     int32_t *ptr = NULL;
1143     for (int32_t i = 0; i != *size; i++) {
1144         ptr = (int32_t *)IoPop(io, sizeof(int32_t));
1145         if (ptr == NULL) {
1146             free(val);
1147             return NULL;
1148         }
1149         val[i] = (bool)(*ptr);
1150     }
1151     return val;
1152 }
1153 
ReadInt8Vector(IpcIo * io,size_t * size)1154 int8_t *ReadInt8Vector(IpcIo *io, size_t *size)
1155 {
1156     if (io == NULL || size == NULL) {
1157         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1158         return NULL;
1159     }
1160     bool ret = ReadUint32(io, (uint32_t *)size);
1161     if (!ret) {
1162         return NULL;
1163     }
1164 
1165     size_t readCapacity = *size * sizeof(int8_t);
1166     int8_t *ptr = (int8_t *)IoPopUnaligned(io, readCapacity);
1167     if (ptr == NULL) {
1168         return NULL;
1169     }
1170 
1171     return ptr;
1172 }
1173 
ReadInt16Vector(IpcIo * io,size_t * size)1174 int16_t *ReadInt16Vector(IpcIo *io, size_t *size)
1175 {
1176     if (io == NULL || size == NULL) {
1177         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1178         return NULL;
1179     }
1180     bool ret = ReadUint32(io, (uint32_t *)size);
1181     if (!ret) {
1182         return NULL;
1183     }
1184 
1185     int16_t *val = (int16_t *)calloc(1, (*size) * sizeof(int16_t));
1186     if (val == NULL) {
1187         RPC_LOG_ERROR("IPC  malloc failed: %s:%d\n", __FUNCTION__, __LINE__);
1188         return NULL;
1189     }
1190     int32_t *ptr = NULL;
1191     for (int32_t i = 0; i != *size; i++) {
1192         ptr = (int32_t *)IoPop(io, sizeof(int32_t));
1193         if (ptr == NULL) {
1194             free(val);
1195             return NULL;
1196         }
1197         val[i] = (int16_t)(*ptr);
1198     }
1199     return val;
1200 }
1201 
ReadInt32Vector(IpcIo * io,size_t * size)1202 int32_t *ReadInt32Vector(IpcIo *io, size_t *size)
1203 {
1204     if (io == NULL || size == NULL) {
1205         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1206         return NULL;
1207     }
1208     bool ret = ReadUint32(io, (uint32_t *)size);
1209     if (!ret) {
1210         return NULL;
1211     }
1212 
1213     size_t readCapacity = *size * sizeof(int32_t);
1214     int32_t *ptr = (int32_t *)IoPopUnaligned(io, readCapacity);
1215     if (ptr == NULL) {
1216         return NULL;
1217     }
1218 
1219     return ptr;
1220 }
1221 
ReadInt64Vector(IpcIo * io,size_t * size)1222 int64_t *ReadInt64Vector(IpcIo *io, size_t *size)
1223 {
1224     if (io == NULL || size == NULL) {
1225         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1226         return NULL;
1227     }
1228     bool ret = ReadUint32(io, (uint32_t *)size);
1229     if (!ret) {
1230         return NULL;
1231     }
1232 
1233     size_t readCapacity = *size * sizeof(int64_t);
1234     int64_t *ptr = (int64_t *)IoPopUnaligned(io, readCapacity);
1235     if (ptr == NULL) {
1236         return NULL;
1237     }
1238 
1239     return ptr;
1240 }
1241 
ReadUInt8Vector(IpcIo * io,size_t * size)1242 uint8_t *ReadUInt8Vector(IpcIo *io, size_t *size)
1243 {
1244     if (io == NULL || size == NULL) {
1245         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1246         return NULL;
1247     }
1248     bool ret = ReadUint32(io, (uint32_t *)size);
1249     if (!ret) {
1250         return NULL;
1251     }
1252 
1253     size_t readCapacity = *size * sizeof(uint8_t);
1254     uint8_t *ptr = (uint8_t *)IoPopUnaligned(io, readCapacity);
1255     if (ptr == NULL) {
1256         return NULL;
1257     }
1258 
1259     return ptr;
1260 }
1261 
ReadUInt16Vector(IpcIo * io,size_t * size)1262 uint16_t *ReadUInt16Vector(IpcIo *io, size_t *size)
1263 {
1264     if (io == NULL || size == NULL) {
1265         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1266         return NULL;
1267     }
1268     bool ret = ReadUint32(io, (uint32_t *)size);
1269     if (!ret) {
1270         return NULL;
1271     }
1272 
1273     size_t readCapacity = *size * sizeof(uint16_t);
1274     uint16_t *ptr = (uint16_t *)IoPopUnaligned(io, readCapacity);
1275     if (ptr == NULL) {
1276         return NULL;
1277     }
1278 
1279     return ptr;
1280 }
1281 
ReadUInt32Vector(IpcIo * io,size_t * size)1282 uint32_t *ReadUInt32Vector(IpcIo *io, size_t *size)
1283 {
1284     if (io == NULL || size == NULL) {
1285         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1286         return NULL;
1287     }
1288     bool ret = ReadUint32(io, (uint32_t *)size);
1289     if (!ret) {
1290         return NULL;
1291     }
1292 
1293     size_t readCapacity = *size * sizeof(uint32_t);
1294     uint32_t *ptr = (uint32_t *)IoPopUnaligned(io, readCapacity);
1295     if (ptr == NULL) {
1296         return NULL;
1297     }
1298 
1299     return ptr;
1300 }
1301 
ReadUInt64Vector(IpcIo * io,size_t * size)1302 uint64_t *ReadUInt64Vector(IpcIo *io, size_t *size)
1303 {
1304     if (io == NULL || size == NULL) {
1305         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1306         return NULL;
1307     }
1308     bool ret = ReadUint32(io, (uint32_t *)size);
1309     if (!ret) {
1310         return NULL;
1311     }
1312 
1313     size_t readCapacity = *size * sizeof(uint64_t);
1314     uint64_t *ptr = (uint64_t *)IoPopUnaligned(io, readCapacity);
1315     if (ptr == NULL) {
1316         return NULL;
1317     }
1318 
1319     return ptr;
1320 }
1321 
ReadFloatVector(IpcIo * io,size_t * size)1322 float *ReadFloatVector(IpcIo *io, size_t *size)
1323 {
1324     if (io == NULL || size == NULL) {
1325         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1326         return NULL;
1327     }
1328     bool ret = ReadUint32(io, (uint32_t *)size);
1329     if (!ret) {
1330         return NULL;
1331     }
1332 
1333     size_t readCapacity = *size * sizeof(float);
1334     float *ptr = (float *)IoPopUnaligned(io, readCapacity);
1335     if (ptr == NULL) {
1336         return NULL;
1337     }
1338 
1339     return ptr;
1340 }
1341 
ReadDoubleVector(IpcIo * io,size_t * size)1342 double *ReadDoubleVector(IpcIo *io, size_t *size)
1343 {
1344     if (io == NULL || size == NULL) {
1345         RPC_LOG_ERROR("IPC io == NULL || size == NULL failed: %s:%d\n", __FUNCTION__, __LINE__);
1346         return NULL;
1347     }
1348     bool ret = ReadUint32(io, (uint32_t *)size);
1349     if (!ret) {
1350         return NULL;
1351     }
1352 
1353     size_t readCapacity = *size * sizeof(double);
1354     double *ptr = (double *)IoPopUnaligned(io, readCapacity);
1355     if (ptr == NULL) {
1356         return NULL;
1357     }
1358 
1359     return ptr;
1360 }
1361