CORDET Framework - C2 Implementation
CrPsPktServReqVerif.h
Go to the documentation of this file.
1 
23 #ifndef CRPSPKTSERVREQVERIF_H_
24 #define CRPSPKTSERVREQVERIF_H_
25 
26 #include "CrFwUserConstants.h"
27 #include "CrPsUserConstants.h"
28 #include "CrPsPkt.h"
29 
33 typedef struct __attribute__((packed)) _VerSuccessAccRep_t {
37  TmHeader_t Header;
38 
42  uint8_t block_5[2];
43 
47  uint8_t block_18[2];
48 
49 } VerSuccessAccRep_t ;
50 
54 typedef struct __attribute__((packed)) _VerFailedAccRep_t {
58  TmHeader_t Header;
59 
63  uint8_t block_5[2];
64 
68  uint8_t block_18[2];
69 
73  CrPsFailCode_t FailureCode;
74 
78  CrPsFailData_t FailureData;
79 
80 } VerFailedAccRep_t ;
81 
85 typedef struct __attribute__((packed)) _VerSuccessStartRep_t {
89  TmHeader_t Header;
90 
94  uint8_t block_5[2];
95 
99  uint8_t block_18[2];
100 
101 } VerSuccessStartRep_t ;
102 
106 typedef struct __attribute__((packed)) _VerFailedStartRep_t {
110  TmHeader_t Header;
111 
115  uint8_t block_5[2];
116 
120  uint8_t block_18[2];
121 
125  CrPsFailCode_t FailureCode;
126 
130  CrPsFailData_t FailureData;
131 
132 } VerFailedStartRep_t ;
133 
137 typedef struct __attribute__((packed)) _VerSuccessPrgrRep_t {
141  TmHeader_t Header;
142 
146  uint8_t block_5[2];
147 
151  uint8_t block_18[2];
152 
156  CrPsStepId_t StepId;
157 
158 } VerSuccessPrgrRep_t ;
159 
163 typedef struct __attribute__((packed)) _VerFailedPrgrRep_t {
167  TmHeader_t Header;
168 
172  uint8_t block_5[2];
173 
177  uint8_t block_18[2];
178 
182  CrPsStepId_t StepId;
183 
187  CrPsFailCode_t FailureCode;
188 
192  CrPsFailData_t FailureData;
193 
194 } VerFailedPrgrRep_t ;
195 
199 typedef struct __attribute__((packed)) _VerSuccessTermRep_t {
203  TmHeader_t Header;
204 
208  uint8_t block_5[2];
209 
213  uint8_t block_18[2];
214 
215 } VerSuccessTermRep_t ;
216 
220 typedef struct __attribute__((packed)) _VerFailedTermRep_t {
224  TmHeader_t Header;
225 
229  uint8_t block_5[2];
230 
234  uint8_t block_18[2];
235 
239  CrPsFailCode_t FailureCode;
240 
244  CrPsFailData_t FailureData;
245 
246 } VerFailedTermRep_t ;
247 
251 typedef struct __attribute__((packed)) _VerFailedRoutingRep_t {
255  TmHeader_t Header;
256 
260  uint8_t block_5[2];
261 
265  uint8_t block_18[2];
266 
270  CrPsFailCode_t FailureCode;
271 
275  CrPsFailData_t FailureData;
276 
277 } VerFailedRoutingRep_t ;
278 
284 static inline Three_Bit_t getVerSuccessAccRepPcktVersionNmb(void* p)
285 {
286  uint16_t t;
287  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
288  t = __builtin_bswap16(t);
289  t >>= 13;
290  t &= 0x7;
291  return (Three_Bit_t)t;
292 }
293 
299 static inline void setVerSuccessAccRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
300 {
301  uint16_t s;
302  uint16_t t;
303  s = ((uint16_t)PcktVersionNmb << 13);
304  s &= (uint16_t)0xe000;
305  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
306  t = __builtin_bswap16(t);
307  t &= (uint16_t)~0xe000;
308  t |= s;
309  t = __builtin_bswap16(t);
310  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
311 }
312 
318 static inline One_Bit_t getVerSuccessAccRepPcktType(void* p)
319 {
320  uint16_t t;
321  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
322  t = __builtin_bswap16(t);
323  t >>= 12;
324  t &= 0x1;
325  return (One_Bit_t)t;
326 }
327 
333 static inline void setVerSuccessAccRepPcktType(void* p, One_Bit_t PcktType)
334 {
335  uint16_t s;
336  uint16_t t;
337  s = ((uint16_t)PcktType << 12);
338  s &= (uint16_t)0x1000;
339  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
340  t = __builtin_bswap16(t);
341  t &= (uint16_t)~0x1000;
342  t |= s;
343  t = __builtin_bswap16(t);
344  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
345 }
346 
352 static inline One_Bit_t getVerSuccessAccRepSecHeaderFlag(void* p)
353 {
354  uint16_t t;
355  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
356  t = __builtin_bswap16(t);
357  t >>= 11;
358  t &= 0x1;
359  return (One_Bit_t)t;
360 }
361 
367 static inline void setVerSuccessAccRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
368 {
369  uint16_t s;
370  uint16_t t;
371  s = ((uint16_t)SecHeaderFlag << 11);
372  s &= (uint16_t)0x800;
373  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
374  t = __builtin_bswap16(t);
375  t &= (uint16_t)~0x800;
376  t |= s;
377  t = __builtin_bswap16(t);
378  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
379 }
380 
386 static inline Eleven_Bit_t getVerSuccessAccRepAPID(void* p)
387 {
388  uint32_t t;
389  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
390  t = __builtin_bswap32(t);
391  t >>= 16;
392  t &= 0x7ff;
393  return (Eleven_Bit_t)t;
394 }
395 
401 static inline void setVerSuccessAccRepAPID(void* p, Eleven_Bit_t APID)
402 {
403  uint32_t s;
404  uint32_t t;
405  s = ((uint32_t)APID << 16);
406  s &= (uint32_t)0x7ff0000;
407  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
408  t = __builtin_bswap32(t);
409  t &= (uint32_t)~0x7ff0000;
410  t |= s;
411  t = __builtin_bswap32(t);
412  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
413 }
414 
420 static inline Two_Bit_t getVerSuccessAccRepSeqFlags(void* p)
421 {
422  uint16_t t;
423  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
424  t = __builtin_bswap16(t);
425  t >>= 14;
426  t &= 0x3;
427  return (Two_Bit_t)t;
428 }
429 
435 static inline void setVerSuccessAccRepSeqFlags(void* p, Two_Bit_t SeqFlags)
436 {
437  uint16_t s;
438  uint16_t t;
439  s = ((uint16_t)SeqFlags << 14);
440  s &= (uint16_t)0xc000;
441  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
442  t = __builtin_bswap16(t);
443  t &= (uint16_t)~0xc000;
444  t |= s;
445  t = __builtin_bswap16(t);
446  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
447 }
448 
454 static inline FourTeen_Bit_t getVerSuccessAccRepSeqCount(void* p)
455 {
456  uint32_t t;
457  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
458  t = __builtin_bswap32(t);
459  t >>= 16;
460  t &= 0x3fff;
461  return (FourTeen_Bit_t)t;
462 }
463 
469 static inline void setVerSuccessAccRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
470 {
471  uint32_t s;
472  uint32_t t;
473  s = ((uint32_t)SeqCount << 16);
474  s &= (uint32_t)0x3fff0000;
475  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
476  t = __builtin_bswap32(t);
477  t &= (uint32_t)~0x3fff0000;
478  t |= s;
479  t = __builtin_bswap32(t);
480  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
481 }
482 
488 static inline Three_Bit_t getVerFailedAccRepPcktVersionNmb(void* p)
489 {
490  uint16_t t;
491  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
492  t = __builtin_bswap16(t);
493  t >>= 13;
494  t &= 0x7;
495  return (Three_Bit_t)t;
496 }
497 
503 static inline void setVerFailedAccRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
504 {
505  uint16_t s;
506  uint16_t t;
507  s = ((uint16_t)PcktVersionNmb << 13);
508  s &= (uint16_t)0xe000;
509  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
510  t = __builtin_bswap16(t);
511  t &= (uint16_t)~0xe000;
512  t |= s;
513  t = __builtin_bswap16(t);
514  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
515 }
516 
522 static inline One_Bit_t getVerFailedAccRepPcktType(void* p)
523 {
524  uint16_t t;
525  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
526  t = __builtin_bswap16(t);
527  t >>= 12;
528  t &= 0x1;
529  return (One_Bit_t)t;
530 }
531 
537 static inline void setVerFailedAccRepPcktType(void* p, One_Bit_t PcktType)
538 {
539  uint16_t s;
540  uint16_t t;
541  s = ((uint16_t)PcktType << 12);
542  s &= (uint16_t)0x1000;
543  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
544  t = __builtin_bswap16(t);
545  t &= (uint16_t)~0x1000;
546  t |= s;
547  t = __builtin_bswap16(t);
548  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
549 }
550 
556 static inline One_Bit_t getVerFailedAccRepSecHeaderFlag(void* p)
557 {
558  uint16_t t;
559  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
560  t = __builtin_bswap16(t);
561  t >>= 11;
562  t &= 0x1;
563  return (One_Bit_t)t;
564 }
565 
571 static inline void setVerFailedAccRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
572 {
573  uint16_t s;
574  uint16_t t;
575  s = ((uint16_t)SecHeaderFlag << 11);
576  s &= (uint16_t)0x800;
577  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
578  t = __builtin_bswap16(t);
579  t &= (uint16_t)~0x800;
580  t |= s;
581  t = __builtin_bswap16(t);
582  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
583 }
584 
590 static inline Eleven_Bit_t getVerFailedAccRepAPID(void* p)
591 {
592  uint32_t t;
593  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
594  t = __builtin_bswap32(t);
595  t >>= 16;
596  t &= 0x7ff;
597  return (Eleven_Bit_t)t;
598 }
599 
605 static inline void setVerFailedAccRepAPID(void* p, Eleven_Bit_t APID)
606 {
607  uint32_t s;
608  uint32_t t;
609  s = ((uint32_t)APID << 16);
610  s &= (uint32_t)0x7ff0000;
611  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
612  t = __builtin_bswap32(t);
613  t &= (uint32_t)~0x7ff0000;
614  t |= s;
615  t = __builtin_bswap32(t);
616  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
617 }
618 
624 static inline Two_Bit_t getVerFailedAccRepSeqFlags(void* p)
625 {
626  uint16_t t;
627  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
628  t = __builtin_bswap16(t);
629  t >>= 14;
630  t &= 0x3;
631  return (Two_Bit_t)t;
632 }
633 
639 static inline void setVerFailedAccRepSeqFlags(void* p, Two_Bit_t SeqFlags)
640 {
641  uint16_t s;
642  uint16_t t;
643  s = ((uint16_t)SeqFlags << 14);
644  s &= (uint16_t)0xc000;
645  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
646  t = __builtin_bswap16(t);
647  t &= (uint16_t)~0xc000;
648  t |= s;
649  t = __builtin_bswap16(t);
650  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
651 }
652 
658 static inline FourTeen_Bit_t getVerFailedAccRepSeqCount(void* p)
659 {
660  uint32_t t;
661  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
662  t = __builtin_bswap32(t);
663  t >>= 16;
664  t &= 0x3fff;
665  return (FourTeen_Bit_t)t;
666 }
667 
673 static inline void setVerFailedAccRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
674 {
675  uint32_t s;
676  uint32_t t;
677  s = ((uint32_t)SeqCount << 16);
678  s &= (uint32_t)0x3fff0000;
679  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
680  t = __builtin_bswap32(t);
681  t &= (uint32_t)~0x3fff0000;
682  t |= s;
683  t = __builtin_bswap32(t);
684  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
685 }
686 
693 {
694  VerFailedAccRep_t* t;
695  t = (VerFailedAccRep_t*)p;
696  return __builtin_bswap16(t->FailureCode);
697 }
698 
704 static inline void setVerFailedAccRepFailureCode(void* p, CrPsFailCode_t FailureCode)
705 {
706  VerFailedAccRep_t* t;
707  t = (VerFailedAccRep_t*)p;
708  t->FailureCode = __builtin_bswap16(FailureCode);
709 }
710 
717 {
718  VerFailedAccRep_t* t;
719  t = (VerFailedAccRep_t*)p;
720  return __builtin_bswap32(t->FailureData);
721 }
722 
728 static inline void setVerFailedAccRepFailureData(void* p, CrPsFailData_t FailureData)
729 {
730  VerFailedAccRep_t* t;
731  t = (VerFailedAccRep_t*)p;
732  t->FailureData = __builtin_bswap32(FailureData);
733 }
734 
740 static inline Three_Bit_t getVerSuccessStartRepPcktVersionNmb(void* p)
741 {
742  uint16_t t;
743  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
744  t = __builtin_bswap16(t);
745  t >>= 13;
746  t &= 0x7;
747  return (Three_Bit_t)t;
748 }
749 
755 static inline void setVerSuccessStartRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
756 {
757  uint16_t s;
758  uint16_t t;
759  s = ((uint16_t)PcktVersionNmb << 13);
760  s &= (uint16_t)0xe000;
761  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
762  t = __builtin_bswap16(t);
763  t &= (uint16_t)~0xe000;
764  t |= s;
765  t = __builtin_bswap16(t);
766  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
767 }
768 
774 static inline One_Bit_t getVerSuccessStartRepPcktType(void* p)
775 {
776  uint16_t t;
777  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
778  t = __builtin_bswap16(t);
779  t >>= 12;
780  t &= 0x1;
781  return (One_Bit_t)t;
782 }
783 
789 static inline void setVerSuccessStartRepPcktType(void* p, One_Bit_t PcktType)
790 {
791  uint16_t s;
792  uint16_t t;
793  s = ((uint16_t)PcktType << 12);
794  s &= (uint16_t)0x1000;
795  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
796  t = __builtin_bswap16(t);
797  t &= (uint16_t)~0x1000;
798  t |= s;
799  t = __builtin_bswap16(t);
800  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
801 }
802 
808 static inline One_Bit_t getVerSuccessStartRepSecHeaderFlag(void* p)
809 {
810  uint16_t t;
811  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
812  t = __builtin_bswap16(t);
813  t >>= 11;
814  t &= 0x1;
815  return (One_Bit_t)t;
816 }
817 
823 static inline void setVerSuccessStartRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
824 {
825  uint16_t s;
826  uint16_t t;
827  s = ((uint16_t)SecHeaderFlag << 11);
828  s &= (uint16_t)0x800;
829  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
830  t = __builtin_bswap16(t);
831  t &= (uint16_t)~0x800;
832  t |= s;
833  t = __builtin_bswap16(t);
834  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
835 }
836 
842 static inline Eleven_Bit_t getVerSuccessStartRepAPID(void* p)
843 {
844  uint32_t t;
845  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
846  t = __builtin_bswap32(t);
847  t >>= 16;
848  t &= 0x7ff;
849  return (Eleven_Bit_t)t;
850 }
851 
857 static inline void setVerSuccessStartRepAPID(void* p, Eleven_Bit_t APID)
858 {
859  uint32_t s;
860  uint32_t t;
861  s = ((uint32_t)APID << 16);
862  s &= (uint32_t)0x7ff0000;
863  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
864  t = __builtin_bswap32(t);
865  t &= (uint32_t)~0x7ff0000;
866  t |= s;
867  t = __builtin_bswap32(t);
868  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
869 }
870 
876 static inline Two_Bit_t getVerSuccessStartRepSeqFlags(void* p)
877 {
878  uint16_t t;
879  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
880  t = __builtin_bswap16(t);
881  t >>= 14;
882  t &= 0x3;
883  return (Two_Bit_t)t;
884 }
885 
891 static inline void setVerSuccessStartRepSeqFlags(void* p, Two_Bit_t SeqFlags)
892 {
893  uint16_t s;
894  uint16_t t;
895  s = ((uint16_t)SeqFlags << 14);
896  s &= (uint16_t)0xc000;
897  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
898  t = __builtin_bswap16(t);
899  t &= (uint16_t)~0xc000;
900  t |= s;
901  t = __builtin_bswap16(t);
902  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
903 }
904 
910 static inline FourTeen_Bit_t getVerSuccessStartRepSeqCount(void* p)
911 {
912  uint32_t t;
913  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
914  t = __builtin_bswap32(t);
915  t >>= 16;
916  t &= 0x3fff;
917  return (FourTeen_Bit_t)t;
918 }
919 
925 static inline void setVerSuccessStartRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
926 {
927  uint32_t s;
928  uint32_t t;
929  s = ((uint32_t)SeqCount << 16);
930  s &= (uint32_t)0x3fff0000;
931  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
932  t = __builtin_bswap32(t);
933  t &= (uint32_t)~0x3fff0000;
934  t |= s;
935  t = __builtin_bswap32(t);
936  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
937 }
938 
944 static inline Three_Bit_t getVerFailedStartRepPcktVersionNmb(void* p)
945 {
946  uint16_t t;
947  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
948  t = __builtin_bswap16(t);
949  t >>= 13;
950  t &= 0x7;
951  return (Three_Bit_t)t;
952 }
953 
959 static inline void setVerFailedStartRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
960 {
961  uint16_t s;
962  uint16_t t;
963  s = ((uint16_t)PcktVersionNmb << 13);
964  s &= (uint16_t)0xe000;
965  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
966  t = __builtin_bswap16(t);
967  t &= (uint16_t)~0xe000;
968  t |= s;
969  t = __builtin_bswap16(t);
970  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
971 }
972 
978 static inline One_Bit_t getVerFailedStartRepPcktType(void* p)
979 {
980  uint16_t t;
981  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
982  t = __builtin_bswap16(t);
983  t >>= 12;
984  t &= 0x1;
985  return (One_Bit_t)t;
986 }
987 
993 static inline void setVerFailedStartRepPcktType(void* p, One_Bit_t PcktType)
994 {
995  uint16_t s;
996  uint16_t t;
997  s = ((uint16_t)PcktType << 12);
998  s &= (uint16_t)0x1000;
999  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1000  t = __builtin_bswap16(t);
1001  t &= (uint16_t)~0x1000;
1002  t |= s;
1003  t = __builtin_bswap16(t);
1004  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1005 }
1006 
1012 static inline One_Bit_t getVerFailedStartRepSecHeaderFlag(void* p)
1013 {
1014  uint16_t t;
1015  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1016  t = __builtin_bswap16(t);
1017  t >>= 11;
1018  t &= 0x1;
1019  return (One_Bit_t)t;
1020 }
1021 
1027 static inline void setVerFailedStartRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
1028 {
1029  uint16_t s;
1030  uint16_t t;
1031  s = ((uint16_t)SecHeaderFlag << 11);
1032  s &= (uint16_t)0x800;
1033  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1034  t = __builtin_bswap16(t);
1035  t &= (uint16_t)~0x800;
1036  t |= s;
1037  t = __builtin_bswap16(t);
1038  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1039 }
1040 
1046 static inline Eleven_Bit_t getVerFailedStartRepAPID(void* p)
1047 {
1048  uint32_t t;
1049  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1050  t = __builtin_bswap32(t);
1051  t >>= 16;
1052  t &= 0x7ff;
1053  return (Eleven_Bit_t)t;
1054 }
1055 
1061 static inline void setVerFailedStartRepAPID(void* p, Eleven_Bit_t APID)
1062 {
1063  uint32_t s;
1064  uint32_t t;
1065  s = ((uint32_t)APID << 16);
1066  s &= (uint32_t)0x7ff0000;
1067  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1068  t = __builtin_bswap32(t);
1069  t &= (uint32_t)~0x7ff0000;
1070  t |= s;
1071  t = __builtin_bswap32(t);
1072  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1073 }
1074 
1080 static inline Two_Bit_t getVerFailedStartRepSeqFlags(void* p)
1081 {
1082  uint16_t t;
1083  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1084  t = __builtin_bswap16(t);
1085  t >>= 14;
1086  t &= 0x3;
1087  return (Two_Bit_t)t;
1088 }
1089 
1095 static inline void setVerFailedStartRepSeqFlags(void* p, Two_Bit_t SeqFlags)
1096 {
1097  uint16_t s;
1098  uint16_t t;
1099  s = ((uint16_t)SeqFlags << 14);
1100  s &= (uint16_t)0xc000;
1101  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1102  t = __builtin_bswap16(t);
1103  t &= (uint16_t)~0xc000;
1104  t |= s;
1105  t = __builtin_bswap16(t);
1106  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1107 }
1108 
1114 static inline FourTeen_Bit_t getVerFailedStartRepSeqCount(void* p)
1115 {
1116  uint32_t t;
1117  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1118  t = __builtin_bswap32(t);
1119  t >>= 16;
1120  t &= 0x3fff;
1121  return (FourTeen_Bit_t)t;
1122 }
1123 
1129 static inline void setVerFailedStartRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
1130 {
1131  uint32_t s;
1132  uint32_t t;
1133  s = ((uint32_t)SeqCount << 16);
1134  s &= (uint32_t)0x3fff0000;
1135  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1136  t = __builtin_bswap32(t);
1137  t &= (uint32_t)~0x3fff0000;
1138  t |= s;
1139  t = __builtin_bswap32(t);
1140  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1141 }
1142 
1149 {
1150  VerFailedStartRep_t* t;
1151  t = (VerFailedStartRep_t*)p;
1152  return __builtin_bswap16(t->FailureCode);
1153 }
1154 
1160 static inline void setVerFailedStartRepFailureCode(void* p, CrPsFailCode_t FailureCode)
1161 {
1162  VerFailedStartRep_t* t;
1163  t = (VerFailedStartRep_t*)p;
1164  t->FailureCode = __builtin_bswap16(FailureCode);
1165 }
1166 
1173 {
1174  VerFailedStartRep_t* t;
1175  t = (VerFailedStartRep_t*)p;
1176  return __builtin_bswap32(t->FailureData);
1177 }
1178 
1184 static inline void setVerFailedStartRepFailureData(void* p, CrPsFailData_t FailureData)
1185 {
1186  VerFailedStartRep_t* t;
1187  t = (VerFailedStartRep_t*)p;
1188  t->FailureData = __builtin_bswap32(FailureData);
1189 }
1190 
1196 static inline Three_Bit_t getVerSuccessPrgrRepPcktVersionNmb(void* p)
1197 {
1198  uint16_t t;
1199  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1200  t = __builtin_bswap16(t);
1201  t >>= 13;
1202  t &= 0x7;
1203  return (Three_Bit_t)t;
1204 }
1205 
1211 static inline void setVerSuccessPrgrRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
1212 {
1213  uint16_t s;
1214  uint16_t t;
1215  s = ((uint16_t)PcktVersionNmb << 13);
1216  s &= (uint16_t)0xe000;
1217  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1218  t = __builtin_bswap16(t);
1219  t &= (uint16_t)~0xe000;
1220  t |= s;
1221  t = __builtin_bswap16(t);
1222  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1223 }
1224 
1230 static inline One_Bit_t getVerSuccessPrgrRepPcktType(void* p)
1231 {
1232  uint16_t t;
1233  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1234  t = __builtin_bswap16(t);
1235  t >>= 12;
1236  t &= 0x1;
1237  return (One_Bit_t)t;
1238 }
1239 
1245 static inline void setVerSuccessPrgrRepPcktType(void* p, One_Bit_t PcktType)
1246 {
1247  uint16_t s;
1248  uint16_t t;
1249  s = ((uint16_t)PcktType << 12);
1250  s &= (uint16_t)0x1000;
1251  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1252  t = __builtin_bswap16(t);
1253  t &= (uint16_t)~0x1000;
1254  t |= s;
1255  t = __builtin_bswap16(t);
1256  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1257 }
1258 
1264 static inline One_Bit_t getVerSuccessPrgrRepSecHeaderFlag(void* p)
1265 {
1266  uint16_t t;
1267  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1268  t = __builtin_bswap16(t);
1269  t >>= 11;
1270  t &= 0x1;
1271  return (One_Bit_t)t;
1272 }
1273 
1279 static inline void setVerSuccessPrgrRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
1280 {
1281  uint16_t s;
1282  uint16_t t;
1283  s = ((uint16_t)SecHeaderFlag << 11);
1284  s &= (uint16_t)0x800;
1285  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1286  t = __builtin_bswap16(t);
1287  t &= (uint16_t)~0x800;
1288  t |= s;
1289  t = __builtin_bswap16(t);
1290  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1291 }
1292 
1298 static inline Eleven_Bit_t getVerSuccessPrgrRepAPID(void* p)
1299 {
1300  uint32_t t;
1301  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1302  t = __builtin_bswap32(t);
1303  t >>= 16;
1304  t &= 0x7ff;
1305  return (Eleven_Bit_t)t;
1306 }
1307 
1313 static inline void setVerSuccessPrgrRepAPID(void* p, Eleven_Bit_t APID)
1314 {
1315  uint32_t s;
1316  uint32_t t;
1317  s = ((uint32_t)APID << 16);
1318  s &= (uint32_t)0x7ff0000;
1319  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1320  t = __builtin_bswap32(t);
1321  t &= (uint32_t)~0x7ff0000;
1322  t |= s;
1323  t = __builtin_bswap32(t);
1324  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1325 }
1326 
1332 static inline Two_Bit_t getVerSuccessPrgrRepSeqFlags(void* p)
1333 {
1334  uint16_t t;
1335  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1336  t = __builtin_bswap16(t);
1337  t >>= 14;
1338  t &= 0x3;
1339  return (Two_Bit_t)t;
1340 }
1341 
1347 static inline void setVerSuccessPrgrRepSeqFlags(void* p, Two_Bit_t SeqFlags)
1348 {
1349  uint16_t s;
1350  uint16_t t;
1351  s = ((uint16_t)SeqFlags << 14);
1352  s &= (uint16_t)0xc000;
1353  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1354  t = __builtin_bswap16(t);
1355  t &= (uint16_t)~0xc000;
1356  t |= s;
1357  t = __builtin_bswap16(t);
1358  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1359 }
1360 
1366 static inline FourTeen_Bit_t getVerSuccessPrgrRepSeqCount(void* p)
1367 {
1368  uint32_t t;
1369  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1370  t = __builtin_bswap32(t);
1371  t >>= 16;
1372  t &= 0x3fff;
1373  return (FourTeen_Bit_t)t;
1374 }
1375 
1381 static inline void setVerSuccessPrgrRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
1382 {
1383  uint32_t s;
1384  uint32_t t;
1385  s = ((uint32_t)SeqCount << 16);
1386  s &= (uint32_t)0x3fff0000;
1387  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1388  t = __builtin_bswap32(t);
1389  t &= (uint32_t)~0x3fff0000;
1390  t |= s;
1391  t = __builtin_bswap32(t);
1392  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1393 }
1394 
1401 {
1402  VerSuccessPrgrRep_t* t;
1403  t = (VerSuccessPrgrRep_t*)p;
1404  return __builtin_bswap32(t->StepId);
1405 }
1406 
1412 static inline void setVerSuccessPrgrRepStepId(void* p, CrPsStepId_t StepId)
1413 {
1414  VerSuccessPrgrRep_t* t;
1415  t = (VerSuccessPrgrRep_t*)p;
1416  t->StepId = __builtin_bswap32(StepId);
1417 }
1418 
1424 static inline Three_Bit_t getVerFailedPrgrRepPcktVersionNmb(void* p)
1425 {
1426  uint16_t t;
1427  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1428  t = __builtin_bswap16(t);
1429  t >>= 13;
1430  t &= 0x7;
1431  return (Three_Bit_t)t;
1432 }
1433 
1439 static inline void setVerFailedPrgrRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
1440 {
1441  uint16_t s;
1442  uint16_t t;
1443  s = ((uint16_t)PcktVersionNmb << 13);
1444  s &= (uint16_t)0xe000;
1445  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1446  t = __builtin_bswap16(t);
1447  t &= (uint16_t)~0xe000;
1448  t |= s;
1449  t = __builtin_bswap16(t);
1450  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1451 }
1452 
1458 static inline One_Bit_t getVerFailedPrgrRepPcktType(void* p)
1459 {
1460  uint16_t t;
1461  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1462  t = __builtin_bswap16(t);
1463  t >>= 12;
1464  t &= 0x1;
1465  return (One_Bit_t)t;
1466 }
1467 
1473 static inline void setVerFailedPrgrRepPcktType(void* p, One_Bit_t PcktType)
1474 {
1475  uint16_t s;
1476  uint16_t t;
1477  s = ((uint16_t)PcktType << 12);
1478  s &= (uint16_t)0x1000;
1479  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1480  t = __builtin_bswap16(t);
1481  t &= (uint16_t)~0x1000;
1482  t |= s;
1483  t = __builtin_bswap16(t);
1484  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1485 }
1486 
1492 static inline One_Bit_t getVerFailedPrgrRepSecHeaderFlag(void* p)
1493 {
1494  uint16_t t;
1495  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1496  t = __builtin_bswap16(t);
1497  t >>= 11;
1498  t &= 0x1;
1499  return (One_Bit_t)t;
1500 }
1501 
1507 static inline void setVerFailedPrgrRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
1508 {
1509  uint16_t s;
1510  uint16_t t;
1511  s = ((uint16_t)SecHeaderFlag << 11);
1512  s &= (uint16_t)0x800;
1513  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1514  t = __builtin_bswap16(t);
1515  t &= (uint16_t)~0x800;
1516  t |= s;
1517  t = __builtin_bswap16(t);
1518  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1519 }
1520 
1526 static inline Eleven_Bit_t getVerFailedPrgrRepAPID(void* p)
1527 {
1528  uint32_t t;
1529  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1530  t = __builtin_bswap32(t);
1531  t >>= 16;
1532  t &= 0x7ff;
1533  return (Eleven_Bit_t)t;
1534 }
1535 
1541 static inline void setVerFailedPrgrRepAPID(void* p, Eleven_Bit_t APID)
1542 {
1543  uint32_t s;
1544  uint32_t t;
1545  s = ((uint32_t)APID << 16);
1546  s &= (uint32_t)0x7ff0000;
1547  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1548  t = __builtin_bswap32(t);
1549  t &= (uint32_t)~0x7ff0000;
1550  t |= s;
1551  t = __builtin_bswap32(t);
1552  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1553 }
1554 
1560 static inline Two_Bit_t getVerFailedPrgrRepSeqFlags(void* p)
1561 {
1562  uint16_t t;
1563  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1564  t = __builtin_bswap16(t);
1565  t >>= 14;
1566  t &= 0x3;
1567  return (Two_Bit_t)t;
1568 }
1569 
1575 static inline void setVerFailedPrgrRepSeqFlags(void* p, Two_Bit_t SeqFlags)
1576 {
1577  uint16_t s;
1578  uint16_t t;
1579  s = ((uint16_t)SeqFlags << 14);
1580  s &= (uint16_t)0xc000;
1581  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1582  t = __builtin_bswap16(t);
1583  t &= (uint16_t)~0xc000;
1584  t |= s;
1585  t = __builtin_bswap16(t);
1586  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1587 }
1588 
1594 static inline FourTeen_Bit_t getVerFailedPrgrRepSeqCount(void* p)
1595 {
1596  uint32_t t;
1597  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1598  t = __builtin_bswap32(t);
1599  t >>= 16;
1600  t &= 0x3fff;
1601  return (FourTeen_Bit_t)t;
1602 }
1603 
1609 static inline void setVerFailedPrgrRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
1610 {
1611  uint32_t s;
1612  uint32_t t;
1613  s = ((uint32_t)SeqCount << 16);
1614  s &= (uint32_t)0x3fff0000;
1615  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1616  t = __builtin_bswap32(t);
1617  t &= (uint32_t)~0x3fff0000;
1618  t |= s;
1619  t = __builtin_bswap32(t);
1620  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1621 }
1622 
1629 {
1630  VerFailedPrgrRep_t* t;
1631  t = (VerFailedPrgrRep_t*)p;
1632  return __builtin_bswap32(t->StepId);
1633 }
1634 
1640 static inline void setVerFailedPrgrRepStepId(void* p, CrPsStepId_t StepId)
1641 {
1642  VerFailedPrgrRep_t* t;
1643  t = (VerFailedPrgrRep_t*)p;
1644  t->StepId = __builtin_bswap32(StepId);
1645 }
1646 
1653 {
1654  VerFailedPrgrRep_t* t;
1655  t = (VerFailedPrgrRep_t*)p;
1656  return __builtin_bswap16(t->FailureCode);
1657 }
1658 
1664 static inline void setVerFailedPrgrRepFailureCode(void* p, CrPsFailCode_t FailureCode)
1665 {
1666  VerFailedPrgrRep_t* t;
1667  t = (VerFailedPrgrRep_t*)p;
1668  t->FailureCode = __builtin_bswap16(FailureCode);
1669 }
1670 
1677 {
1678  VerFailedPrgrRep_t* t;
1679  t = (VerFailedPrgrRep_t*)p;
1680  return __builtin_bswap32(t->FailureData);
1681 }
1682 
1688 static inline void setVerFailedPrgrRepFailureData(void* p, CrPsFailData_t FailureData)
1689 {
1690  VerFailedPrgrRep_t* t;
1691  t = (VerFailedPrgrRep_t*)p;
1692  t->FailureData = __builtin_bswap32(FailureData);
1693 }
1694 
1700 static inline Three_Bit_t getVerSuccessTermRepPcktVersionNmb(void* p)
1701 {
1702  uint16_t t;
1703  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1704  t = __builtin_bswap16(t);
1705  t >>= 13;
1706  t &= 0x7;
1707  return (Three_Bit_t)t;
1708 }
1709 
1715 static inline void setVerSuccessTermRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
1716 {
1717  uint16_t s;
1718  uint16_t t;
1719  s = ((uint16_t)PcktVersionNmb << 13);
1720  s &= (uint16_t)0xe000;
1721  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1722  t = __builtin_bswap16(t);
1723  t &= (uint16_t)~0xe000;
1724  t |= s;
1725  t = __builtin_bswap16(t);
1726  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1727 }
1728 
1734 static inline One_Bit_t getVerSuccessTermRepPcktType(void* p)
1735 {
1736  uint16_t t;
1737  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1738  t = __builtin_bswap16(t);
1739  t >>= 12;
1740  t &= 0x1;
1741  return (One_Bit_t)t;
1742 }
1743 
1749 static inline void setVerSuccessTermRepPcktType(void* p, One_Bit_t PcktType)
1750 {
1751  uint16_t s;
1752  uint16_t t;
1753  s = ((uint16_t)PcktType << 12);
1754  s &= (uint16_t)0x1000;
1755  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1756  t = __builtin_bswap16(t);
1757  t &= (uint16_t)~0x1000;
1758  t |= s;
1759  t = __builtin_bswap16(t);
1760  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1761 }
1762 
1768 static inline One_Bit_t getVerSuccessTermRepSecHeaderFlag(void* p)
1769 {
1770  uint16_t t;
1771  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1772  t = __builtin_bswap16(t);
1773  t >>= 11;
1774  t &= 0x1;
1775  return (One_Bit_t)t;
1776 }
1777 
1783 static inline void setVerSuccessTermRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
1784 {
1785  uint16_t s;
1786  uint16_t t;
1787  s = ((uint16_t)SecHeaderFlag << 11);
1788  s &= (uint16_t)0x800;
1789  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1790  t = __builtin_bswap16(t);
1791  t &= (uint16_t)~0x800;
1792  t |= s;
1793  t = __builtin_bswap16(t);
1794  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1795 }
1796 
1802 static inline Eleven_Bit_t getVerSuccessTermRepAPID(void* p)
1803 {
1804  uint32_t t;
1805  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1806  t = __builtin_bswap32(t);
1807  t >>= 16;
1808  t &= 0x7ff;
1809  return (Eleven_Bit_t)t;
1810 }
1811 
1817 static inline void setVerSuccessTermRepAPID(void* p, Eleven_Bit_t APID)
1818 {
1819  uint32_t s;
1820  uint32_t t;
1821  s = ((uint32_t)APID << 16);
1822  s &= (uint32_t)0x7ff0000;
1823  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1824  t = __builtin_bswap32(t);
1825  t &= (uint32_t)~0x7ff0000;
1826  t |= s;
1827  t = __builtin_bswap32(t);
1828  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1829 }
1830 
1836 static inline Two_Bit_t getVerSuccessTermRepSeqFlags(void* p)
1837 {
1838  uint16_t t;
1839  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1840  t = __builtin_bswap16(t);
1841  t >>= 14;
1842  t &= 0x3;
1843  return (Two_Bit_t)t;
1844 }
1845 
1851 static inline void setVerSuccessTermRepSeqFlags(void* p, Two_Bit_t SeqFlags)
1852 {
1853  uint16_t s;
1854  uint16_t t;
1855  s = ((uint16_t)SeqFlags << 14);
1856  s &= (uint16_t)0xc000;
1857  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1858  t = __builtin_bswap16(t);
1859  t &= (uint16_t)~0xc000;
1860  t |= s;
1861  t = __builtin_bswap16(t);
1862  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1863 }
1864 
1870 static inline FourTeen_Bit_t getVerSuccessTermRepSeqCount(void* p)
1871 {
1872  uint32_t t;
1873  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1874  t = __builtin_bswap32(t);
1875  t >>= 16;
1876  t &= 0x3fff;
1877  return (FourTeen_Bit_t)t;
1878 }
1879 
1885 static inline void setVerSuccessTermRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
1886 {
1887  uint32_t s;
1888  uint32_t t;
1889  s = ((uint32_t)SeqCount << 16);
1890  s &= (uint32_t)0x3fff0000;
1891  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
1892  t = __builtin_bswap32(t);
1893  t &= (uint32_t)~0x3fff0000;
1894  t |= s;
1895  t = __builtin_bswap32(t);
1896  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
1897 }
1898 
1904 static inline Three_Bit_t getVerFailedTermRepPcktVersionNmb(void* p)
1905 {
1906  uint16_t t;
1907  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1908  t = __builtin_bswap16(t);
1909  t >>= 13;
1910  t &= 0x7;
1911  return (Three_Bit_t)t;
1912 }
1913 
1919 static inline void setVerFailedTermRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
1920 {
1921  uint16_t s;
1922  uint16_t t;
1923  s = ((uint16_t)PcktVersionNmb << 13);
1924  s &= (uint16_t)0xe000;
1925  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1926  t = __builtin_bswap16(t);
1927  t &= (uint16_t)~0xe000;
1928  t |= s;
1929  t = __builtin_bswap16(t);
1930  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1931 }
1932 
1938 static inline One_Bit_t getVerFailedTermRepPcktType(void* p)
1939 {
1940  uint16_t t;
1941  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1942  t = __builtin_bswap16(t);
1943  t >>= 12;
1944  t &= 0x1;
1945  return (One_Bit_t)t;
1946 }
1947 
1953 static inline void setVerFailedTermRepPcktType(void* p, One_Bit_t PcktType)
1954 {
1955  uint16_t s;
1956  uint16_t t;
1957  s = ((uint16_t)PcktType << 12);
1958  s &= (uint16_t)0x1000;
1959  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1960  t = __builtin_bswap16(t);
1961  t &= (uint16_t)~0x1000;
1962  t |= s;
1963  t = __builtin_bswap16(t);
1964  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1965 }
1966 
1972 static inline One_Bit_t getVerFailedTermRepSecHeaderFlag(void* p)
1973 {
1974  uint16_t t;
1975  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1976  t = __builtin_bswap16(t);
1977  t >>= 11;
1978  t &= 0x1;
1979  return (One_Bit_t)t;
1980 }
1981 
1987 static inline void setVerFailedTermRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
1988 {
1989  uint16_t s;
1990  uint16_t t;
1991  s = ((uint16_t)SecHeaderFlag << 11);
1992  s &= (uint16_t)0x800;
1993  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
1994  t = __builtin_bswap16(t);
1995  t &= (uint16_t)~0x800;
1996  t |= s;
1997  t = __builtin_bswap16(t);
1998  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
1999 }
2000 
2006 static inline Eleven_Bit_t getVerFailedTermRepAPID(void* p)
2007 {
2008  uint32_t t;
2009  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2010  t = __builtin_bswap32(t);
2011  t >>= 16;
2012  t &= 0x7ff;
2013  return (Eleven_Bit_t)t;
2014 }
2015 
2021 static inline void setVerFailedTermRepAPID(void* p, Eleven_Bit_t APID)
2022 {
2023  uint32_t s;
2024  uint32_t t;
2025  s = ((uint32_t)APID << 16);
2026  s &= (uint32_t)0x7ff0000;
2027  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2028  t = __builtin_bswap32(t);
2029  t &= (uint32_t)~0x7ff0000;
2030  t |= s;
2031  t = __builtin_bswap32(t);
2032  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
2033 }
2034 
2040 static inline Two_Bit_t getVerFailedTermRepSeqFlags(void* p)
2041 {
2042  uint16_t t;
2043  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2044  t = __builtin_bswap16(t);
2045  t >>= 14;
2046  t &= 0x3;
2047  return (Two_Bit_t)t;
2048 }
2049 
2055 static inline void setVerFailedTermRepSeqFlags(void* p, Two_Bit_t SeqFlags)
2056 {
2057  uint16_t s;
2058  uint16_t t;
2059  s = ((uint16_t)SeqFlags << 14);
2060  s &= (uint16_t)0xc000;
2061  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2062  t = __builtin_bswap16(t);
2063  t &= (uint16_t)~0xc000;
2064  t |= s;
2065  t = __builtin_bswap16(t);
2066  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
2067 }
2068 
2074 static inline FourTeen_Bit_t getVerFailedTermRepSeqCount(void* p)
2075 {
2076  uint32_t t;
2077  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2078  t = __builtin_bswap32(t);
2079  t >>= 16;
2080  t &= 0x3fff;
2081  return (FourTeen_Bit_t)t;
2082 }
2083 
2089 static inline void setVerFailedTermRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
2090 {
2091  uint32_t s;
2092  uint32_t t;
2093  s = ((uint32_t)SeqCount << 16);
2094  s &= (uint32_t)0x3fff0000;
2095  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2096  t = __builtin_bswap32(t);
2097  t &= (uint32_t)~0x3fff0000;
2098  t |= s;
2099  t = __builtin_bswap32(t);
2100  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
2101 }
2102 
2109 {
2110  VerFailedTermRep_t* t;
2111  t = (VerFailedTermRep_t*)p;
2112  return __builtin_bswap16(t->FailureCode);
2113 }
2114 
2120 static inline void setVerFailedTermRepFailureCode(void* p, CrPsFailCode_t FailureCode)
2121 {
2122  VerFailedTermRep_t* t;
2123  t = (VerFailedTermRep_t*)p;
2124  t->FailureCode = __builtin_bswap16(FailureCode);
2125 }
2126 
2133 {
2134  VerFailedTermRep_t* t;
2135  t = (VerFailedTermRep_t*)p;
2136  return __builtin_bswap32(t->FailureData);
2137 }
2138 
2144 static inline void setVerFailedTermRepFailureData(void* p, CrPsFailData_t FailureData)
2145 {
2146  VerFailedTermRep_t* t;
2147  t = (VerFailedTermRep_t*)p;
2148  t->FailureData = __builtin_bswap32(FailureData);
2149 }
2150 
2156 static inline Three_Bit_t getVerFailedRoutingRepPcktVersionNmb(void* p)
2157 {
2158  uint16_t t;
2159  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2160  t = __builtin_bswap16(t);
2161  t >>= 13;
2162  t &= 0x7;
2163  return (Three_Bit_t)t;
2164 }
2165 
2171 static inline void setVerFailedRoutingRepPcktVersionNmb(void* p, Three_Bit_t PcktVersionNmb)
2172 {
2173  uint16_t s;
2174  uint16_t t;
2175  s = ((uint16_t)PcktVersionNmb << 13);
2176  s &= (uint16_t)0xe000;
2177  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2178  t = __builtin_bswap16(t);
2179  t &= (uint16_t)~0xe000;
2180  t |= s;
2181  t = __builtin_bswap16(t);
2182  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
2183 }
2184 
2190 static inline One_Bit_t getVerFailedRoutingRepPcktType(void* p)
2191 {
2192  uint16_t t;
2193  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2194  t = __builtin_bswap16(t);
2195  t >>= 12;
2196  t &= 0x1;
2197  return (One_Bit_t)t;
2198 }
2199 
2205 static inline void setVerFailedRoutingRepPcktType(void* p, One_Bit_t PcktType)
2206 {
2207  uint16_t s;
2208  uint16_t t;
2209  s = ((uint16_t)PcktType << 12);
2210  s &= (uint16_t)0x1000;
2211  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2212  t = __builtin_bswap16(t);
2213  t &= (uint16_t)~0x1000;
2214  t |= s;
2215  t = __builtin_bswap16(t);
2216  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
2217 }
2218 
2224 static inline One_Bit_t getVerFailedRoutingRepSecHeaderFlag(void* p)
2225 {
2226  uint16_t t;
2227  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2228  t = __builtin_bswap16(t);
2229  t >>= 11;
2230  t &= 0x1;
2231  return (One_Bit_t)t;
2232 }
2233 
2239 static inline void setVerFailedRoutingRepSecHeaderFlag(void* p, One_Bit_t SecHeaderFlag)
2240 {
2241  uint16_t s;
2242  uint16_t t;
2243  s = ((uint16_t)SecHeaderFlag << 11);
2244  s &= (uint16_t)0x800;
2245  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2246  t = __builtin_bswap16(t);
2247  t &= (uint16_t)~0x800;
2248  t |= s;
2249  t = __builtin_bswap16(t);
2250  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
2251 }
2252 
2258 static inline Eleven_Bit_t getVerFailedRoutingRepAPID(void* p)
2259 {
2260  uint32_t t;
2261  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2262  t = __builtin_bswap32(t);
2263  t >>= 16;
2264  t &= 0x7ff;
2265  return (Eleven_Bit_t)t;
2266 }
2267 
2273 static inline void setVerFailedRoutingRepAPID(void* p, Eleven_Bit_t APID)
2274 {
2275  uint32_t s;
2276  uint32_t t;
2277  s = ((uint32_t)APID << 16);
2278  s &= (uint32_t)0x7ff0000;
2279  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)], sizeof(t));
2280  t = __builtin_bswap32(t);
2281  t &= (uint32_t)~0x7ff0000;
2282  t |= s;
2283  t = __builtin_bswap32(t);
2284  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)], &t, sizeof(t));
2285 }
2286 
2292 static inline Two_Bit_t getVerFailedRoutingRepSeqFlags(void* p)
2293 {
2294  uint16_t t;
2295  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2296  t = __builtin_bswap16(t);
2297  t >>= 14;
2298  t &= 0x3;
2299  return (Two_Bit_t)t;
2300 }
2301 
2307 static inline void setVerFailedRoutingRepSeqFlags(void* p, Two_Bit_t SeqFlags)
2308 {
2309  uint16_t s;
2310  uint16_t t;
2311  s = ((uint16_t)SeqFlags << 14);
2312  s &= (uint16_t)0xc000;
2313  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2314  t = __builtin_bswap16(t);
2315  t &= (uint16_t)~0xc000;
2316  t |= s;
2317  t = __builtin_bswap16(t);
2318  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
2319 }
2320 
2326 static inline FourTeen_Bit_t getVerFailedRoutingRepSeqCount(void* p)
2327 {
2328  uint32_t t;
2329  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2330  t = __builtin_bswap32(t);
2331  t >>= 16;
2332  t &= 0x3fff;
2333  return (FourTeen_Bit_t)t;
2334 }
2335 
2341 static inline void setVerFailedRoutingRepSeqCount(void* p, FourTeen_Bit_t SeqCount)
2342 {
2343  uint32_t s;
2344  uint32_t t;
2345  s = ((uint32_t)SeqCount << 16);
2346  s &= (uint32_t)0x3fff0000;
2347  (void)memcpy(&t, &((uint8_t*)p)[sizeof(TmHeader_t)+2], sizeof(t));
2348  t = __builtin_bswap32(t);
2349  t &= (uint32_t)~0x3fff0000;
2350  t |= s;
2351  t = __builtin_bswap32(t);
2352  (void)memcpy(&((uint8_t*)p)[sizeof(TmHeader_t)+2], &t, sizeof(t));
2353 }
2354 
2361 {
2362  VerFailedRoutingRep_t* t;
2363  t = (VerFailedRoutingRep_t*)p;
2364  return __builtin_bswap16(t->FailureCode);
2365 }
2366 
2372 static inline void setVerFailedRoutingRepFailureCode(void* p, CrPsFailCode_t FailureCode)
2373 {
2374  VerFailedRoutingRep_t* t;
2375  t = (VerFailedRoutingRep_t*)p;
2376  t->FailureCode = __builtin_bswap16(FailureCode);
2377 }
2378 
2385 {
2386  VerFailedRoutingRep_t* t;
2387  t = (VerFailedRoutingRep_t*)p;
2388  return __builtin_bswap32(t->FailureData);
2389 }
2390 
2396 static inline void setVerFailedRoutingRepFailureData(void* p, CrPsFailData_t FailureData)
2397 {
2398  VerFailedRoutingRep_t* t;
2399  t = (VerFailedRoutingRep_t*)p;
2400  t->FailureData = __builtin_bswap32(FailureData);
2401 }
2402 
2403 
2404 
2405 /*----------------------------------------------------------------------------*/
2406 #endif /* CRPSPKTSERVREQVERIF_H */
static FourTeen_Bit_t getVerFailedTermRepSeqCount(void *p)
Get "SeqCount" from "VerFailedTermRep" packet.
static void setVerFailedStartRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerFailedStartRep" packet.
static void setVerSuccessPrgrRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerSuccessPrgrRep" packet.
static void setVerFailedStartRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerFailedStartRep" packet.
static FourTeen_Bit_t getVerFailedAccRepSeqCount(void *p)
Get "SeqCount" from "VerFailedAccRep" packet.
static void setVerFailedRoutingRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerFailedRoutingRep" packet.
static CrPsStepId_t getVerSuccessPrgrRepStepId(void *p)
Get "StepId" from "VerSuccessPrgrRep" packet.
static One_Bit_t getVerFailedRoutingRepPcktType(void *p)
Get "PcktType" from "VerFailedRoutingRep" packet.
static void setVerSuccessStartRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerSuccessStartRep" packet.
static void setVerSuccessTermRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerSuccessTermRep" packet.
static Three_Bit_t getVerFailedRoutingRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerFailedRoutingRep" packet.
static void setVerSuccessAccRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerSuccessAccRep" packet.
static CrPsFailCode_t getVerFailedRoutingRepFailureCode(void *p)
Get "FailureCode" from "VerFailedRoutingRep" packet.
static Two_Bit_t getVerFailedPrgrRepSeqFlags(void *p)
Get "SeqFlags" from "VerFailedPrgrRep" packet.
static void setVerFailedStartRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerFailedStartRep" packet.
static void setVerSuccessStartRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerSuccessStartRep" packet.
static void setVerSuccessTermRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerSuccessTermRep" packet.
static void setVerSuccessStartRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerSuccessStartRep" packet.
static void setVerSuccessAccRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerSuccessAccRep" packet.
static void setVerSuccessPrgrRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerSuccessPrgrRep" packet.
Header file to define all user-configurable constants and types for the IASW Application.
static void setVerFailedStartRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerFailedStartRep" packet.
static CrPsFailCode_t getVerFailedTermRepFailureCode(void *p)
Get "FailureCode" from "VerFailedTermRep" packet.
static Three_Bit_t getVerSuccessStartRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerSuccessStartRep" packet.
static CrPsFailCode_t getVerFailedStartRepFailureCode(void *p)
Get "FailureCode" from "VerFailedStartRep" packet.
static FourTeen_Bit_t getVerFailedPrgrRepSeqCount(void *p)
Get "SeqCount" from "VerFailedPrgrRep" packet.
static void setVerSuccessTermRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerSuccessTermRep" packet.
static Eleven_Bit_t getVerSuccessStartRepAPID(void *p)
Get "APID" from "VerSuccessStartRep" packet.
static Two_Bit_t getVerFailedTermRepSeqFlags(void *p)
Get "SeqFlags" from "VerFailedTermRep" packet.
static Eleven_Bit_t getVerSuccessTermRepAPID(void *p)
Get "APID" from "VerSuccessTermRep" packet.
static One_Bit_t getVerFailedAccRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerFailedAccRep" packet.
static void setVerFailedStartRepFailureData(void *p, CrPsFailData_t FailureData)
Set "FailureData" in "VerFailedStartRep" packet.
static One_Bit_t getVerFailedAccRepPcktType(void *p)
Get "PcktType" from "VerFailedAccRep" packet.
static void setVerFailedPrgrRepStepId(void *p, CrPsStepId_t StepId)
Set "StepId" in "VerFailedPrgrRep" packet.
static void setVerSuccessTermRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerSuccessTermRep" packet.
static void setVerFailedTermRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerFailedTermRep" packet.
static One_Bit_t getVerSuccessStartRepPcktType(void *p)
Get "PcktType" from "VerSuccessStartRep" packet.
static void setVerSuccessAccRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerSuccessAccRep" packet.
static Three_Bit_t getVerSuccessTermRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerSuccessTermRep" packet.
static void setVerSuccessTermRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerSuccessTermRep" packet.
static void setVerFailedAccRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerFailedAccRep" packet.
static Eleven_Bit_t getVerFailedAccRepAPID(void *p)
Get "APID" from "VerFailedAccRep" packet.
static void setVerFailedRoutingRepFailureCode(void *p, CrPsFailCode_t FailureCode)
Set "FailureCode" in "VerFailedRoutingRep" packet.
static void setVerSuccessAccRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerSuccessAccRep" packet.
static void setVerSuccessPrgrRepStepId(void *p, CrPsStepId_t StepId)
Set "StepId" in "VerSuccessPrgrRep" packet.
static void setVerFailedAccRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerFailedAccRep" packet.
static Two_Bit_t getVerFailedAccRepSeqFlags(void *p)
Get "SeqFlags" from "VerFailedAccRep" packet.
static Eleven_Bit_t getVerFailedStartRepAPID(void *p)
Get "APID" from "VerFailedStartRep" packet.
static void setVerFailedTermRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerFailedTermRep" packet.
static Two_Bit_t getVerSuccessTermRepSeqFlags(void *p)
Get "SeqFlags" from "VerSuccessTermRep" packet.
static Three_Bit_t getVerFailedAccRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerFailedAccRep" packet.
static void setVerFailedPrgrRepFailureData(void *p, CrPsFailData_t FailureData)
Set "FailureData" in "VerFailedPrgrRep" packet.
static FourTeen_Bit_t getVerSuccessAccRepSeqCount(void *p)
Get "SeqCount" from "VerSuccessAccRep" packet.
static void setVerSuccessAccRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerSuccessAccRep" packet.
static One_Bit_t getVerFailedPrgrRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerFailedPrgrRep" packet.
uint32_t CrPsStepId_t
Type used for the Step ID of a packet.
static void setVerFailedPrgrRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerFailedPrgrRep" packet.
static Two_Bit_t getVerFailedRoutingRepSeqFlags(void *p)
Get "SeqFlags" from "VerFailedRoutingRep" packet.
static FourTeen_Bit_t getVerSuccessTermRepSeqCount(void *p)
Get "SeqCount" from "VerSuccessTermRep" packet.
static void setVerSuccessPrgrRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerSuccessPrgrRep" packet.
static One_Bit_t getVerFailedPrgrRepPcktType(void *p)
Get "PcktType" from "VerFailedPrgrRep" packet.
static Three_Bit_t getVerFailedStartRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerFailedStartRep" packet.
static One_Bit_t getVerSuccessTermRepPcktType(void *p)
Get "PcktType" from "VerSuccessTermRep" packet.
static void setVerFailedTermRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerFailedTermRep" packet.
static void setVerFailedStartRepFailureCode(void *p, CrPsFailCode_t FailureCode)
Set "FailureCode" in "VerFailedStartRep" packet.
static void setVerFailedRoutingRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerFailedRoutingRep" packet.
static Three_Bit_t getVerSuccessPrgrRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerSuccessPrgrRep" packet.
static void setVerFailedPrgrRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerFailedPrgrRep" packet.
static void setVerSuccessStartRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerSuccessStartRep" packet.
static void setVerSuccessStartRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerSuccessStartRep" packet.
static void setVerFailedAccRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerFailedAccRep" packet.
static One_Bit_t getVerFailedTermRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerFailedTermRep" packet.
static void setVerSuccessTermRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerSuccessTermRep" packet.
static void setVerFailedRoutingRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerFailedRoutingRep" packet.
static Three_Bit_t getVerFailedTermRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerFailedTermRep" packet.
static void setVerFailedTermRepFailureData(void *p, CrPsFailData_t FailureData)
Set "FailureData" in "VerFailedTermRep" packet.
static void setVerFailedPrgrRepFailureCode(void *p, CrPsFailCode_t FailureCode)
Set "FailureCode" in "VerFailedPrgrRep" packet.
static One_Bit_t getVerSuccessAccRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerSuccessAccRep" packet.
uint32_t CrPsFailData_t
Type used for the Failure Data of a packet.
static CrPsFailData_t getVerFailedAccRepFailureData(void *p)
Get "FailureData" from "VerFailedAccRep" packet.
static void setVerFailedTermRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerFailedTermRep" packet.
static void setVerFailedAccRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerFailedAccRep" packet.
static CrPsFailData_t getVerFailedStartRepFailureData(void *p)
Get "FailureData" from "VerFailedStartRep" packet.
static void setVerFailedTermRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerFailedTermRep" packet.
static Eleven_Bit_t getVerFailedRoutingRepAPID(void *p)
Get "APID" from "VerFailedRoutingRep" packet.
static FourTeen_Bit_t getVerFailedStartRepSeqCount(void *p)
Get "SeqCount" from "VerFailedStartRep" packet.
static void setVerFailedRoutingRepFailureData(void *p, CrPsFailData_t FailureData)
Set "FailureData" in "VerFailedRoutingRep" packet.
static void setVerSuccessAccRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerSuccessAccRep" packet.
static One_Bit_t getVerSuccessPrgrRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerSuccessPrgrRep" packet.
static CrPsFailData_t getVerFailedPrgrRepFailureData(void *p)
Get "FailureData" from "VerFailedPrgrRep" packet.
static Two_Bit_t getVerSuccessPrgrRepSeqFlags(void *p)
Get "SeqFlags" from "VerSuccessPrgrRep" packet.
uint16_t CrPsFailCode_t
Type used for the Failure Code of a packet.
static One_Bit_t getVerSuccessStartRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerSuccessStartRep" packet.
static void setVerFailedStartRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerFailedStartRep" packet.
Packet header definitions.
static void setVerFailedAccRepFailureData(void *p, CrPsFailData_t FailureData)
Set "FailureData" in "VerFailedAccRep" packet.
static Eleven_Bit_t getVerSuccessAccRepAPID(void *p)
Get "APID" from "VerSuccessAccRep" packet.
static void setVerFailedPrgrRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerFailedPrgrRep" packet.
static Eleven_Bit_t getVerSuccessPrgrRepAPID(void *p)
Get "APID" from "VerSuccessPrgrRep" packet.
static Two_Bit_t getVerFailedStartRepSeqFlags(void *p)
Get "SeqFlags" from "VerFailedStartRep" packet.
static CrPsFailCode_t getVerFailedAccRepFailureCode(void *p)
Get "FailureCode" from "VerFailedAccRep" packet.
static One_Bit_t getVerFailedStartRepPcktType(void *p)
Get "PcktType" from "VerFailedStartRep" packet.
static void setVerSuccessPrgrRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerSuccessPrgrRep" packet.
static Two_Bit_t getVerSuccessAccRepSeqFlags(void *p)
Get "SeqFlags" from "VerSuccessAccRep" packet.
static void setVerFailedPrgrRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerFailedPrgrRep" packet.
static void setVerSuccessPrgrRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerSuccessPrgrRep" packet.
static void setVerFailedAccRepFailureCode(void *p, CrPsFailCode_t FailureCode)
Set "FailureCode" in "VerFailedAccRep" packet.
static One_Bit_t getVerSuccessAccRepPcktType(void *p)
Get "PcktType" from "VerSuccessAccRep" packet.
static FourTeen_Bit_t getVerSuccessStartRepSeqCount(void *p)
Get "SeqCount" from "VerSuccessStartRep" packet.
static void setVerFailedAccRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerFailedAccRep" packet.
static One_Bit_t getVerFailedRoutingRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerFailedRoutingRep" packet.
static Eleven_Bit_t getVerFailedTermRepAPID(void *p)
Get "APID" from "VerFailedTermRep" packet.
static void setVerFailedTermRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerFailedTermRep" packet.
static One_Bit_t getVerFailedTermRepPcktType(void *p)
Get "PcktType" from "VerFailedTermRep" packet.
static CrPsFailData_t getVerFailedRoutingRepFailureData(void *p)
Get "FailureData" from "VerFailedRoutingRep" packet.
static FourTeen_Bit_t getVerSuccessPrgrRepSeqCount(void *p)
Get "SeqCount" from "VerSuccessPrgrRep" packet.
static void setVerSuccessStartRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerSuccessStartRep" packet.
static One_Bit_t getVerSuccessPrgrRepPcktType(void *p)
Get "PcktType" from "VerSuccessPrgrRep" packet.
static void setVerFailedPrgrRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerFailedPrgrRep" packet.
static void setVerFailedTermRepFailureCode(void *p, CrPsFailCode_t FailureCode)
Set "FailureCode" in "VerFailedTermRep" packet.
static One_Bit_t getVerSuccessTermRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerSuccessTermRep" packet.
static Three_Bit_t getVerFailedPrgrRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerFailedPrgrRep" packet.
static void setVerFailedAccRepPcktVersionNmb(void *p, Three_Bit_t PcktVersionNmb)
Set "PcktVersionNmb" in "VerFailedAccRep" packet.
static void setVerFailedRoutingRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerFailedRoutingRep" packet.
static One_Bit_t getVerFailedStartRepSecHeaderFlag(void *p)
Get "SecHeaderFlag" from "VerFailedStartRep" packet.
static CrPsStepId_t getVerFailedPrgrRepStepId(void *p)
Get "StepId" from "VerFailedPrgrRep" packet.
static void setVerFailedPrgrRepSecHeaderFlag(void *p, One_Bit_t SecHeaderFlag)
Set "SecHeaderFlag" in "VerFailedPrgrRep" packet.
static void setVerFailedStartRepAPID(void *p, Eleven_Bit_t APID)
Set "APID" in "VerFailedStartRep" packet.
static void setVerFailedRoutingRepPcktType(void *p, One_Bit_t PcktType)
Set "PcktType" in "VerFailedRoutingRep" packet.
static Two_Bit_t getVerSuccessStartRepSeqFlags(void *p)
Get "SeqFlags" from "VerSuccessStartRep" packet.
static Eleven_Bit_t getVerFailedPrgrRepAPID(void *p)
Get "APID" from "VerFailedPrgrRep" packet.
static CrPsFailCode_t getVerFailedPrgrRepFailureCode(void *p)
Get "FailureCode" from "VerFailedPrgrRep" packet.
static void setVerFailedRoutingRepSeqFlags(void *p, Two_Bit_t SeqFlags)
Set "SeqFlags" in "VerFailedRoutingRep" packet.
static CrPsFailData_t getVerFailedTermRepFailureData(void *p)
Get "FailureData" from "VerFailedTermRep" packet.
static FourTeen_Bit_t getVerFailedRoutingRepSeqCount(void *p)
Get "SeqCount" from "VerFailedRoutingRep" packet.
static void setVerSuccessPrgrRepSeqCount(void *p, FourTeen_Bit_t SeqCount)
Set "SeqCount" in "VerSuccessPrgrRep" packet.
struct __attribute__((packed)) _VerSuccessAccRep_t
Structure for VerSuccessAccRep.
static Three_Bit_t getVerSuccessAccRepPcktVersionNmb(void *p)
Get "PcktVersionNmb" from "VerSuccessAccRep" packet.
P&P Software GmbH, Copyright 2012-2013, All Rights Reserved