1 #include "config.h"
2 #include <razorback/api.h>
3 #include <razorback/block.h>
4 #include <razorback/debug.h>
5 #include <razorback/log.h>
6 #include <razorback/hash.h>
7 #include <razorback/event.h>
8 #include <razorback/judgment.h>
9 #include <razorback/thread.h>
10 #include <razorback/uuids.h>
11 #include <razorback/string_list.h>
12
13 #ifdef HAVE_SYS_ENDIAN_H
14 #include <sys/endian.h>
15 #endif
16
17 #ifdef _MSC_VER
18 #include <WinSock.h>
19 #else //_MSC_VER
20 #include <arpa/inet.h>
21 #endif //_MSC_VER
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "runtime_config.h"
27 #include "binary_buffer.h"
28
29 #include <stdio.h>
30
31 #include <osreldate.h>
32 #if __FreeBSD_version < 800067
33 size_t strnlen(const char *s, size_t maxlen);
strnlen(const char * s,size_t maxlen)34 size_t strnlen(const char *s, size_t maxlen)
35 {
36 size_t i;
37 for (i = 0; i < maxlen; i++) {
38 if (s[i] == '\0')
39 break;
40 }
41 return i;
42 }
43 #endif
44
45 struct BinaryBuffer *
BinaryBuffer_CreateFromMessage(struct Message * message)46 BinaryBuffer_CreateFromMessage (struct Message *message)
47 {
48 struct BinaryBuffer *buf;
49 ASSERT(message != NULL);
50 if (message == NULL)
51 return NULL;
52
53 if ((buf = calloc (1, sizeof (struct BinaryBuffer))) == NULL)
54 return NULL;
55
56 buf->pBuffer = message->serialized;
57 buf->iLength = message->length;
58
59 return buf;
60 }
61
62 struct BinaryBuffer *
BinaryBuffer_Create(uint32_t p_iSize)63 BinaryBuffer_Create (uint32_t p_iSize)
64 {
65 struct BinaryBuffer *l_pBuffer;
66 if ((l_pBuffer = calloc (1, sizeof (struct BinaryBuffer))) == NULL)
67 {
68 rzb_perror ("BinaryBuffer_Create: calloc failure: %s");
69 return NULL;
70 }
71
72
73 if (p_iSize > (uint32_t) Config_getMaxBlockSize ())
74 return NULL;
75
76
77 l_pBuffer->iLength = p_iSize;
78
79 // alocate the buffer
80 if ((l_pBuffer->pBuffer = calloc (p_iSize, sizeof (uint8_t))) == NULL)
81 {
82 rzb_log (LOG_ERR,
83 "%s: failed due to lack of memory", __func__);
84 free (l_pBuffer);
85 return NULL;
86 }
87
88 // set the offset
89 l_pBuffer->iOffset = 0;
90
91 // done
92 return l_pBuffer;
93 }
94
95 void
BinaryBuffer_Destroy(struct BinaryBuffer * p_pBuffer)96 BinaryBuffer_Destroy (struct BinaryBuffer *p_pBuffer)
97 {
98 ASSERT (p_pBuffer != NULL);
99
100 // free the heap memory
101 if (p_pBuffer->pBuffer != NULL)
102 free (p_pBuffer->pBuffer);
103
104 free (p_pBuffer);
105 }
106
107 bool
BinaryBuffer_Put_uint8_t(struct BinaryBuffer * p_pBuffer,uint8_t p_iValue)108 BinaryBuffer_Put_uint8_t (struct BinaryBuffer *p_pBuffer, uint8_t p_iValue)
109 {
110 ASSERT (p_pBuffer != NULL);
111 ASSERT (p_pBuffer->pBuffer != NULL);
112
113 // check that space exists
114 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint8_t) > p_pBuffer->iLength)
115 {
116 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
117 return false;
118 }
119
120 // place in the buffer in network order
121 p_pBuffer->pBuffer[p_pBuffer->iOffset] = p_iValue;
122
123 // update length
124 p_pBuffer->iOffset += (uint32_t) sizeof (uint8_t);
125
126 // done
127 return true;
128 }
129
130 bool
BinaryBuffer_Put_uint16_t(struct BinaryBuffer * p_pBuffer,uint16_t p_iValue)131 BinaryBuffer_Put_uint16_t (struct BinaryBuffer * p_pBuffer, uint16_t p_iValue)
132 {
133 ASSERT (p_pBuffer != NULL);
134 ASSERT (p_pBuffer->pBuffer != NULL);
135
136 // check that space exists
137 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint16_t) >
138 p_pBuffer->iLength)
139 {
140 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
141 return false;
142 }
143
144 // place in the buffer in network order
145 p_iValue = htobe16 (p_iValue);
146 memcpy(&(p_pBuffer->pBuffer[p_pBuffer->iOffset]), &p_iValue, sizeof(uint16_t));
147
148 // update length
149 p_pBuffer->iOffset += (uint32_t) sizeof (uint16_t);
150
151 // done
152 return true;
153 }
154
155 bool
BinaryBuffer_Put_uint32_t(struct BinaryBuffer * p_pBuffer,uint32_t p_iValue)156 BinaryBuffer_Put_uint32_t (struct BinaryBuffer * p_pBuffer, uint32_t p_iValue)
157 {
158 ASSERT (p_pBuffer != NULL);
159 ASSERT (p_pBuffer->pBuffer != NULL);
160
161 // check that space exists
162 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint32_t) >
163 p_pBuffer->iLength)
164 {
165 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
166 return false;
167 }
168 // place in the buffer in network order
169 p_iValue = htobe32 (p_iValue);
170 memcpy(&(p_pBuffer->pBuffer[p_pBuffer->iOffset]), &p_iValue, sizeof(uint32_t));
171
172 // update length
173 p_pBuffer->iOffset += (uint32_t) sizeof (uint32_t);
174
175 // done
176 return true;
177 }
178
179 bool
BinaryBuffer_Put_uint64_t(struct BinaryBuffer * p_pBuffer,uint64_t p_iValue)180 BinaryBuffer_Put_uint64_t (struct BinaryBuffer * p_pBuffer, uint64_t p_iValue)
181 {
182 ASSERT (p_pBuffer != NULL);
183 ASSERT (p_pBuffer->pBuffer != NULL);
184
185 // check that space exists
186 if (p_pBuffer->iOffset + (uint64_t) sizeof (uint64_t) >
187 p_pBuffer->iLength)
188 {
189 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
190 return false;
191 }
192 // place in the buffer in network order
193 p_iValue = htobe64 (p_iValue);
194 memcpy(&(p_pBuffer->pBuffer[p_pBuffer->iOffset]), &p_iValue, sizeof(uint64_t));
195
196 // update length
197 p_pBuffer->iOffset += (uint64_t) sizeof (uint64_t);
198
199 // done
200 return true;
201 }
202
203 bool
BinaryBuffer_Put_ByteArray(struct BinaryBuffer * p_pBuffer,uint32_t p_iSize,const uint8_t * p_pByteArray)204 BinaryBuffer_Put_ByteArray (struct BinaryBuffer * p_pBuffer,
205 uint32_t p_iSize, const uint8_t * p_pByteArray)
206 {
207 ASSERT (p_pBuffer != NULL);
208 ASSERT (p_pBuffer->pBuffer != NULL);
209 ASSERT (p_pByteArray != NULL);
210
211 // check that space exists
212 if (p_pBuffer->iOffset + p_iSize > p_pBuffer->iLength)
213 {
214 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
215 return false;
216 }
217 // place in the buffer in network order
218 memcpy (((uint8_t *) & p_pBuffer->pBuffer[p_pBuffer->iOffset]),
219 p_pByteArray, p_iSize);
220
221 // update length
222 p_pBuffer->iOffset += p_iSize;
223
224 // done
225 return true;
226 }
227
228 bool
BinaryBuffer_Put_String(struct BinaryBuffer * p_pBB,const uint8_t * p_sString)229 BinaryBuffer_Put_String (struct BinaryBuffer * p_pBB,
230 const uint8_t * p_sString)
231 {
232 uint32_t l_iSize;
233
234 ASSERT (p_pBB != NULL);
235 ASSERT (p_pBB->pBuffer != NULL);
236 ASSERT (p_sString != NULL);
237
238 // determine the size
239 l_iSize = (uint32_t) (strlen ((char *) p_sString) + 1) * sizeof (uint8_t);
240
241 return BinaryBuffer_Put_ByteArray (p_pBB, l_iSize, p_sString);
242 }
243
244
245 bool
BinaryBuffer_Get_uint8_t(struct BinaryBuffer * p_pBuffer,uint8_t * p_pValue)246 BinaryBuffer_Get_uint8_t (struct BinaryBuffer * p_pBuffer, uint8_t * p_pValue)
247 {
248 ASSERT (p_pBuffer != NULL);
249 ASSERT (p_pBuffer->pBuffer != NULL);
250 ASSERT (p_pValue != NULL);
251
252 // check that space exists
253 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint8_t) > p_pBuffer->iLength)
254 {
255 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
256 return false;
257 }
258
259 // read the value
260 *p_pValue = p_pBuffer->pBuffer[p_pBuffer->iOffset];
261
262 // adjust the offset
263 p_pBuffer->iOffset += (uint32_t) sizeof (uint8_t);
264
265 // done
266 return true;
267 }
268
269 bool
BinaryBuffer_Get_uint16_t(struct BinaryBuffer * p_pBuffer,uint16_t * p_pValue)270 BinaryBuffer_Get_uint16_t (struct BinaryBuffer * p_pBuffer,
271 uint16_t * p_pValue)
272 {
273 ASSERT (p_pBuffer != NULL);
274 ASSERT (p_pBuffer->pBuffer != NULL);
275 ASSERT (p_pValue != NULL);
276
277 // check that space exists
278 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint16_t) >
279 p_pBuffer->iLength)
280 {
281 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
282 return false;
283 }
284 // read the value
285 // *p_pValue =
286 // be16toh (*((uint16_t *) & p_pBuffer->pBuffer[p_pBuffer->iOffset]));
287 memcpy(p_pValue, &(p_pBuffer->pBuffer[p_pBuffer->iOffset]), sizeof(uint16_t));
288 *p_pValue = be16toh(*p_pValue);
289 // adjust the offset
290 p_pBuffer->iOffset += (uint32_t) sizeof (uint16_t);
291
292 // done
293 return true;
294 }
295
296 bool
BinaryBuffer_Get_uint32_t(struct BinaryBuffer * p_pBuffer,uint32_t * p_pValue)297 BinaryBuffer_Get_uint32_t (struct BinaryBuffer * p_pBuffer,
298 uint32_t * p_pValue)
299 {
300 ASSERT (p_pBuffer != NULL);
301 ASSERT (p_pBuffer->pBuffer != NULL);
302 ASSERT (p_pValue != NULL);
303
304 // check that space exists
305 if (p_pBuffer->iOffset + (uint32_t) sizeof (uint32_t) >
306 p_pBuffer->iLength)
307 {
308 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
309 return false;
310 }
311 // read the value
312 memcpy(p_pValue, &(p_pBuffer->pBuffer[p_pBuffer->iOffset]), sizeof(uint32_t));
313 *p_pValue = be32toh(*p_pValue);
314
315 // adjust the offset
316 p_pBuffer->iOffset += (uint32_t) sizeof (uint32_t);
317
318 // done
319 return true;
320 }
321
322 bool
BinaryBuffer_Get_uint64_t(struct BinaryBuffer * p_pBuffer,uint64_t * p_pValue)323 BinaryBuffer_Get_uint64_t (struct BinaryBuffer * p_pBuffer,
324 uint64_t * p_pValue)
325 {
326 ASSERT (p_pBuffer != NULL);
327 ASSERT (p_pBuffer->pBuffer != NULL);
328 ASSERT (p_pValue != NULL);
329
330 // check that space exists
331 if (p_pBuffer->iOffset + (uint64_t) sizeof (uint64_t) >
332 p_pBuffer->iLength)
333 {
334 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
335 return false;
336 }
337 // read the value
338 memcpy(p_pValue, &(p_pBuffer->pBuffer[p_pBuffer->iOffset]), sizeof(uint64_t));
339 *p_pValue = be64toh(*p_pValue);
340
341 // adjust the offset
342 p_pBuffer->iOffset += (uint64_t) sizeof (uint64_t);
343
344 // done
345 return true;
346 }
347
348 uint8_t *
BinaryBuffer_Get_String(struct BinaryBuffer * p_pBuffer)349 BinaryBuffer_Get_String (struct BinaryBuffer * p_pBuffer)
350 {
351 uint32_t l_iBytesLeft = p_pBuffer->iLength - p_pBuffer->iOffset;
352 uint32_t l_iSize;
353 uint8_t *pString;
354
355 ASSERT (p_pBuffer != NULL);
356 ASSERT (p_pBuffer->pBuffer != NULL);
357
358 l_iSize = strnlen ((char *)&p_pBuffer->pBuffer[p_pBuffer->iOffset],
359 l_iBytesLeft);
360
361 if (l_iSize == 0)
362 {
363 rzb_log (LOG_ERR,
364 "%s: failed due to empty string", __func__);
365 return NULL;
366 }
367
368 if (l_iSize == l_iBytesLeft)
369 {
370 rzb_log (LOG_ERR,
371 "%s: failed due to buffer overrun", __func__);
372 return NULL;
373 }
374
375 if ((pString = (uint8_t *)calloc(l_iSize+1, sizeof(uint8_t))) == NULL)
376 {
377 rzb_log (LOG_ERR,
378 "%s: could not allocate memory", __func__);
379 return NULL;
380 }
381
382 if (!BinaryBuffer_Get_ByteArray(p_pBuffer, l_iSize+1, pString))
383 {
384 rzb_log (LOG_ERR,
385 "%s: failed due to failed of BinaryBuffer_Get_ByteArray", __func__);
386 free(pString);
387 return NULL;
388 }
389
390 return pString;
391 }
392
393 bool
BinaryBuffer_Get_ByteArray(struct BinaryBuffer * p_pBuffer,uint32_t p_iSize,uint8_t * p_pByteArray)394 BinaryBuffer_Get_ByteArray (struct BinaryBuffer * p_pBuffer,
395 uint32_t p_iSize, uint8_t * p_pByteArray)
396 {
397 ASSERT (p_pBuffer != NULL);
398 ASSERT (p_pBuffer->pBuffer != NULL);
399 ASSERT (p_pByteArray != NULL);
400
401 // check that space exists
402 if (p_pBuffer->iOffset + p_iSize > p_pBuffer->iLength)
403 {
404 rzb_log (LOG_ERR, "%s: failed due to overrun", __func__);
405 return false;
406 }
407 // read the value
408 memcpy (p_pByteArray, &p_pBuffer->pBuffer[p_pBuffer->iOffset], p_iSize);
409
410 // adjust the offset
411 p_pBuffer->iOffset += p_iSize;
412
413 // done
414 return true;
415 }
416
417 bool
BinaryBuffer_Get_UUID(struct BinaryBuffer * p_pBuffer,uuid_t p_uuid)418 BinaryBuffer_Get_UUID (struct BinaryBuffer * p_pBuffer, uuid_t p_uuid)
419 {
420 uint32_t l_iIndex;
421
422 ASSERT (p_pBuffer != NULL);
423 ASSERT (p_pBuffer->pBuffer != NULL);
424 ASSERT (p_uuid != NULL);
425
426 for (l_iIndex = 0; l_iIndex < 16; l_iIndex++)
427 {
428 if (!BinaryBuffer_Get_uint8_t (p_pBuffer, &p_uuid[l_iIndex]))
429 {
430 rzb_log (LOG_ERR,
431 "%s: failed due to failure of BinaryBuffer_Get_uint8_t", __func__);
432 return false;
433 }
434 }
435 return true;
436 }
437
438 bool
BinaryBuffer_Put_UUID(struct BinaryBuffer * p_pBuffer,uuid_t p_uuid)439 BinaryBuffer_Put_UUID (struct BinaryBuffer * p_pBuffer, uuid_t p_uuid)
440 {
441 uint32_t l_iIndex;
442
443 ASSERT (p_pBuffer != NULL);
444 ASSERT (p_pBuffer->pBuffer != NULL);
445 ASSERT (p_uuid != NULL);
446
447 for (l_iIndex = 0; l_iIndex < 16; l_iIndex++)
448 {
449 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, p_uuid[l_iIndex]))
450 {
451 rzb_log (LOG_ERR,
452 "%s: failed due to failure of BinaryBuffer_Put_uint8_t", __func__);
453 return false;
454 }
455 }
456 return true;
457 }
458
459 static int
BinaryBuffer_Put_NTLVItem(struct NTLVItem * p_pItem,struct BinaryBuffer * p_pBuffer)460 BinaryBuffer_Put_NTLVItem (struct NTLVItem *p_pItem,struct BinaryBuffer *p_pBuffer)
461 {
462 ASSERT (p_pBuffer != NULL);
463 ASSERT (p_pItem != NULL);
464
465 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pItem->uuidName))
466 {
467 rzb_log (LOG_ERR,
468 "%s: failed due to failure of BinaryBuffer_Put_UUID", __func__);
469 return LIST_EACH_ERROR;
470 }
471 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pItem->uuidType))
472 {
473 rzb_log (LOG_ERR,
474 "%s: failed due to failure of BinaryBuffer_Put_UUID", __func__);
475 return LIST_EACH_ERROR;
476 }
477 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pItem->iLength))
478 {
479 rzb_log (LOG_ERR,
480 "%s: failed due to failure of BinaryBuffer_Put_uint32_t", __func__);
481 return LIST_EACH_ERROR;
482 }
483 if (!BinaryBuffer_Put_ByteArray
484 (p_pBuffer, p_pItem->iLength, p_pItem->pData))
485 {
486 rzb_log (LOG_ERR,
487 "%s: failed due to failure of BinaryBuffer_Put_ByteArray", __func__);
488 return LIST_EACH_ERROR;
489 }
490
491 return LIST_EACH_OK;
492 }
493
494 bool
BinaryBuffer_Put_NTLVList(struct BinaryBuffer * p_pBuffer,struct List * p_pList)495 BinaryBuffer_Put_NTLVList (struct BinaryBuffer * p_pBuffer,
496 struct List * p_pList)
497 {
498 ASSERT (p_pBuffer != NULL);
499 ASSERT (p_pList != NULL);
500
501 if (p_pBuffer->iOffset + NTLVList_Size (p_pList) > p_pBuffer->iLength)
502 {
503 rzb_log (LOG_ERR,
504 "%s: failed due to lack overrun", __func__);
505 return false;
506 }
507
508 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, List_Length (p_pList)))
509 {
510 rzb_log (LOG_ERR,
511 "%s: failed due failure of BinaryBuffer_Put_uint32_t", __func__);
512 return false;
513 }
514 if (!List_ForEach(p_pList, (int (*)(void*,void*))BinaryBuffer_Put_NTLVItem, p_pBuffer))
515 {
516 rzb_log (LOG_ERR,
517 "%s: failed due failure of BinaryBuffer_Put_NTLVItem", __func__);
518 return false;
519 }
520 return true;
521 }
522
523 bool
BinaryBuffer_Get_NTLVList(struct BinaryBuffer * p_pBuffer,struct List ** p_pList)524 BinaryBuffer_Get_NTLVList (struct BinaryBuffer * p_pBuffer,
525 struct List ** p_pList)
526 {
527 struct List * l_pList;
528 uint32_t l_iCount;
529 uint32_t l_iIndex;
530 uuid_t l_uuiNameTemp;
531 uuid_t l_uuiTypeTemp;
532 uint32_t l_iSizeTemp;
533 uint8_t *l_pDataTemp;
534
535 ASSERT (p_pBuffer != NULL);
536
537 // clear the list
538 if ((l_pList = NTLVList_Create()) == NULL)
539 {
540 *p_pList = NULL;
541 return false;
542 }
543 // get the count
544 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_iCount))
545 {
546 List_Destroy (l_pList);
547 *p_pList = NULL;
548 rzb_log (LOG_ERR,
549 "%s: failed due failure of BinaryBuffer_Get_uint32_t", __func__);
550 return false;
551 }
552
553 // get each entry
554 for (l_iIndex = 0; l_iIndex < l_iCount; l_iIndex++)
555 {
556 // get each field
557 if (!BinaryBuffer_Get_UUID (p_pBuffer, l_uuiNameTemp))
558 {
559 List_Destroy (l_pList);
560 *p_pList = NULL;
561 rzb_log (LOG_ERR,
562 "%s: failed due failure of BinaryBuffer_Get_UUID", __func__);
563 return false;
564 }
565 if (!BinaryBuffer_Get_UUID (p_pBuffer, l_uuiTypeTemp))
566 {
567 List_Destroy (l_pList);
568 *p_pList = NULL;
569 rzb_log (LOG_ERR,
570 "%s: failed due failure of BinaryBuffer_Get_UUID", __func__);
571 return false;
572 }
573 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_iSizeTemp))
574 {
575 List_Destroy (l_pList);
576 *p_pList = NULL;
577 rzb_log (LOG_ERR,
578 "%s: failed due failure of BinaryBuffer_Get_uint32_t", __func__);
579 return false;
580 }
581 l_pDataTemp = (uint8_t *)calloc (l_iSizeTemp, sizeof (uint8_t));
582 if (l_pDataTemp == NULL)
583 {
584 List_Destroy (l_pList);
585 *p_pList = NULL;
586 rzb_log (LOG_ERR,
587 "%s: failed due to lack of memory", __func__);
588 return false;
589 }
590 if (!BinaryBuffer_Get_ByteArray (p_pBuffer, l_iSizeTemp, l_pDataTemp))
591 {
592 free (l_pDataTemp);
593 List_Destroy (l_pList);
594 *p_pList = NULL;
595 rzb_log (LOG_ERR,
596 "%s: failed due failure of BinaryBuffer_Get_ByteArray", __func__);
597 return false;
598 }
599 if (!NTLVList_Add
600 (l_pList, l_uuiNameTemp, l_uuiTypeTemp, l_iSizeTemp, l_pDataTemp))
601 {
602 free (l_pDataTemp);
603 List_Destroy (l_pList);
604 *p_pList = NULL;
605 rzb_log (LOG_ERR,
606 "%s: failed due failure of List_Add", __func__);
607 return false;
608 }
609 free (l_pDataTemp);
610 }
611 *p_pList = l_pList;
612 return true;
613 }
614
615 bool
BinaryBuffer_Put_Hash(struct BinaryBuffer * p_pBuffer,const struct Hash * p_pHash)616 BinaryBuffer_Put_Hash (struct BinaryBuffer * p_pBuffer,
617 const struct Hash * p_pHash)
618 {
619 ASSERT (p_pBuffer != NULL);
620 ASSERT (p_pHash != NULL);
621 ASSERT (p_pHash->iFlags & HASH_FLAG_FINAL);
622 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pHash->iType))
623 {
624 rzb_log (LOG_ERR,
625 "%s: failed due failure of BinaryBuffer_Put_uint32_t", __func__);
626 return false;
627 }
628 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pHash->iSize))
629 {
630 rzb_log (LOG_ERR,
631 "%s: failed due failure of BinaryBuffer_Put_uint32_t", __func__);
632 return false;
633 }
634 if (!BinaryBuffer_Put_ByteArray (p_pBuffer, p_pHash->iSize,
635 p_pHash->pData))
636 {
637 rzb_log (LOG_ERR,
638 "%s: failed due failure of BinaryBuffer_Put_ByteArray", __func__);
639 return false;
640 }
641
642 return true;
643 }
644
645 bool
BinaryBuffer_Get_Hash(struct BinaryBuffer * p_pBuffer,struct Hash ** p_pHash)646 BinaryBuffer_Get_Hash (struct BinaryBuffer * p_pBuffer, struct Hash ** p_pHash)
647 {
648 struct Hash *l_pHash;
649
650 ASSERT (p_pBuffer != NULL);
651
652 if ((l_pHash = (struct Hash *)calloc(1, sizeof (struct Hash))) == NULL)
653 {
654 *p_pHash = NULL;
655 return false;
656 }
657
658 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pHash->iType))
659 {
660 Hash_Destroy(l_pHash);
661 *p_pHash = NULL;
662 rzb_log (LOG_ERR,
663 "%s: failed due failure of BinaryBuffer_Get_uint32_t", __func__);
664 return false;
665 }
666
667 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pHash->iSize))
668 {
669 Hash_Destroy(l_pHash);
670 *p_pHash = NULL;
671 rzb_log (LOG_ERR,
672 "%s: failed due failure of BinaryBuffer_Get_uint32_t", __func__);
673 return false;
674 }
675 if ((l_pHash->pData = (uint8_t *)calloc (l_pHash->iSize, sizeof (uint8_t))) == NULL)
676 {
677 Hash_Destroy(l_pHash);
678 *p_pHash = NULL;
679 rzb_log (LOG_ERR, "%s: failed due lack of memory", __func__);
680 return false;
681 }
682
683 if (!BinaryBuffer_Get_ByteArray
684 (p_pBuffer, l_pHash->iSize, l_pHash->pData))
685 {
686 Hash_Destroy(l_pHash);
687 *p_pHash = NULL;
688 rzb_log (LOG_ERR,
689 "%s: failed due failure of BinaryBuffer_Get_ByteArray", __func__);
690 return false;
691 }
692 l_pHash->iFlags = HASH_FLAG_FINAL;
693 *p_pHash = l_pHash;
694
695 return true;
696 }
697
698
699
700 bool
BinaryBuffer_Put_BlockId(struct BinaryBuffer * p_pBuffer,struct BlockId * p_pId)701 BinaryBuffer_Put_BlockId (struct BinaryBuffer * p_pBuffer,
702 struct BlockId * p_pId)
703 {
704 ASSERT (p_pBuffer != NULL);
705 ASSERT (p_pId != NULL);
706
707 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pId->uuidDataType))
708 {
709 rzb_log (LOG_ERR,
710 "%s: failed due failure of BinaryBuffer_Put_UUID", __func__);
711 return false;
712 }
713 if (!BinaryBuffer_Put_uint64_t (p_pBuffer, p_pId->iLength))
714 {
715 rzb_log (LOG_ERR,
716 "%s: failed due failure of BinaryBuffer_Put_uint64_t", __func__);
717 return false;
718 }
719 if (!BinaryBuffer_Put_Hash (p_pBuffer, p_pId->pHash))
720 {
721 rzb_log (LOG_ERR,
722 "%s: failed due failure of BinaryBuffer_Put_Hash", __func__);
723 return false;
724 }
725 return true;
726 }
727
728 bool
BinaryBuffer_Get_BlockId(struct BinaryBuffer * p_pBuffer,struct BlockId ** p_pId)729 BinaryBuffer_Get_BlockId (struct BinaryBuffer * p_pBuffer,
730 struct BlockId ** p_pId)
731 {
732 struct BlockId * l_pId;
733
734 ASSERT (p_pBuffer != NULL);
735
736 if ((l_pId = (struct BlockId *)calloc(1, sizeof(struct BlockId))) == NULL)
737 {
738 return false;
739 }
740 if (!BinaryBuffer_Get_UUID (p_pBuffer, l_pId->uuidDataType))
741 {
742 rzb_log (LOG_ERR,
743 "%s: failed due failure of BinaryBuffer_Get_UUID", __func__);
744 return false;
745 }
746 if (!BinaryBuffer_Get_uint64_t (p_pBuffer, &l_pId->iLength))
747 {
748 rzb_log (LOG_ERR,
749 "%s: failed due failure of BinaryBuffer_Get_uint64_t", __func__);
750 return false;
751 }
752 if (!BinaryBuffer_Get_Hash (p_pBuffer, &l_pId->pHash))
753 {
754 free (l_pId->pHash);
755 rzb_log (LOG_ERR,
756 "%s: failed due failure of BinaryBuffer_Get_Hash", __func__);
757 return false;
758 }
759 *p_pId = l_pId;
760 return true;
761 }
762
763 bool
BinaryBuffer_Put_Block(struct BinaryBuffer * p_pBuffer,struct Block * p_pBlock)764 BinaryBuffer_Put_Block (struct BinaryBuffer * p_pBuffer,
765 struct Block * p_pBlock)
766 {
767 ASSERT (p_pBuffer != NULL);
768 ASSERT (p_pBlock != NULL);
769 if (!BinaryBuffer_Put_BlockId (p_pBuffer, p_pBlock->pId))
770 {
771 rzb_log (LOG_ERR,
772 "%s: failed due failure of BinaryBuffer_Put_BlockId", __func__);
773 return false;
774 }
775
776 if (p_pBlock->pParentId == NULL)
777 {
778 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 0))
779 {
780 rzb_log (LOG_ERR,
781 "%s: failed due failure of BinaryBuffer_Put_uint8_t", __func__);
782 return false;
783 }
784 }
785 else
786 {
787 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 1))
788 {
789 rzb_log (LOG_ERR,
790 "%s: failed due failure of BinaryBuffer_Put_uint8_t", __func__);
791 return false;
792 }
793 if (!BinaryBuffer_Put_BlockId (p_pBuffer, p_pBlock->pParentId))
794 {
795 rzb_log (LOG_ERR,
796 "%s: failed due failure of BinaryBuffer_Put_BlockId", __func__);
797 return false;
798 }
799 }
800
801 if (!BinaryBuffer_Put_NTLVList (p_pBuffer, p_pBlock->pMetaDataList))
802 {
803 rzb_log (LOG_ERR,
804 "%s: failed due failure of BinaryBuffer_Put_NTLVList", __func__);
805 return false;
806 }
807
808
809 return true;
810 }
811
812
813 bool
BinaryBuffer_Get_Block(struct BinaryBuffer * p_pBuffer,struct Block ** p_pBlock)814 BinaryBuffer_Get_Block (struct BinaryBuffer * p_pBuffer,
815 struct Block ** p_pBlock)
816 {
817 uint8_t l_iHas = 0;
818 struct Block * l_pBlock;
819
820 ASSERT (p_pBuffer != NULL);
821
822 if ((l_pBlock = (struct Block *)calloc(1, sizeof(struct Block))) == NULL)
823 {
824 *p_pBlock = NULL;
825 return false;
826 }
827
828 if (!BinaryBuffer_Get_BlockId (p_pBuffer, &l_pBlock->pId))
829 {
830 rzb_log (LOG_ERR,
831 "%s: failed due failure of BinaryBuffer_Get_BlockId", __func__);
832 Block_Destroy(l_pBlock);
833 *p_pBlock = NULL;
834 return false;
835 }
836
837 if (!BinaryBuffer_Get_uint8_t (p_pBuffer, &l_iHas))
838 {
839 rzb_log (LOG_ERR,
840 "%s: failed due failure of BinaryBuffer_Get_uint8_t", __func__);
841 Block_Destroy(l_pBlock);
842 *p_pBlock = NULL;
843 return false;
844 }
845
846 if (l_iHas == 1)
847 {
848 if (!BinaryBuffer_Get_BlockId (p_pBuffer, &l_pBlock->pParentId))
849 {
850 rzb_log (LOG_ERR,
851 "%s: failed due failure of BinaryBuffer_Get_BlockId", __func__);
852 Block_Destroy(l_pBlock);
853 *p_pBlock = NULL;
854 return false;
855 }
856 }
857 else
858 l_pBlock->pParentId = NULL;
859
860
861 if (!BinaryBuffer_Get_NTLVList (p_pBuffer, &l_pBlock->pMetaDataList))
862 {
863 rzb_log (LOG_ERR,
864 "%s: failed due failure of BinaryBuffer_Get_NTLVList", __func__);
865 Block_Destroy(l_pBlock);
866 *p_pBlock = NULL;
867 return false;
868 }
869
870
871 *p_pBlock = l_pBlock;
872 return true;
873 }
874
875 bool
BinaryBuffer_Put_EventId(struct BinaryBuffer * p_pBuffer,struct EventId * p_pEventId)876 BinaryBuffer_Put_EventId (struct BinaryBuffer *p_pBuffer,
877 struct EventId *p_pEventId)
878 {
879 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pEventId->uuidNuggetId))
880 {
881 rzb_log(LOG_ERR, "%s: Failed to put nugget id", __func__);
882 return false;
883 }
884
885 if (!BinaryBuffer_Put_uint64_t (p_pBuffer, p_pEventId->iSeconds))
886 {
887 rzb_log(LOG_ERR, "%s: Failed to put seconds", __func__);
888 return false;
889 }
890 if (!BinaryBuffer_Put_uint64_t (p_pBuffer, p_pEventId->iNanoSecs))
891 {
892 rzb_log(LOG_ERR, "%s: Failed to put nano seconds", __func__);
893 return false;
894 }
895
896 return true;
897 }
898
899 bool
BinaryBuffer_Get_EventId(struct BinaryBuffer * p_pBuffer,struct EventId ** p_pEventId)900 BinaryBuffer_Get_EventId (struct BinaryBuffer *p_pBuffer,
901 struct EventId **p_pEventId)
902 {
903 struct EventId *eventId = NULL;
904 if ((eventId = EventId_Create()) == NULL)
905 {
906 rzb_log(LOG_ERR, "%s: Failed to create event", __func__);
907 return false;
908 }
909
910 if (!BinaryBuffer_Get_UUID (p_pBuffer, eventId->uuidNuggetId))
911 {
912 rzb_log(LOG_ERR, "%s: Failed to get nugget id", __func__);
913 return false;
914 }
915
916 if (!BinaryBuffer_Get_uint64_t (p_pBuffer, &eventId->iSeconds))
917 {
918 rzb_log(LOG_ERR, "%s: Failed to get seconds", __func__);
919 return false;
920 }
921 if (!BinaryBuffer_Get_uint64_t (p_pBuffer, &eventId->iNanoSecs))
922 {
923 rzb_log(LOG_ERR, "%s: Failed to get nano seconds", __func__);
924 return false;
925 }
926 *p_pEventId = eventId;
927 return true;
928 }
929
930 bool
BinaryBuffer_Put_Event(struct BinaryBuffer * p_pBuffer,struct Event * p_pEvent)931 BinaryBuffer_Put_Event (struct BinaryBuffer *p_pBuffer,
932 struct Event *p_pEvent)
933 {
934 if (!BinaryBuffer_Put_EventId (p_pBuffer, p_pEvent->pId))
935 {
936 rzb_log(LOG_ERR, "%s: Failed to put nugget id", __func__);
937 return false;
938 }
939 if (p_pEvent->pParentId == NULL)
940 {
941 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 0))
942 {
943 rzb_log(LOG_ERR, "%s: Failed to put event id marker", __func__);
944 return false;
945 }
946 }
947 else
948 {
949 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 1))
950 {
951 rzb_log(LOG_ERR, "%s: Failed to put event id marker", __func__);
952 return false;
953 }
954 if (!BinaryBuffer_Put_EventId (p_pBuffer, p_pEvent->pParentId))
955 {
956 rzb_log(LOG_ERR, "%s: Failed to put parent event id", __func__);
957 return false;
958 }
959 }
960
961 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pEvent->uuidApplicationType))
962 {
963 rzb_log(LOG_ERR, "%s: Failed to put app type", __func__);
964 return false;
965 }
966
967 if (!BinaryBuffer_Put_NTLVList (p_pBuffer, p_pEvent->pMetaDataList))
968 {
969 rzb_log(LOG_ERR, "%s: Failed to put metadata list", __func__);
970 return false;
971 }
972 if (!BinaryBuffer_Put_Block (p_pBuffer, p_pEvent->pBlock))
973 {
974 rzb_log(LOG_ERR, "%s: Failed to put block", __func__);
975 return false;
976 }
977 return true;
978 }
979
980 bool
BinaryBuffer_Get_Event(struct BinaryBuffer * p_pBuffer,struct Event ** p_pEvent)981 BinaryBuffer_Get_Event (struct BinaryBuffer *p_pBuffer,
982 struct Event **p_pEvent)
983 {
984 struct Event *l_pEvent;
985 uint8_t l_iHas;
986
987 if ((l_pEvent = calloc(1, sizeof (struct Event))) == NULL)
988 {
989 *p_pEvent = NULL;
990 return false;
991 }
992
993 if (!BinaryBuffer_Get_EventId (p_pBuffer, &l_pEvent->pId))
994 {
995 rzb_log(LOG_ERR, "%s: Failed to get event id", __func__);
996 Event_Destroy(l_pEvent);
997 *p_pEvent = NULL;
998 return false;
999 }
1000
1001 if (!BinaryBuffer_Get_uint8_t (p_pBuffer, &l_iHas))
1002 {
1003 rzb_log(LOG_ERR, "%s: Failed to get event id marker", __func__);
1004 Event_Destroy(l_pEvent);
1005 *p_pEvent = NULL;
1006 return false;
1007 }
1008 if (l_iHas == 1)
1009 {
1010 if (!BinaryBuffer_Get_EventId (p_pBuffer, &l_pEvent->pParentId))
1011 {
1012 rzb_log(LOG_ERR, "%s: Failed to get message", __func__);
1013 Event_Destroy(l_pEvent);
1014 *p_pEvent = NULL;
1015 return false;
1016 }
1017 }
1018
1019 if (!BinaryBuffer_Get_UUID (p_pBuffer, l_pEvent->uuidApplicationType))
1020 {
1021 rzb_log(LOG_ERR, "%s: Failed to get app type", __func__);
1022 Event_Destroy(l_pEvent);
1023 *p_pEvent = NULL;
1024 return false;
1025 }
1026 if (!BinaryBuffer_Get_NTLVList (p_pBuffer, &l_pEvent->pMetaDataList))
1027 {
1028 rzb_log(LOG_ERR, "%s: Failed to get metadata list", __func__);
1029 Event_Destroy(l_pEvent);
1030 *p_pEvent = NULL;
1031 return false;
1032 }
1033 if (!BinaryBuffer_Get_Block (p_pBuffer, &l_pEvent->pBlock))
1034 {
1035 rzb_log(LOG_ERR, "%s: Failed to get block", __func__);
1036 Event_Destroy(l_pEvent);
1037 *p_pEvent = NULL;
1038 return false;
1039 }
1040 *p_pEvent = l_pEvent;
1041 return true;
1042 }
1043
1044 bool
BinaryBuffer_Put_Judgment(struct BinaryBuffer * p_pBuffer,struct Judgment * p_pJudgment)1045 BinaryBuffer_Put_Judgment (struct BinaryBuffer *p_pBuffer,
1046 struct Judgment *p_pJudgment)
1047 {
1048 if (!BinaryBuffer_Put_UUID (p_pBuffer, p_pJudgment->uuidNuggetId))
1049 {
1050 rzb_log(LOG_ERR, "%s: Failed to put nugget id", __func__);
1051 return false;
1052 }
1053 if (!BinaryBuffer_Put_uint64_t (p_pBuffer, p_pJudgment->iSeconds))
1054 {
1055 rzb_log(LOG_ERR, "%s: Failed to put seconds", __func__);
1056 return false;
1057 }
1058 if (!BinaryBuffer_Put_uint64_t (p_pBuffer, p_pJudgment->iNanoSecs))
1059 {
1060 rzb_log(LOG_ERR, "%s: Failed to put nano seconds", __func__);
1061 return false;
1062 }
1063
1064 if (!BinaryBuffer_Put_EventId (p_pBuffer, p_pJudgment->pEventId))
1065 {
1066 rzb_log(LOG_ERR, "%s: Failed to put event id", __func__);
1067 return false;
1068 }
1069
1070 if (!BinaryBuffer_Put_BlockId (p_pBuffer, p_pJudgment->pBlockId))
1071 {
1072 rzb_log(LOG_ERR, "%s: Failed to put block id", __func__);
1073 return false;
1074 }
1075
1076 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, p_pJudgment->iPriority))
1077 {
1078 rzb_log(LOG_ERR, "%s: Failed to put priority type", __func__);
1079 return false;
1080 }
1081
1082 if (!BinaryBuffer_Put_NTLVList (p_pBuffer, p_pJudgment->pMetaDataList))
1083 {
1084 rzb_log(LOG_ERR, "%s: Failed to put metadata list", __func__);
1085 return false;
1086 }
1087 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->iGID))
1088 {
1089 rzb_log(LOG_ERR, "%s: Failed to put GID", __func__);
1090 return false;
1091 }
1092 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->iSID))
1093 {
1094 rzb_log(LOG_ERR, "%s: Failed to put SID", __func__);
1095 return false;
1096 }
1097 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->Set_SfFlags))
1098 {
1099 rzb_log(LOG_ERR, "%s: Failed to put set sf flags", __func__);
1100 return false;
1101 }
1102 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->Set_EntFlags))
1103 {
1104 rzb_log(LOG_ERR, "%s: Failed to put set ent flags", __func__);
1105 return false;
1106 }
1107 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->Unset_SfFlags))
1108 {
1109 rzb_log(LOG_ERR, "%s: Failed to put unset sf flags", __func__);
1110 return false;
1111 }
1112 if (!BinaryBuffer_Put_uint32_t (p_pBuffer, p_pJudgment->Unset_EntFlags))
1113 {
1114 rzb_log(LOG_ERR, "%s: Failed to put unset ent flags", __func__);
1115 return false;
1116 }
1117 if (p_pJudgment->sMessage == NULL)
1118 {
1119 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 0))
1120 {
1121 rzb_log(LOG_ERR, "%s: Failed to put priority type", __func__);
1122 return false;
1123 }
1124 }
1125 else
1126 {
1127 if (!BinaryBuffer_Put_uint8_t (p_pBuffer, 1))
1128 {
1129 rzb_log(LOG_ERR, "%s: Failed to put priority type", __func__);
1130 return false;
1131 }
1132 if (!BinaryBuffer_Put_String (p_pBuffer, p_pJudgment->sMessage))
1133 {
1134 rzb_log(LOG_ERR, "%s: Failed to put message", __func__);
1135 return false;
1136 }
1137 }
1138 return true;
1139 }
1140
1141 bool
BinaryBuffer_Get_Judgment(struct BinaryBuffer * p_pBuffer,struct Judgment ** p_pJudgment)1142 BinaryBuffer_Get_Judgment (struct BinaryBuffer *p_pBuffer,
1143 struct Judgment **p_pJudgment)
1144 {
1145 struct Judgment *l_pJudgment;
1146 uint8_t l_iHas = 0;
1147 if ((l_pJudgment = calloc(1, sizeof (struct Judgment))) == NULL)
1148 {
1149 *p_pJudgment = NULL;
1150 return false;
1151 }
1152
1153 if (!BinaryBuffer_Get_UUID (p_pBuffer, l_pJudgment->uuidNuggetId))
1154 {
1155 rzb_log(LOG_ERR, "%s: Failed to get Nugget Id", __func__);
1156 Judgment_Destroy(l_pJudgment);
1157 *p_pJudgment = NULL;
1158 return false;
1159 }
1160 if (!BinaryBuffer_Get_uint64_t (p_pBuffer, &l_pJudgment->iSeconds))
1161 {
1162 rzb_log(LOG_ERR, "%s: Failed to get seconds", __func__);
1163 Judgment_Destroy(l_pJudgment);
1164 *p_pJudgment = NULL;
1165 return false;
1166 }
1167 if (!BinaryBuffer_Get_uint64_t (p_pBuffer, &l_pJudgment->iNanoSecs))
1168 {
1169 rzb_log(LOG_ERR, "%s: Failed to get nano seconds", __func__);
1170 Judgment_Destroy(l_pJudgment);
1171 *p_pJudgment = NULL;
1172 return false;
1173 }
1174 if (!BinaryBuffer_Get_EventId (p_pBuffer, &l_pJudgment->pEventId))
1175 {
1176 rzb_log(LOG_ERR, "%s: Failed to get event id", __func__);
1177 Judgment_Destroy(l_pJudgment);
1178 *p_pJudgment = NULL;
1179 return false;
1180 }
1181 if (!BinaryBuffer_Get_BlockId (p_pBuffer, &l_pJudgment->pBlockId))
1182 {
1183 rzb_log(LOG_ERR, "%s: Failed to get block id", __func__);
1184 Judgment_Destroy(l_pJudgment);
1185 *p_pJudgment = NULL;
1186 return false;
1187 }
1188 if (!BinaryBuffer_Get_uint8_t (p_pBuffer, &l_pJudgment->iPriority))
1189 {
1190 rzb_log(LOG_ERR, "%s: Failed to get priority", __func__);
1191 Judgment_Destroy(l_pJudgment);
1192 *p_pJudgment = NULL;
1193 return false;
1194 }
1195 if (!BinaryBuffer_Get_NTLVList (p_pBuffer, &l_pJudgment->pMetaDataList))
1196 {
1197 rzb_log(LOG_ERR, "%s: Failed to get metadata list", __func__);
1198 Judgment_Destroy(l_pJudgment);
1199 *p_pJudgment = NULL;
1200 return false;
1201 }
1202 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->iGID))
1203 {
1204 rzb_log(LOG_ERR, "%s: Failed to get GID", __func__);
1205 Judgment_Destroy(l_pJudgment);
1206 *p_pJudgment = NULL;
1207 return false;
1208 }
1209 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->iSID))
1210 {
1211 rzb_log(LOG_ERR, "%s: Failed to get SID", __func__);
1212 Judgment_Destroy(l_pJudgment);
1213 *p_pJudgment = NULL;
1214 return false;
1215 }
1216 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->Set_SfFlags))
1217 {
1218 rzb_log(LOG_ERR, "%s: Failed to get set sf flags", __func__);
1219 Judgment_Destroy(l_pJudgment);
1220 *p_pJudgment = NULL;
1221 return false;
1222 }
1223 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->Set_EntFlags))
1224 {
1225 rzb_log(LOG_ERR, "%s: Failed to get set ent flags", __func__);
1226 Judgment_Destroy(l_pJudgment);
1227 *p_pJudgment = NULL;
1228 return false;
1229 }
1230 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->Unset_SfFlags))
1231 {
1232 rzb_log(LOG_ERR, "%s: Failed to get unset sf flags", __func__);
1233 Judgment_Destroy(l_pJudgment);
1234 *p_pJudgment = NULL;
1235 return false;
1236 }
1237 if (!BinaryBuffer_Get_uint32_t (p_pBuffer, &l_pJudgment->Unset_EntFlags))
1238 {
1239 rzb_log(LOG_ERR, "%s: Failed to get unset sf flags", __func__);
1240 Judgment_Destroy(l_pJudgment);
1241 *p_pJudgment = NULL;
1242 return false;
1243 }
1244 if (!BinaryBuffer_Get_uint8_t (p_pBuffer, &l_iHas))
1245 {
1246 rzb_log(LOG_ERR, "%s: Failed to get unset sf flags", __func__);
1247 Judgment_Destroy(l_pJudgment);
1248 *p_pJudgment = NULL;
1249 return false;
1250 }
1251 if (l_iHas == 1)
1252 {
1253 if ((l_pJudgment->sMessage =BinaryBuffer_Get_String (p_pBuffer)) == NULL)
1254 {
1255 rzb_log(LOG_ERR, "%s: Failed to get message", __func__);
1256 Judgment_Destroy(l_pJudgment);
1257 *p_pJudgment = NULL;
1258 return false;
1259 }
1260 }
1261
1262 *p_pJudgment = l_pJudgment;
1263 return true;
1264 }
1265
1266 bool
BinaryBuffer_Get_UUIDList(struct BinaryBuffer * buffer,struct List ** r_list)1267 BinaryBuffer_Get_UUIDList(struct BinaryBuffer *buffer, struct List **r_list)
1268 {
1269 struct List *list;
1270 uint32_t count;
1271 uuid_t *uuids = NULL;
1272 uint32_t namesSize;
1273 char *names = NULL;
1274 char *curStr;
1275 uuid_t *curUuid;
1276 uint32_t pos = 0;
1277
1278 if ((list = UUID_Create_List()) == NULL)
1279 return false;
1280 if (!BinaryBuffer_Get_uint32_t(buffer, &count))
1281 {
1282 rzb_log(LOG_ERR, "%s: Failed to get NTLV Type Count", __func__);
1283 return false;
1284 }
1285 if (!BinaryBuffer_Get_uint32_t(buffer, &namesSize))
1286 {
1287 rzb_log(LOG_ERR, "%s: Failed to get NTLV Type name size", __func__);
1288 return false;
1289 }
1290 // Remove the UUIDs
1291 namesSize -= (count*16);
1292 if (count > 0)
1293 {
1294 uuids = calloc(count, sizeof(uuid_t));
1295 names = calloc(namesSize, sizeof(char));
1296 if ((uuids == NULL ) ||
1297 (names == NULL ) )
1298 {
1299 free(names);
1300 free(uuids);
1301 rzb_log(LOG_ERR, "%s: failed to allocate income message structures", __func__);
1302 return false;
1303 }
1304 if (!BinaryBuffer_Get_ByteArray(buffer, count * sizeof(uuid_t), (uint8_t*)uuids))
1305 {
1306 free(names);
1307 free(uuids);
1308 rzb_log(LOG_ERR, "%s: failed to read Types uuids", __func__);
1309 return false;
1310 }
1311
1312 if (!BinaryBuffer_Get_ByteArray(buffer, namesSize * sizeof(char), (uint8_t*)names))
1313 {
1314 free(names);
1315 free(uuids);
1316 rzb_log(LOG_ERR, "%s: failed to read Types names", __func__);
1317 return false;
1318 }
1319 curStr = names;
1320 curUuid = uuids;
1321 for (pos =0; pos < count; pos++)
1322 {
1323 UUID_Add_List_Entry(list, *curUuid, curStr, "");
1324 curStr = curStr + strlen(curStr) +1;
1325 curUuid+=1;
1326 }
1327 free(names);
1328 free(uuids);
1329 }
1330 *r_list = list;
1331 return true;
1332 }
1333
1334 struct UUID_ListStatus
1335 {
1336 uuid_t *curUuid;
1337 char *curString;
1338 };
1339
1340 static int
BinaryBuffer_UUIDList_AddData(void * vItem,void * vStatus)1341 BinaryBuffer_UUIDList_AddData(void *vItem, void *vStatus)
1342 {
1343 struct UUIDListNode *item = (struct UUIDListNode *)vItem;
1344 struct UUID_ListStatus *status = (struct UUID_ListStatus *)vStatus;
1345
1346 memcpy(status->curString, item->sName, strlen(item->sName)+1);
1347 status->curString += strlen(item->sName)+1;
1348 uuid_copy(*status->curUuid, item->uuid);
1349 status->curUuid++;
1350 return LIST_EACH_OK;
1351 }
1352
1353
1354 bool
BinaryBuffer_Put_UUIDList(struct BinaryBuffer * buffer,struct List * list)1355 BinaryBuffer_Put_UUIDList(struct BinaryBuffer *buffer, struct List *list)
1356 {
1357 uint8_t *data;
1358 uint32_t size = UUIDList_BinarySize(list);
1359 uint32_t count = List_Length(list);
1360 struct UUID_ListStatus listStatus;
1361 if ((data = calloc(size,sizeof(uint8_t))) == NULL)
1362 return false;
1363
1364 if (!BinaryBuffer_Put_uint32_t(buffer, count))
1365 {
1366 rzb_log(LOG_ERR, "%s: Failed to put UUID Count", __func__);
1367 return false;
1368 }
1369 if (!BinaryBuffer_Put_uint32_t(buffer, size))
1370 {
1371 rzb_log(LOG_ERR, "%s: Failed to put UUID size", __func__);
1372 return false;
1373 }
1374 listStatus.curUuid = (uuid_t *)data;
1375 listStatus.curString = (char *)(data+(count*16));
1376 List_ForEach(list, BinaryBuffer_UUIDList_AddData, &listStatus);
1377
1378 BinaryBuffer_Put_ByteArray(buffer, size, data);
1379
1380
1381 free(data);
1382 return true;
1383 }
1384
1385 bool
BinaryBuffer_Get_StringList(struct BinaryBuffer * buffer,struct List ** r_list)1386 BinaryBuffer_Get_StringList(struct BinaryBuffer *buffer, struct List **r_list)
1387 {
1388 struct List *list;
1389 uint32_t count;
1390 uint32_t pos = 0;
1391 char *item;
1392
1393 if ((list = StringList_Create()) == NULL)
1394 return false;
1395 if (!BinaryBuffer_Get_uint32_t(buffer, &count))
1396 {
1397 rzb_log(LOG_ERR, "%s: Failed to get NTLV Type Count", __func__);
1398 return false;
1399 }
1400 for (pos = 0; pos < count; pos++)
1401 {
1402 item = (char *)BinaryBuffer_Get_String(buffer);
1403 StringList_Add(list, item);
1404 free(item);
1405
1406 }
1407 return true;
1408 }
1409
1410 static int
BinaryBuffer_Put_StringListItem(void * vItem,void * vBuffer)1411 BinaryBuffer_Put_StringListItem(void *vItem, void *vBuffer)
1412 {
1413 struct BinaryBuffer *buffer = vBuffer;
1414 uint8_t *item = vItem;
1415
1416 if (!BinaryBuffer_Put_String(buffer, item))
1417 return LIST_EACH_ERROR;
1418
1419 return LIST_EACH_OK;
1420 }
1421
1422 bool
BinaryBuffer_Put_StringList(struct BinaryBuffer * buffer,struct List * list)1423 BinaryBuffer_Put_StringList(struct BinaryBuffer *buffer, struct List *list)
1424 {
1425 uint32_t count = List_Length(list);
1426
1427 if (!BinaryBuffer_Put_uint32_t(buffer, count))
1428 {
1429 rzb_log(LOG_ERR, "%s: Failed to put UUID Count", __func__);
1430 return false;
1431 }
1432 if (!List_ForEach(list, BinaryBuffer_Put_StringListItem, buffer))
1433 return false;
1434
1435 return true;
1436 }
1437