le_pack.h

1 /**
2  * @page c_pack Low-level Pack/Unpack API
3  *
4  * @ref le_pack.h "API Reference"
5  *
6  * <HR>
7  *
8  * This low-level pack/unpack API is intended to support the higher level
9  * IPC messaging system, specifically code generated by ifgen. But it
10  * can also be used to hand-pack messages if using the @ref c_messaging
11  * API directly.
12  *
13  * This low-level pack/unpack API supports:
14  * - Packing basic types supported by the IPC system.
15  * - Packing reference types
16  * - Packing arrays of the above types
17  * - Packing strings.
18  * It also supports unpacking any of the above.
19  */
20 
21 #ifndef LE_PACK_H_INCLUDE_GUARD
22 #define LE_PACK_H_INCLUDE_GUARD
23 
24 //--------------------------------------------------------------------------------------------------
25 // Pack functions
26 //--------------------------------------------------------------------------------------------------
27 
28 // Packing a simple value is basically the same regardless of type. But don't use this macro
29 // directly to get better verification that we're only packing the types we expect
30 #define LE_PACK_PACK_SIMPLE_VALUE(value) \
31  if (*sizePtr < sizeof(value)) \
32  { \
33  return false; \
34  } \
35  \
36  memcpy(*bufferPtr, &(value), sizeof(value)); \
37  \
38  *bufferPtr = *bufferPtr + sizeof(value); \
39  *sizePtr -= sizeof(value); \
40  \
41  return true
42 
43 
44 //--------------------------------------------------------------------------------------------------
45 /**
46  * Pack a uint8_t into a buffer, incrementing the buffer pointer and decrementing the
47  * available size, as appropriate.
48  *
49  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
50  * size is known at compile time.
51  */
52 //--------------------------------------------------------------------------------------------------
53 static inline bool le_pack_PackUint8
54 (
55  uint8_t** bufferPtr,
56  size_t* sizePtr,
57  uint8_t value
58 )
59 {
60  LE_PACK_PACK_SIMPLE_VALUE(value);
61 }
62 
63 //--------------------------------------------------------------------------------------------------
64 /**
65  * Pack a uint16_t into a buffer, incrementing the buffer pointer and decrementing the
66  * available size, as appropriate.
67  *
68  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
69  * size is known at compile time.
70  */
71 //--------------------------------------------------------------------------------------------------
72 static inline bool le_pack_PackUint16
73 (
74  uint8_t** bufferPtr,
75  size_t* sizePtr,
76  uint16_t value
77 )
78 {
79  LE_PACK_PACK_SIMPLE_VALUE(value);
80 }
81 
82 //--------------------------------------------------------------------------------------------------
83 /**
84  * Pack a uint32_t into a buffer, incrementing the buffer pointer and decrementing the
85  * available size, as appropriate.
86  *
87  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
88  * size is known at compile time.
89  */
90 //--------------------------------------------------------------------------------------------------
91 static inline bool le_pack_PackUint32
92 (
93  uint8_t** bufferPtr,
94  size_t* sizePtr,
95  uint32_t value
96 )
97 {
98  LE_PACK_PACK_SIMPLE_VALUE(value);
99 }
100 
101 //--------------------------------------------------------------------------------------------------
102 /**
103  * Pack a uint64_t into a buffer, incrementing the buffer pointer and decrementing the
104  * available size, as appropriate.
105  *
106  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
107  * size is known at compile time.
108  */
109 //--------------------------------------------------------------------------------------------------
110 static inline bool le_pack_PackUint64
111 (
112  uint8_t** bufferPtr,
113  size_t* sizePtr,
114  uint64_t value
115 )
116 {
117  LE_PACK_PACK_SIMPLE_VALUE(value);
118 }
119 
120 //--------------------------------------------------------------------------------------------------
121 /**
122  * Pack a int8_t into a buffer, incrementing the buffer pointer and decrementing the
123  * available size, as appropriate.
124  *
125  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
126  * size is known at compile time.
127  */
128 //--------------------------------------------------------------------------------------------------
129 static inline bool le_pack_PackInt8
130 (
131  uint8_t** bufferPtr,
132  size_t* sizePtr,
133  int8_t value
134 )
135 {
136  LE_PACK_PACK_SIMPLE_VALUE(value);
137 }
138 
139 //--------------------------------------------------------------------------------------------------
140 /**
141  * Pack a int16_t into a buffer, incrementing the buffer pointer and decrementing the
142  * available size, as appropriate.
143  *
144  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
145  * size is known at compile time.
146  */
147 //--------------------------------------------------------------------------------------------------
148 static inline bool le_pack_PackInt16
149 (
150  uint8_t** bufferPtr,
151  size_t* sizePtr,
152  int16_t value
153 )
154 {
155  LE_PACK_PACK_SIMPLE_VALUE(value);
156 }
157 
158 //--------------------------------------------------------------------------------------------------
159 /**
160  * Pack a int32_t into a buffer, incrementing the buffer pointer and decrementing the
161  * available size, as appropriate.
162  *
163  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
164  * size is known at compile time.
165  */
166 //--------------------------------------------------------------------------------------------------
167 static inline bool le_pack_PackInt32
168 (
169  uint8_t** bufferPtr,
170  size_t* sizePtr,
171  int32_t value
172 )
173 {
174  LE_PACK_PACK_SIMPLE_VALUE(value);
175 }
176 
177 //--------------------------------------------------------------------------------------------------
178 /**
179  * Pack a int64_t into a buffer, incrementing the buffer pointer and decrementing the
180  * available size, as appropriate.
181  *
182  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
183  * size is known at compile time.
184  */
185 //--------------------------------------------------------------------------------------------------
186 static inline bool le_pack_PackInt64
187 (
188  uint8_t** bufferPtr,
189  size_t* sizePtr,
190  int64_t value
191 )
192 {
193  LE_PACK_PACK_SIMPLE_VALUE(value);
194 }
195 
196 //--------------------------------------------------------------------------------------------------
197 /**
198  * Pack a size_t into a buffer, incrementing the buffer pointer and decrementing the
199  * available size, as appropriate.
200  *
201  * @note Packed sizes are limited to 2^32-1, regardless of platform
202  */
203 //--------------------------------------------------------------------------------------------------
204 static inline bool le_pack_PackSize
205 (
206  uint8_t **bufferPtr,
207  size_t *sizePtr,
208  size_t value
209 )
210 {
211  if (value > UINT32_MAX)
212  {
213  return false;
214  }
215 
216  return le_pack_PackUint32(bufferPtr, sizePtr, value);
217 }
218 
219 //--------------------------------------------------------------------------------------------------
220 /**
221  * Pack a bool into a buffer, incrementing the buffer pointer and decrementing the
222  * available size, as appropriate.
223  *
224  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
225  * size is known at compile time.
226  */
227 //--------------------------------------------------------------------------------------------------
228 static inline bool le_pack_PackBool
229 (
230  uint8_t** bufferPtr,
231  size_t* sizePtr,
232  bool value
233 )
234 {
235  // Force boolean to uint8_t 0 or 1 for packing, regarldess of underlying OS type.
236  // Underlying type has been int on some platforms in the past.
237  uint8_t simpleValue = ((value)?1:0);
238  LE_PACK_PACK_SIMPLE_VALUE(simpleValue);
239 }
240 
241 //--------------------------------------------------------------------------------------------------
242 /**
243  * Pack a char into a buffer, incrementing the buffer pointer and decrementing the
244  * available size, as appropriate.
245  *
246  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
247  * size is known at compile time.
248  */
249 //--------------------------------------------------------------------------------------------------
250 static inline bool le_pack_PackChar
251 (
252  uint8_t** bufferPtr,
253  size_t* sizePtr,
254  char value
255 )
256 {
257  LE_PACK_PACK_SIMPLE_VALUE(value);
258 }
259 
260 //--------------------------------------------------------------------------------------------------
261 /**
262  * Pack a double into a buffer, incrementing the buffer pointer and decrementing the
263  * available size, as appropriate.
264  *
265  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
266  * size is known at compile time.
267  */
268 //--------------------------------------------------------------------------------------------------
269 static inline bool le_pack_PackDouble
270 (
271  uint8_t** bufferPtr,
272  size_t* sizePtr,
273  double value
274 )
275 {
276  LE_PACK_PACK_SIMPLE_VALUE(value);
277 }
278 
279 //--------------------------------------------------------------------------------------------------
280 /**
281  * Pack a le_result_t into a buffer, incrementing the buffer pointer and decrementing the
282  * available size, as appropriate.
283  *
284  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
285  * size is known at compile time.
286  */
287 //--------------------------------------------------------------------------------------------------
288 static inline bool le_pack_PackResult
289 (
290  uint8_t** bufferPtr,
291  size_t* sizePtr,
292  le_result_t value
293 )
294 {
295  LE_PACK_PACK_SIMPLE_VALUE(value);
296 }
297 
298 //--------------------------------------------------------------------------------------------------
299 /**
300  * Pack le_onoff_t into a buffer, incrementing the buffer pointer and decrementing the
301  * available size, as appropriate.
302  *
303  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
304  * size is known at compile time.
305  */
306 //--------------------------------------------------------------------------------------------------
307 static inline bool le_pack_PackOnOff
308 (
309  uint8_t** bufferPtr,
310  size_t* sizePtr,
311  le_onoff_t value
312 )
313 {
314  LE_PACK_PACK_SIMPLE_VALUE(value);
315 }
316 
317 #undef LE_PACK_PACK_SIMPLE_VALUE
318 
319 //--------------------------------------------------------------------------------------------------
320 /**
321  * Pack a reference into a buffer, incrementing the buffer pointer and decrementing the available
322  * size.
323  */
324 //--------------------------------------------------------------------------------------------------
325 static inline bool le_pack_PackReference
326 (
327  uint8_t** bufferPtr,
328  size_t* sizePtr,
329  const void* ref
330 )
331 {
332  size_t refAsInt = (size_t)ref;
333 
334  // All references passed through an API must be safe references (or NULL), so
335  // 0-bit will be set and reference will be <= UINT32_MAX. Size check
336  // is performed in pack function.
337  if ((refAsInt <= UINT32_MAX) &&
338  ((refAsInt & 0x01) ||
339  !refAsInt))
340  {
341  return le_pack_PackUint32(bufferPtr, sizePtr, (uint32_t)refAsInt);
342  }
343  else
344  {
345  return false;
346  }
347 }
348 
349 //--------------------------------------------------------------------------------------------------
350 /**
351  * Pack a string into a buffer, incrementing the buffer pointer and decrementing the available
352  * size.
353  *
354  * @note Always decrements available size according to the max possible size used, not actual size
355  * used. Will assert if provided string is larger than maximum allowable string.
356  */
357 //--------------------------------------------------------------------------------------------------
358 static inline bool le_pack_PackString
359 (
360  uint8_t** bufferPtr,
361  size_t* sizePtr,
362  const char *stringPtr,
363  uint32_t maxStringCount
364 )
365 {
366  size_t bytesCopied;
367 
368  if (*sizePtr < (maxStringCount + sizeof(uint32_t)))
369  {
370  return false;
371  }
372 
373  if (!stringPtr)
374  {
375  return false;
376  }
377 
378 #if defined(__KLOCWORK__)
379  // Just like strncpy & strnlen, this function doesn't know the size of the source string,
380  // which can potentially result in a read overflow on the input buffer.
381  // Static code analyzer can report this issue, which is deliberatly ignored since this
382  // function expects NULL-terminated strings.
383  maxStringCount = strnlen(stringPtr, maxStringCount);
384 #endif
385 
386  // First copy in the string -- up to maxStringCount bytes, allowing enough
387  // space at the begining for a uint32.
388  for (bytesCopied = 0;
389  (bytesCopied < maxStringCount) && (stringPtr[bytesCopied] != '\0');
390  ++bytesCopied)
391  {
392  (*bufferPtr)[bytesCopied + sizeof(uint32_t)] = stringPtr[bytesCopied];
393  }
394 
395  // String was too long to fit in the buffer -- return false.
396  if (stringPtr[bytesCopied] != '\0')
397  {
398  return false;
399  }
400 
401  // Then go back and copy string size. No loss of precision packing into a uint32
402  // because maxStringCount is a uint32 or less.
403  bool packResult = le_pack_PackUint32(bufferPtr, sizePtr, bytesCopied);
404  LE_ASSERT(packResult); // Should not fail -- have checked there's enough space above.
405 
406  // Now increment buffer by size of string actually copied, and decrement available
407  // space by max which could have been copied. This ensures out of space errors will
408  // be caught as soon as possible.
409  *bufferPtr = *bufferPtr + bytesCopied;
410  *sizePtr -= maxStringCount;
411 
412  return true;
413 }
414 
415 //--------------------------------------------------------------------------------------------------
416 /**
417  * Pack the size information for an array into a buffer, incrementing the buffer pointer and
418  * decrementing the available size.
419  *
420  * @note Users of this API should generally use LE_PACK_PACKARRAY macro instead which also
421  * packs the array data.
422  */
423 //--------------------------------------------------------------------------------------------------
424 static inline bool le_pack_PackArrayHeader
425 (
426  uint8_t **bufferPtr,
427  size_t *sizePtr,
428  const void *arrayPtr,
429  size_t elementSize,
430  size_t arrayCount,
431  size_t arrayMaxCount
432 )
433 {
434  if ((*sizePtr < arrayMaxCount*elementSize + sizeof(uint32_t)) ||
435  (arrayCount > arrayMaxCount))
436  {
437  return false;
438  }
439 
440  LE_ASSERT(le_pack_PackSize(bufferPtr, sizePtr, arrayCount));
441 
442  return true;
443 }
444 
445 //--------------------------------------------------------------------------------------------------
446 /**
447  * Pack an array into a buffer, incrementing the buffer pointer and decrementing the available
448  * size.
449  *
450  * @note Always decrements available size according to the max possible size used, not actual size
451  * used. Will assert if provided string is larger than maximum allowable string.
452  */
453 //--------------------------------------------------------------------------------------------------
454 #define LE_PACK_PACKARRAY(bufferPtr, \
455  sizePtr, \
456  arrayPtr, \
457  arrayCount, \
458  arrayMaxCount, \
459  packFunc, \
460  resultPtr) \
461  do { \
462  *(resultPtr) = le_pack_PackArrayHeader((bufferPtr), (sizePtr), \
463  (arrayPtr), sizeof((arrayPtr)[0]), \
464  (arrayCount), (arrayMaxCount)); \
465  if (*(resultPtr)) \
466  { \
467  uint32_t i; \
468  size_t newSizePtr = *(sizePtr) - sizeof((arrayPtr)[0])*(arrayMaxCount); \
469  for (i = 0; i < (arrayCount); ++i) \
470  { \
471  LE_ASSERT(packFunc((bufferPtr), (sizePtr), (arrayPtr)[i])); \
472  } \
473  LE_ASSERT(*(sizePtr) >= newSizePtr); \
474  *(sizePtr) = newSizePtr; \
475  *(resultPtr) = true; \
476  } \
477  } while (0)
478 
479 //--------------------------------------------------------------------------------------------------
480 // Unpack functions
481 //--------------------------------------------------------------------------------------------------
482 
483 #define LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr) \
484  if (*sizePtr < sizeof(*(valuePtr))) \
485  { \
486  return false; \
487  } \
488  \
489  memcpy((valuePtr), *bufferPtr, sizeof(*(valuePtr))); \
490  \
491  *bufferPtr = (*bufferPtr) + sizeof(*(valuePtr)); \
492  *sizePtr -= sizeof(*(valuePtr)); \
493  \
494  return true
495 
496 //--------------------------------------------------------------------------------------------------
497 /**
498  * Unpack a uint8_t from a buffer, incrementing the buffer pointer and decrementing the
499  * available size, as appropriate.
500  *
501  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
502  * size is known at compile time.
503  */
504 //--------------------------------------------------------------------------------------------------
505 static inline bool le_pack_UnpackUint8
506 (
507  uint8_t** bufferPtr,
508  size_t* sizePtr,
509  uint8_t* valuePtr
510 )
511 {
512  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
513 }
514 
515 //--------------------------------------------------------------------------------------------------
516 /**
517  * Unpack a uint16_t from a buffer, incrementing the buffer pointer and decrementing the
518  * available size, as appropriate.
519  *
520  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
521  * size is known at compile time.
522  */
523 //--------------------------------------------------------------------------------------------------
524 static inline bool le_pack_UnpackUint16
525 (
526  uint8_t** bufferPtr,
527  size_t* sizePtr,
528  uint16_t* valuePtr
529 )
530 {
531  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
532 }
533 
534 //--------------------------------------------------------------------------------------------------
535 /**
536  * Unpack a uint32_t from a buffer, incrementing the buffer pointer and decrementing the
537  * available size, as appropriate.
538  *
539  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
540  * size is known at compile time.
541  */
542 //--------------------------------------------------------------------------------------------------
543 static inline bool le_pack_UnpackUint32
544 (
545  uint8_t** bufferPtr,
546  size_t* sizePtr,
547  uint32_t* valuePtr
548 )
549 {
550  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
551 }
552 
553 //--------------------------------------------------------------------------------------------------
554 /**
555  * Unpack a uint64_t from a buffer, incrementing the buffer pointer and decrementing the
556  * available size, as appropriate.
557  *
558  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
559  * size is known at compile time.
560  */
561 //--------------------------------------------------------------------------------------------------
562 static inline bool le_pack_UnpackUint64
563 (
564  uint8_t** bufferPtr,
565  size_t* sizePtr,
566  uint64_t* valuePtr
567 )
568 {
569  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
570 }
571 
572 //--------------------------------------------------------------------------------------------------
573 /**
574  * Unpack a int8_t from a buffer, incrementing the buffer pointer and decrementing the
575  * available size, as appropriate.
576  *
577  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
578  * size is known at compile time.
579  */
580 //--------------------------------------------------------------------------------------------------
581 static inline bool le_pack_UnpackInt8
582 (
583  uint8_t** bufferPtr,
584  size_t* sizePtr,
585  int8_t* valuePtr
586 )
587 {
588  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
589 }
590 
591 //--------------------------------------------------------------------------------------------------
592 /**
593  * Unpack a int16_t from a buffer, incrementing the buffer pointer and decrementing the
594  * available size, as appropriate.
595  *
596  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
597  * size is known at compile time.
598  */
599 //--------------------------------------------------------------------------------------------------
600 static inline bool le_pack_UnpackInt16
601 (
602  uint8_t** bufferPtr,
603  size_t* sizePtr,
604  int16_t* valuePtr
605 )
606 {
607  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
608 }
609 
610 //--------------------------------------------------------------------------------------------------
611 /**
612  * Unpack a int32_t from a buffer, incrementing the buffer pointer and decrementing the
613  * available size, as appropriate.
614  *
615  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
616  * size is known at compile time.
617  */
618 //--------------------------------------------------------------------------------------------------
619 static inline bool le_pack_UnpackInt32
620 (
621  uint8_t** bufferPtr,
622  size_t* sizePtr,
623  int32_t* valuePtr
624 )
625 {
626  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
627 }
628 
629 //--------------------------------------------------------------------------------------------------
630 /**
631  * Unpack a int64_t from a buffer, incrementing the buffer pointer and decrementing the
632  * available size, as appropriate.
633  *
634  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
635  * size is known at compile time.
636  */
637 //--------------------------------------------------------------------------------------------------
638 static inline bool le_pack_UnpackInt64
639 (
640  uint8_t** bufferPtr,
641  size_t* sizePtr,
642  int64_t* valuePtr
643 )
644 {
645  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
646 }
647 
648 /**
649  * Pack a size_t into a buffer, incrementing the buffer pointer and decrementing the
650  * available size, as appropriate.
651  *
652  * @note Packed sizes are limited to 2^32-1, regardless of platform
653  */
654 //--------------------------------------------------------------------------------------------------
655 static inline bool le_pack_UnpackSize
656 (
657  uint8_t **bufferPtr,
658  size_t *sizePtr,
659  size_t *valuePtr
660 )
661 {
662  uint32_t rawValue;
663 
664  if (!le_pack_UnpackUint32(bufferPtr, sizePtr, &rawValue))
665  {
666  return false;
667  }
668 
669  *valuePtr = rawValue;
670 
671  return true;
672 }
673 
674 //--------------------------------------------------------------------------------------------------
675 /**
676  * Unpack a bool from a buffer, incrementing the buffer pointer and decrementing the
677  * available size, as appropriate.
678  *
679  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
680  * size is known at compile time.
681  */
682 //--------------------------------------------------------------------------------------------------
683 static inline bool le_pack_UnpackBool
684 (
685  uint8_t** bufferPtr,
686  size_t* sizePtr,
687  bool* valuePtr
688 )
689 {
690  // Treat boolean as uint8_t for packing, regarldess of underlying OS type.
691  // Underlying type has been int on some platforms in the past.
692  uint8_t simpleValue;
693  if (*sizePtr < sizeof(simpleValue))
694  {
695  return false;
696  }
697 
698  memcpy(&simpleValue, *bufferPtr, sizeof(simpleValue));
699 
700  *bufferPtr = ((uint8_t* )*bufferPtr) + sizeof(simpleValue);
701  *sizePtr -= sizeof(simpleValue);
702 
703  // force to true or false
704  *valuePtr = !!simpleValue;
705 
706  return true;
707 }
708 
709 //--------------------------------------------------------------------------------------------------
710 /**
711  * Unpack a char from a buffer, incrementing the buffer pointer and decrementing the
712  * available size, as appropriate.
713  *
714  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
715  * size is known at compile time.
716  */
717 //--------------------------------------------------------------------------------------------------
718 static inline bool le_pack_UnpackChar
719 (
720  uint8_t** bufferPtr,
721  size_t* sizePtr,
722  char* valuePtr
723 )
724 {
725  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
726 }
727 
728 //--------------------------------------------------------------------------------------------------
729 /**
730  * Unpack a double from a buffer, incrementing the buffer pointer and decrementing the
731  * available size, as appropriate.
732  *
733  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
734  * size is known at compile time.
735  */
736 //--------------------------------------------------------------------------------------------------
737 static inline bool le_pack_UnpackDouble
738 (
739  uint8_t** bufferPtr,
740  size_t* sizePtr,
741  double* valuePtr
742 )
743 {
744  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
745 }
746 
747 //--------------------------------------------------------------------------------------------------
748 /**
749  * Unpack a le_result_t from a buffer, incrementing the buffer pointer and decrementing the
750  * available size, as appropriate.
751  *
752  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
753  * size is known at compile time.
754  */
755 //--------------------------------------------------------------------------------------------------
756 static inline bool le_pack_UnpackResult
757 (
758  uint8_t** bufferPtr,
759  size_t* sizePtr,
760  le_result_t* valuePtr
761 )
762 {
763  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
764 }
765 
766 //--------------------------------------------------------------------------------------------------
767 /**
768  * Pack le_onoff_t into a buffer, incrementing the buffer pointer and decrementing the
769  * available size, as appropriate.
770  *
771  * @note By making this an inline function, gcc can often optimize out the size check if the buffer
772  * size is known at compile time.
773  */
774 //--------------------------------------------------------------------------------------------------
775 static inline bool le_pack_UnpackOnOff
776 (
777  uint8_t** bufferPtr,
778  size_t* sizePtr,
779  le_onoff_t* valuePtr
780 )
781 {
782  LE_PACK_UNPACK_SIMPLE_VALUE(valuePtr);
783 }
784 
785 #undef LE_PACK_UNPACK_SIMPLE_VALUE
786 
787 //--------------------------------------------------------------------------------------------------
788 /**
789  * Unpack a reference from a buffer, incrementing the buffer pointer and decrementing the available
790  * size.
791  */
792 //--------------------------------------------------------------------------------------------------
793 static inline bool le_pack_UnpackReference
794 (
795  uint8_t** bufferPtr,
796  size_t* sizePtr,
797  void* refPtr ///< Pointer to the reference. Declared as void * to allow implicit
798  ///< conversion from pointer to reference types.
799 )
800 {
801  uint32_t refAsInt;
802 
803  if (!le_pack_UnpackUint32(bufferPtr, sizePtr, &refAsInt))
804  {
805  return false;
806  }
807 
808  // All references passed through an API must be safe references, so
809  // 0-bit will be set. Check that here to be safe.
810  if ((refAsInt & 0x01) ||
811  (!refAsInt))
812  {
813  // Double cast to avoid warnings.
814  *(void **)refPtr = (void *)(size_t)refAsInt;
815  return true;
816  }
817  else
818  {
819  return false;
820  }
821 }
822 
823 //--------------------------------------------------------------------------------------------------
824 /**
825  * Unpack a string from a buffer, incrementing the buffer pointer and decrementing the available
826  * size.
827  *
828  * @note Always decrements available size according to the max possible size used, not actual size
829  * used. Will assert if provided string is larger than maximum allowable string.
830  */
831 //--------------------------------------------------------------------------------------------------
832 static inline bool le_pack_UnpackString
833 (
834  uint8_t** bufferPtr,
835  size_t* sizePtr,
836  char *stringPtr,
837  uint32_t bufferSize,
838  uint32_t maxStringCount
839 )
840 {
841  uint32_t stringSize;
842 
843  if (*sizePtr < (maxStringCount + sizeof(uint32_t)))
844  {
845  return false;
846  }
847 
848  // First get string size
849  if (!le_pack_UnpackUint32(bufferPtr, sizePtr, &stringSize))
850  {
851  return false;
852  }
853 
854  if ((stringSize > maxStringCount) ||
855  (stringSize > bufferSize))
856  {
857  return false;
858  }
859 
860  if (!stringPtr)
861  {
862  // Only allow unpacking into no output buffer if the string is zero sized.
863  // Otherwise an output buffer is required.
864  if (stringSize)
865  {
866  return false;
867  }
868  else
869  {
870  return true;
871  }
872  }
873 
874  memcpy(stringPtr, *bufferPtr, stringSize);
875  stringPtr[stringSize] = '\0';
876 
877  *bufferPtr = *bufferPtr + stringSize;
878  *sizePtr -= maxStringCount;
879 
880  return true;
881 }
882 
883 //--------------------------------------------------------------------------------------------------
884 /**
885  * Pack the size information for an array into a buffer, incrementing the buffer pointer and
886  * decrementing the available size.
887  *
888  * @note Users of this API should generally use LE_PACK_PACKARRAY macro instead which also
889  * packs the array data.
890  */
891 //--------------------------------------------------------------------------------------------------
892 static inline bool le_pack_UnpackArrayHeader
893 (
894  uint8_t **bufferPtr,
895  size_t *sizePtr,
896  const void *arrayPtr,
897  size_t elementSize,
898  size_t *arrayCountPtr,
899  size_t arrayMaxCount
900 )
901 {
902  if (*sizePtr < (arrayMaxCount*elementSize + sizeof(uint32_t)))
903  {
904  return false;
905  }
906 
907  LE_ASSERT(le_pack_UnpackSize(bufferPtr, sizePtr, arrayCountPtr));
908  if (*arrayCountPtr > arrayMaxCount)
909  {
910  return false;
911  }
912  else if (!arrayPtr)
913  {
914  // Missing array pointer must match zero sized array.
915  return (*arrayCountPtr == 0);
916  }
917 
918  return true;
919 }
920 
921 //--------------------------------------------------------------------------------------------------
922 /**
923  * Unpack an array into from buffer, incrementing the buffer pointer and decrementing the available
924  * size.
925  *
926  * @note Always decrements available size according to the max possible size used, not actual size
927  * used. Will assert if provided string is larger than maximum allowable string.
928  */
929 //--------------------------------------------------------------------------------------------------
930 #define LE_PACK_UNPACKARRAY(bufferPtr, \
931  sizePtr, \
932  arrayPtr, \
933  arrayCountPtr, \
934  arrayMaxCount, \
935  unpackFunc, \
936  resultPtr) \
937  do { \
938  if (!le_pack_UnpackArrayHeader((bufferPtr), (sizePtr), \
939  (arrayPtr), sizeof((arrayPtr)[0]), \
940  (arrayCountPtr), (arrayMaxCount))) \
941  { \
942  *(resultPtr) = false; \
943  } \
944  else \
945  { \
946  uint32_t i; \
947  size_t newSizePtr = *(sizePtr) - sizeof((arrayPtr)[0])*(arrayMaxCount); \
948  for (i = 0; i < *(arrayCountPtr); ++i) \
949  { \
950  LE_ASSERT(unpackFunc((bufferPtr), (sizePtr), &(arrayPtr)[i])); \
951  } \
952  LE_ASSERT(*(sizePtr) >= newSizePtr); \
953  *(sizePtr) = newSizePtr; \
954  *(resultPtr) = true; \
955  } \
956  } while (0)
957 
958 #endif /* LE_PACK_H_INCLUDE_GUARD */
le_result_t
Definition: le_basics.h:35
#define LE_ASSERT(condition)
Definition: le_log.h:562
le_onoff_t
Definition: le_basics.h:70