[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Implementation of onduration timer
[o-du/l2.git] / src / cm / cm_tkns.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18 \f
19 /********************************************************************20**
20   
21      Name:     general layer
22   
23      Type:     C file
24   
25      Desc:     Packing/Unpacking for structures, defined in cm_tkns.x
26    
27      File:     cm_tkns.c
28   
29 *********************************************************************21*/
30 \f
31 /* header include files (.h) */
32
33 #include "envopt.h"        /* environment options */
34 #include "envdep.h"        /* environment dependent */
35 #include "envind.h"        /* environment independent */
36
37 #include "gen.h"           /* general layer */
38 #include "ssi.h"           /* system services */
39 #include "cm_mblk.h"
40 #include "cm_tkns.h"       /* common tokens */
41
42 /* header/extern include files (.x) */
43
44 #include "gen.x"           /* general layer */
45 #include "ssi.x"           /* system services */
46 #include "cm_mblk.x"
47 #include "cm_tkns.x"       /* common tokens */
48
49 \f  
50
51 /*
52  *      PACKING FUNCTIONS
53  */
54
55 \f
56 /*
57  *
58  *      Fun:   cmPkTknS16
59  *
60  *      Desc:  This function unpacks a token S16
61  *
62  *      Ret:   ROK      - ok
63  *
64  *      Notes: None
65  *
66         File:  cm_tkns.c
67  *
68  */
69 S16 cmPkTknS16
70 (
71 TknS16 *tknS16,             /* token S16 */
72 Buffer *mBuf                /* message buffer */
73 )
74 {
75
76    if (tknS16->pres)
77    {
78       /* Value */
79       CMCHKPK(SPkS16, tknS16->val, mBuf);
80    }
81
82    /* Token Header */
83    CMCHKPK(oduUnpackUInt8, tknS16->pres, mBuf);
84
85    return ROK;
86 } /* end of cmPkTknS16 */
87   
88 \f
89 /*
90  *
91  *      Fun:   cmPkTknBStr32
92  *
93  *      Desc:  This function packs a token bit string of size 32
94  *
95  *      Ret:   ROK      - ok
96  *
97  *      Notes: None
98  *
99         File:  cm_tkns.c
100  *
101  */
102   
103 S16 cmPkTknBStr32
104 (
105 TknBStr32 *tknStr,             /* token string */
106 Buffer    *mBuf                /* message buffer */
107 )
108 {
109
110    CMPKTKNBSTR(tknStr, mBuf);
111
112    return ROK;
113
114 } /* end of cmPkTknBStr32 */
115
116 /*
117  *
118  *      Fun:   cmPkTknStr8
119  *
120  *      Desc:  This function packs a token string of size 8
121  *
122  *      Ret:   ROK      - ok
123  *
124  *      Notes: None
125  *
126         File:  cm_tkns.c
127  *
128  */
129   
130 S16 cmPkTknStr8
131 (
132 TknStr8 *tknStr,             /* token string */
133 Buffer  *mBuf                /* message buffer */
134 )
135 {
136
137    CMPKTKNSTR(tknStr, mBuf);
138
139    return ROK;
140
141 } /* end of cmPkTknStr8 */
142
143 \f
144 /*
145  *
146  *      Fun:   cmPkTknStr16
147  *
148  *      Desc:  This function packs a token string of size 16
149  *
150  *      Ret:   ROK      - ok
151  *
152  *      Notes: None
153  *
154         File:  cm_tkns.c
155  *
156  */
157   
158 S16 cmPkTknStr16
159 (
160 TknStr16 *tknStr,             /* token string */
161 Buffer   *mBuf                /* message buffer */
162 )
163 {
164
165    CMPKTKNSTR(tknStr, mBuf);
166
167    return ROK;
168
169 } /* end of cmPkTknStr16 */
170
171 \f
172 /*
173  *
174  *      Fun:   cmPkTknStrOSXL
175  *
176  *      Desc:  This function packs a Long Octet string
177  *
178  *      Ret:   ROK      - ok
179  *
180  *      Notes: None
181  *
182         File:  cm_tkns.c
183  *
184  */
185   
186 S16 cmPkTknStrOSXL
187 (
188 TknStrOSXL *tknStr,             /* token string */
189 Buffer     *mBuf                /* message buffer */
190 )
191 {
192    uint16_t ndx;
193
194
195    if(tknStr->pres)
196    {
197       /* Value */
198       for (ndx = 0; ndx < tknStr->len; ndx++)
199       {
200          CMCHKPK(oduUnpackUInt8, tknStr->val[ndx], mBuf);
201       }
202       /* Length */
203       CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
204    }
205    /* Token Header */
206    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
207
208    return ROK;
209
210 } /* end of cmPkTknStrOSXL */
211
212
213 \f
214 /*
215  *
216  *      Fun:   cmPkTknStrBSXL
217  *
218  *      Desc:  This function packs a Long bit string
219  *
220  *      Ret:   ROK      - ok
221  *
222  *      Notes: None
223  *
224         File:  cm_tkns.c
225  *
226  */
227   
228 S16 cmPkTknStrBSXL
229 (
230 TknStrBSXL *tknStr,             /* token string */
231 Buffer     *mBuf              /* message buffer */
232 )
233 {
234    uint16_t ndx;
235    uint16_t len;
236
237
238    if(tknStr->pres)
239    {
240       if (tknStr->len % 8)
241          len = (tknStr->len/8) + 1;
242       else
243          len = (tknStr->len/8);
244    
245       /* Value */
246       for (ndx = 0; ndx < len; ndx++)
247       {
248          CMCHKPK(oduUnpackUInt8, tknStr->val[ndx], mBuf);
249       }
250       /* Length */
251       CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
252    }
253    /* Token Header */
254    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
255
256    return ROK;
257
258 } /* end of cmPkTknStrBSXL */
259
260 \f  
261 /*
262  *
263  *      Fun:   cmPkTknStrBMP4
264  *
265  *      Desc:  This function packs a BMP token string of size 4
266  *
267  *      Ret:   ROK      - ok
268  *
269  *      Notes: None
270  *
271         File:  cm_tkns.c
272  *
273  */
274   
275 S16 cmPkTknStrBMP4
276 (
277 TknStrBMP4 *tknStr,             /* token string */
278 Buffer     *mBuf                /* message buffer */
279 )
280 {
281    uint8_t ndx;
282
283
284    if(tknStr->pres)
285    {
286       /* Value */
287       for (ndx = 0; ndx < tknStr->len; ndx++)
288       {
289          CMCHKPK(oduUnpackUInt16, tknStr->val[ndx], mBuf);
290       }
291
292       /* Length */
293       CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
294    }
295
296    /* Token Header */
297    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
298
299    return ROK;
300 } /* end of cmPkTknStrBMP4 */
301
302 \f
303 /*
304  *
305  *      Fun:   cmPkTknStrBMPXL
306  *
307  *      Desc:  This function packs a Long BMP Octet string
308  *
309  *      Ret:   ROK      - ok
310  *
311  *      Notes: None
312  *
313         File:  cm_tkns.c
314  *
315  */
316   
317 S16 cmPkTknStrBMPXL
318 (
319 TknStrBMPXL *tknStr,             /* token string */
320 Buffer     *mBuf                /* message buffer */
321 )
322 {
323    uint16_t ndx;
324
325
326    if(tknStr->pres)
327    {
328       /* Value */
329       for (ndx = 0; ndx < tknStr->len; ndx++)
330       {
331          CMCHKPK(oduUnpackUInt16, tknStr->val[ndx], mBuf);
332       }
333       /* Length */
334       CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
335    }
336    /* Token Header */
337    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
338
339    return ROK;
340 } /* end of cmPkTknStrBMPXL */
341
342 \f  
343 /*
344  *
345  *      Fun:   cmPkTknStrUNI4
346  *
347  *      Desc:  This function packs a UNI token string of size 4
348  *
349  *      Ret:   ROK      - ok
350  *
351  *      Notes: None
352  *
353         File:  cm_tkns.c
354  *
355  */
356   
357 S16 cmPkTknStrUNI4
358 (
359 TknStrUNI4 *tknStr,             /* token string */
360 Buffer     *mBuf                /* message buffer */
361 )
362 {
363    uint8_t ndx;
364
365
366    if(tknStr->pres)
367    {
368       /* Value */
369       for (ndx = 0; ndx < tknStr->len; ndx++)
370       {
371          CMCHKPK(oduUnpackUInt32, tknStr->val[ndx], mBuf);
372       }
373
374       /* Length */
375       CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
376    }
377
378    /* Token Header */
379    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
380
381    return ROK;
382 } /* end of cmPkTknStrUNI4 */
383
384 \f
385 /*
386  *
387  *      Fun:   cmPkTknStrUNIXL
388  *
389  *      Desc:  This function packs a Long UNI Octet string
390  *
391  *      Ret:   ROK      - ok
392  *
393  *      Notes: None
394  *
395         File:  cm_tkns.c
396  *
397  */
398   
399 S16 cmPkTknStrUNIXL
400 (
401 TknStrUNIXL *tknStr,             /* token string */
402 Buffer     *mBuf                /* message buffer */
403 )
404 {
405    uint16_t ndx;
406
407
408    if(tknStr->pres)
409    {
410       /* Value */
411       for (ndx = 0; ndx < tknStr->len; ndx++)
412       {
413          CMCHKPK(oduUnpackUInt32, tknStr->val[ndx], mBuf);
414       }
415       /* Length */
416       CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
417    }
418    /* Token Header */
419    CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
420
421    return ROK;
422 } /* end of cmPkTknStrUNIXL */
423 \f
424 /*
425  *      UNPACKING FUNCTIONS
426  */
427
428 \f
429 /*
430  *
431  *      Fun:   cmUnpkTknS16
432  *
433  *      Desc:  This function unpacks a token S16
434  *
435  *      Ret:   ROK      - ok
436  *
437  *      Notes: None
438  *
439         File:  cm_tkns.c
440  *
441  */
442 S16 cmUnpkTknS16
443 (
444 TknS16 *tknS16,             /* token S16 */
445 Buffer *mBuf                /* message buffer */
446 )
447 {
448
449    /* Token Header */
450    CMCHKUNPK(oduPackUInt8, &tknS16->pres, mBuf);
451
452    if (tknS16->pres)
453    {
454       /* Value */
455       CMCHKUNPK(SUnpkS16, &tknS16->val, mBuf);
456    }
457
458    return ROK;
459 } /* end of cmUnpkTknS16 */
460   
461 \f
462 /*
463  *
464  *      Fun:   cmUnpkTknBStr32
465  *
466  *      Desc:  This function packs a token bit string of size 32
467  *
468  *      Ret:   ROK      - ok
469  *
470  *      Notes: None
471  *
472         File:  cm_tkns.c
473  *
474  */
475   
476 S16 cmUnpkTknBStr32
477 (
478 TknBStr32 *tknStr,             /* token string */
479 Buffer    *mBuf                /* message buffer */
480 )
481 {
482
483    CMUNPKTKNBSTR(tknStr, mBuf);
484
485    return ROK;
486
487 } /* end of cmUnpkTknBStr32 */
488
489 \f
490 /*
491  *
492  *      Fun:   cmUnpkTknStr8
493  *
494  *      Desc:  This function packs a token string of size 8
495  *
496  *      Ret:   ROK      - ok
497  *
498  *      Notes: None
499  *
500         File:  cm_tkns.c
501  *
502  */
503   
504 S16 cmUnpkTknStr8
505 (
506 TknStr8 *tknStr,             /* token string */
507 Buffer  *mBuf                /* message buffer */
508 )
509 {
510
511    CMUNPKTKNSTR(tknStr, mBuf);
512
513    return ROK;
514
515 } /* end of cmUnpkTknStr8 */
516
517 \f
518 /*
519  *
520  *      Fun:   cmUnpkTknStr16
521  *
522  *      Desc:  This function packs a token string of size 16
523  *
524  *      Ret:   ROK      - ok
525  *
526  *      Notes: None
527  *
528         File:  cm_tkns.c
529  *
530  */
531   
532 S16 cmUnpkTknStr16
533 (
534 TknStr16 *tknStr,             /* token string */
535 Buffer   *mBuf                /* message buffer */
536 )
537 {
538
539    CMUNPKTKNSTR(tknStr, mBuf);
540
541    return ROK;
542
543 } /* end of cmUnpkTknStr16 */
544
545 \f
546 /*
547  *
548  *      Fun:   cmUnpkTknStrOSXL
549  *
550  *      Desc:  This function packs a long octet token string
551  *
552  *      Ret:   ROK      - ok
553  *
554  *      Notes: None
555  *
556         File:  cm_tkns.c
557  *
558  */
559   
560 S16 cmUnpkTknStrOSXL
561 (
562 TknStrOSXL *tknStr,             /* token string */
563 Buffer     *mBuf,               /* message buffer */
564 Ptr         ptr                 /* pointer to memory control block */
565 )
566 {
567    uint16_t ndx;
568
569    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
570
571    if(tknStr->pres)
572    {
573       /* Length */
574       CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
575
576       if( cmGetMem(ptr, tknStr->len, (Ptr *)&tknStr->val) != ROK)
577       {
578          return RFAILED;
579       }
580       /* Value */
581       for (ndx = 1; ndx <= tknStr->len; ndx++)
582       {
583          CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - ndx], mBuf);
584       }
585    }
586
587    return ROK;
588
589 } /* end of cmUnpkTknStrOSXL */
590
591
592 \f
593 /*
594  *
595  *      Fun:   cmUnpkTknStrBSXL
596  *
597  *      Desc:  This function packs a long bit token string
598  *
599  *      Ret:   ROK      - ok
600  *
601  *      Notes: None
602  *
603         File:  cm_tkns.c
604  *
605  */
606   
607 S16 cmUnpkTknStrBSXL
608 (
609 TknStrBSXL *tknStr,             /* token string */
610 Ptr         ptr,                /* pointer to memory control block */
611 Buffer     *mBuf                /* message buffer */
612 )
613 {
614    uint16_t ndx;
615    uint16_t len;
616
617
618    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
619
620    if(tknStr->pres)
621    {
622       /* Length */
623       CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
624
625       if (tknStr->len % 8)
626          len = (tknStr->len/8) + 1;
627       else
628          len = (tknStr->len/8);
629          
630       if( cmGetMem(ptr, len, (Ptr *)&tknStr->val) != ROK)
631       {
632          return RFAILED;
633       }
634       /* Value */
635       for (ndx = 1; ndx <= len; ndx++)
636       {
637          CMCHKUNPK(oduPackUInt8, &tknStr->val[len - ndx], mBuf);
638       }
639    }
640
641    return ROK;
642
643 } /* end of cmUnpkTknStrBSXL */
644
645 \f  
646 /*
647  *
648  *      Fun:   cmUnpkTknStrBMP4
649  *
650  *      Desc:  This function unpacks a BMP token string of size 4
651  *
652  *      Ret:   ROK      - ok
653  *
654  *      Notes: None
655  *
656         File:  cm_tkns.c
657  *
658  */
659   
660 S16 cmUnpkTknStrBMP4
661 (
662 TknStrBMP4 *tknStr,             /* token string */
663 Buffer     *mBuf                /* message buffer */
664 )
665 {
666    uint8_t ndx;
667
668
669    /* Token Header */
670    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
671
672    if(tknStr->pres)
673    {
674       /* Length */
675       CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
676
677       /* Value */
678       for (ndx = 1; ndx <= tknStr->len; ndx++)
679       {
680          CMCHKUNPK(oduPackUInt16, &tknStr->val[tknStr->len - ndx], mBuf);
681       }
682    }
683
684    return ROK;
685 } /* end of cmUnpkTknStrBMP4 */
686
687 \f
688 /*
689  *
690  *      Fun:   cmUnpkTknStrBMPXL
691  *
692  *      Desc:  This function packs a long octet token string
693  *
694  *      Ret:   ROK      - ok
695  *
696  *      Notes: None
697  *
698         File:  cm_tkns.c
699  *
700  */
701   
702 S16 cmUnpkTknStrBMPXL
703 (
704 TknStrBMPXL *tknStr,             /* token string */
705 Buffer      *mBuf,               /* message buffer */
706 Ptr          ptr                 /* pointer to memory control block */
707 )
708 {
709    uint16_t ndx;
710
711
712    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
713
714    if(tknStr->pres)
715    {
716       /* Length */
717       CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
718
719       /* Each BMP Character is 2 octet long */
720       if( cmGetMem(ptr, 2*(tknStr->len), (Ptr *)&tknStr->val) != ROK)
721       {
722          return RFAILED;
723       }
724       /* Value */
725       for (ndx = 1; ndx <= tknStr->len; ndx++)
726       {
727          CMCHKUNPK(oduPackUInt16, &tknStr->val[tknStr->len - ndx], mBuf);
728       }
729    }
730
731    return ROK;
732
733 } /* end of cmUnpkTknStrBMPXL */
734
735 \f  
736 /*
737  *
738  *      Fun:   cmUnpkTknStrUNI4
739  *
740  *      Desc:  This function unpacks a UNI token string of size 4
741  *
742  *      Ret:   ROK      - ok
743  *
744  *      Notes: None
745  *
746         File:  cm_tkns.c
747  *
748  */
749   
750 S16 cmUnpkTknStrUNI4
751 (
752 TknStrUNI4 *tknStr,             /* token string */
753 Buffer     *mBuf                /* message buffer */
754 )
755 {
756    uint8_t ndx;
757
758
759    /* Token Header */
760    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
761
762    if(tknStr->pres)
763    {
764       /* Length */
765       CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
766
767       /* Value */
768       for (ndx = 1; ndx <= tknStr->len; ndx++)
769       {
770          CMCHKUNPK(oduPackUInt32, &tknStr->val[tknStr->len - ndx], mBuf);
771       }
772    }
773
774    return ROK;
775 } /* end of cmUnpkTknStrUNI4 */
776
777 \f
778 /*
779  *
780  *      Fun:   cmUnpkTknStrUNIXL
781  *
782  *      Desc:  This function packs a long octet token string
783  *
784  *      Ret:   ROK      - ok
785  *
786  *      Notes: None
787  *
788         File:  cm_tkns.c
789  *
790  */
791   
792 S16 cmUnpkTknStrUNIXL
793 (
794 TknStrUNIXL *tknStr,             /* token string */
795 Buffer      *mBuf,               /* message buffer */
796 Ptr          ptr                 /* pointer to memory control block */
797 )
798 {
799    uint16_t ndx;
800
801
802    CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
803
804    if(tknStr->pres)
805    {
806       /* Length */
807       CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
808
809       /* Each UNI Character is 4 octets long */
810       if( cmGetMem(ptr, 4*tknStr->len, (Ptr *)&tknStr->val) != ROK)
811       {
812          return RFAILED;
813       }
814       /* Value */
815       for (ndx = 1; ndx <= tknStr->len; ndx++)
816       {
817          CMCHKUNPK(oduPackUInt32, &tknStr->val[tknStr->len - ndx], mBuf);
818       }
819    }
820
821    return ROK;
822
823 } /* end of cmUnpkTknStrUNIXL */
824
825 /**********************************************************************
826          End of file
827 **********************************************************************/