SIB1 optional parameters, Cell start request, stop request and slot indication
[o-du/l2.git] / src / cm / cm_tpt.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:     HCT Interface
22   
23      Type:     C file
24   
25      Desc:     This file contains the packing/unpacking functions
26                for the H.225 primitives on hct interface
27
28      File:     cm_tpt.c
29
30 *********************************************************************21*/
31 \f
32 /* header include files (.h) */
33
34 #include "envopt.h"        /* environment options */  
35 #include "envdep.h"        /* environment dependent */
36 #include "envind.h"        /* environment independent */
37
38 #include "gen.h"           /* general layer */
39 #include "ssi.h"           /* system service interface */
40
41 #include "cm_tpt.h"
42
43 /* header/extern include files (.x) */
44
45 #include "gen.x"           /* general layer */
46 #include "ssi.x"           /* system service interface */
47
48 /*#include "cm_tkns.x"*/
49 #include "cm_tpt.x"
50
51 \f
52 /* local defines */
53
54 /* local typedefs */
55
56 /* local externs */
57   
58 /* forward references */
59
60 /* local function definition */
61
62 /* functions in other modules */
63
64 /* public variable declarations */
65
66 /* control variables for testing */
67
68 /* private variable declarations */
69
70 /*
71  * support functions
72  */
73
74 /*  cm_tpt_c_001.main_17 - Guarded under LCEGT and LCLEG */
75 /*  cm_tpt_c_001.main_18 - Guarded under LWLCEGT */
76 \f
77 #if    (   defined(LCHCT) || defined (LWLCHCT) || defined(LCHIT) \
78         || defined(LCLHC) || defined(TRIL_HZ) \
79         || defined(LCHRT) || defined(LCLHR)   \
80         || defined(LCLMG) || defined(LCMGT)   \
81         || defined(LCLHG) || defined(LCHGT)   \
82         || defined(LCSCT) || defined(LCLSB)   \
83         || defined(LCLNT) || defined(LCLLN)   \
84         || defined(LCLSO) || defined(LCSOT)   \
85         || defined(LCEGT) || defined(LCLEG)   || defined(LWLCEGT) \
86         || defined(CM_COMPRESS)   \
87        )
88
89 #ifdef __cplusplus
90 extern "C" {
91 #endif
92    /* Add prototypes here  (MB) */
93
94 #ifdef __cplusplus
95 }
96 #endif
97
98 \f  
99
100 /*
101  *      PACKING FUNCTIONS
102  */
103 /* Moving IPv4 address packing functions from cm_inet.c */
104 /*
105 *
106 *       Fun:   cmPkCmIpv4TptAddr
107 *
108 *       Desc:  This function packs the IPv4 address 
109 *
110 *       Ret:   ROK
111 *
112 *       Notes: None
113 *
114 *       File:  cm_tpt.c
115 *
116 */
117 #ifdef ANSI
118 PUBLIC S16 cmPkCmIpv4TptAddr
119 (
120 CmIpv4TptAddr            *pkParam,  /* IPv4 Address structure */
121 Buffer                   *mBuf      /* message buffer */
122 )
123 #else
124 PUBLIC S16 cmPkCmIpv4TptAddr (pkParam, mBuf)
125 CmIpv4TptAddr            *pkParam;  /* IPv4 Address structure */
126 Buffer                   *mBuf;     /* message buffer */
127 #endif
128 {
129    TRC2(cmPkCmIpv4TptAddr)
130
131    CMCHKPK(cmPkCmIpv4NetAddr, pkParam->address, mBuf);
132    CMCHKPK(SPkU16, pkParam->port, mBuf);
133
134    RETVALUE(ROK);
135 } /* cmPkCmIpv4TptAddr */
136
137 /*
138 *
139 *       Fun:   cmPkCmIpv6NetAddr
140 *
141 *       Desc:  This function packs the 16 bytes of IPv6 address 
142 *
143 *       Ret:   ROK
144 *
145 *       Notes: None
146 *
147 *       File:  cm_tpt.c
148 *
149 */
150 #ifdef ANSI
151 PRIVATE S16 cmPkCmIpv6NetAddr
152 (
153 CmIpv6NetAddr            *pkParam,     
154 Buffer                   *mBuf         /* message buffer */
155 )
156 #else
157 PRIVATE S16 cmPkCmIpv6NetAddr (pkParam, mBuf)
158 CmIpv6NetAddr            *pkParam;     
159 Buffer                   *mBuf;        /* message buffer */
160 #endif
161 {
162    U8 num;
163    U8 *ptr = (U8*)pkParam;
164
165    TRC3(cmPkCmIpv6NetAddr)
166
167    for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
168    {
169       CMCHKPK(SPkU8, *(ptr+num), mBuf);
170    }
171
172    RETVALUE(ROK);
173 } /* end of cmPkCmIpv6NetAddr */
174
175 \f
176 /*
177 *
178 *       Fun:   cmPkCmIpv6TptAddr
179 *
180 *       Desc:  This function packs the IPv6 transport address
181 *
182 *       Ret:   ROK
183 *
184 *       Notes: None
185 *
186 *       File:  cm_tpt.c
187 *
188 */
189 #ifdef ANSI
190 PRIVATE S16 cmPkCmIpv6TptAddr
191 (
192 CmIpv6TptAddr            *pkParam,     /* IPv6 transport address */
193 Buffer                   *mBuf         /* message buffer */
194 )
195 #else
196 PRIVATE S16 cmPkCmIpv6TptAddr (pkParam, mBuf)
197 CmIpv6TptAddr            *pkParam;     /* IPv6 transport address */
198 Buffer                   *mBuf;        /* message buffer */
199 #endif
200 {
201    TRC3(cmPkCmIpv6TptAddr)
202
203    CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6NetAddr, mBuf);
204    CMCHKPK(SPkU16, pkParam->port, mBuf);
205
206    RETVALUE(ROK);
207 }   /* cmPkCmIpv6TptAddr */
208
209 \f
210 /*
211 *
212 *       Fun:   cmPkCmNetAddrTbl
213 *
214 *       Desc:  This function packs the 
215 *
216 *       Ret:   ROK
217 *
218 *       Notes: None
219 *
220 *       File:  cm_tpt.c
221 *
222 */
223 #ifdef ANSI
224 PUBLIC S16 cmPkCmNetAddrTbl
225 (
226 CmNetAddrTbl            *pkParam,      /* Network Address Table */
227 Buffer                  *mBuf          /* message buffer */
228 )
229 #else
230 PUBLIC S16 cmPkCmNetAddrTbl (pkParam, mBuf)
231 CmNetAddrTbl            *pkParam;      /* Network Address Table */
232 Buffer                  *mBuf;         /* message buffer */
233 #endif
234 {
235    U16                  idx;           /* Loop Index */
236    CmNetAddr            *netAddr;      /* Network Address */
237
238    TRC2(cmPkCmNetAddrTbl)
239
240    if (pkParam->count > CM_MAX_NET_ADDR)
241       RETVALUE(RFAILED);
242
243    /* Pack All the addresses */
244    for (idx = pkParam->count; idx; idx--)
245    {
246       netAddr = &(pkParam->netAddr[idx - 1]);
247
248       if ((cmPkCmNetAddr(netAddr, mBuf)) != ROK)
249          RETVALUE(RFAILED);
250    }
251
252    /* Pack the total number of addresses present in the table */
253    CMCHKPK(SPkU16, pkParam->count, mBuf);
254
255    RETVALUE(ROK);
256
257 } /* end of cmPkCmNetAddrTbl() */
258
259 /*
260 *
261 *       Fun:   cmPkCmNetAddr
262 *
263 *       Desc:  This function packs the 
264 *
265 *       Ret:   ROK
266 *
267 *       Notes: None
268 *
269 *       File:  cm_tpt.c
270 *
271 */
272 #ifdef ANSI
273 PUBLIC S16 cmPkCmNetAddr
274 (
275 CmNetAddr                *pkParam,     
276 Buffer                   *mBuf         /* message buffer */
277 )
278 #else
279 PUBLIC S16 cmPkCmNetAddr (pkParam, mBuf)
280 CmNetAddr                *pkParam;     
281 Buffer                   *mBuf;        /* message buffer */
282 #endif
283 {
284    TRC3(cmPkCmNetAddr)
285
286    switch (pkParam->type)
287    {
288       case CM_NETADDR_NOTPRSNT:
289          break;
290
291       case CM_NETADDR_IPV4:
292          CMCHKPK(cmPkCmIpv4NetAddr, pkParam->u.ipv4NetAddr, mBuf);
293          break;
294
295       case CM_NETADDR_IPV6:
296          CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->u.ipv6NetAddr, mBuf);
297          break;
298
299       default:
300          RETVALUE(RFAILED);
301    }
302    CMCHKPK(SPkU8, pkParam->type, mBuf);
303
304    RETVALUE(ROK);
305 }   /* cmPkCmNetAddr */
306
307 \f
308 /*
309 *
310 *       Fun:   cmPkCmTptAddr
311 *
312 *       Desc:  This function packs the 
313 *
314 *       Ret:   ROK
315 *
316 *       Notes: None
317 *
318 *       File:  cm_tpt.c
319 *
320 */
321 #ifdef ANSI
322 PUBLIC S16 cmPkCmTptAddr
323 (
324 CmTptAddr                *pkParam,     
325 Buffer                   *mBuf         /* message buffer */
326 )
327 #else
328 PUBLIC S16 cmPkCmTptAddr (pkParam, mBuf)
329 CmTptAddr                *pkParam;     
330 Buffer                   *mBuf;        /* message buffer */
331 #endif
332 {
333    TRC3(cmPkCmTptAddr)
334
335    switch (pkParam->type)
336    {
337       case CM_TPTADDR_NOTPRSNT:
338          break;
339
340       case CM_TPTADDR_IPV4:
341          CMCHKPK(cmPkCmIpv4TptAddr, &pkParam->u.ipv4TptAddr, mBuf);
342          break;
343
344       case CM_TPTADDR_IPV6:
345          CMCHKPK(cmPkCmIpv6TptAddr, &pkParam->u.ipv6TptAddr, mBuf);
346          break;
347    
348       default:
349          RETVALUE(RFAILED);
350    }
351    CMCHKPK(SPkU8, pkParam->type, mBuf);
352
353    RETVALUE(ROK);
354 }   /* cmPkCmTptAddr */
355
356 /* added new packing functions */
357 #ifdef LOCAL_INTF
358 /*
359 *
360 *       Fun:   cmPkCmTptLocalInf
361 *
362 *       Desc:  This function packs the local interface info on which IPV4/IPV6
363 *              packet was received on.
364 *
365 *       Ret:   ROK
366 *
367 *       Notes: None
368 *
369 *       File:  cm_tpt.c
370 *
371 */
372 #ifdef ANSI
373 PUBLIC S16 cmPkCmTptLocalInf
374 (
375 CmTptLocalInf           *pkParam,   /* local interface info */
376 Buffer                  *mBuf       /* message buffer */
377 )
378 #else
379 PUBLIC S16 cmPkCmTptLocalInf (pkParam, mBuf)
380 CmTptLocalInf           *pkParam;   /* local interface info */
381 Buffer                  *mBuf;      /* message buffer */
382 #endif
383 {
384    TRC3(cmPkCmTptLocalInf)
385
386    if (pkParam->intfPrsnt == TRUE)
387    {  
388       /* pack the actual interface address */ 
389       CMCHKPK(cmPkCmNetAddr, &pkParam->localIfAddr, mBuf); 
390       /* pack the interface index value */
391       CMCHKPK(SPkU32, pkParam->localIf, mBuf);
392    }
393    /* pack the boll which indicates if valid local intf is present or not */
394    CMCHKPK(SPkU8, pkParam->intfPrsnt, mBuf);
395    RETVALUE(ROK);
396 }   /* cmPkCmTptLocalInf */
397 #endif /* LOCAL_INTF */
398
399 /* Moving IPv6 multicast information packing functions from cm_inet.c */
400 #ifdef IPV6_SUPPORTED
401 /*
402 *
403 *       Fun:   cmPkCmNetMCastInf6
404 *
405 *       Desc:  This function packs the IPv6 multicast information 
406 *
407 *       Ret:   ROK
408 *
409 *       Notes: None
410 *
411 *       File:  cm_tpt.c
412 *
413 */
414 #ifdef ANSI
415 PUBLIC S16 cmPkCmNetMCastInf6
416 (
417 CmNetMCastInf6            *pkParam,     /* IPv6 multicast information */
418 Buffer                    *mBuf         /* message buffer */
419 )
420 #else
421 PUBLIC S16 cmPkCmNetMCastInf6(pkParam, mBuf)
422 CmNetMCastInf6            *pkParam;     /* IPv6 multicast information */
423 Buffer                    *mBuf;        /* message buffer */
424 #endif
425 {
426    TRC3(cmPkCmNetMCastInf6)
427
428    CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->mCastAddr, mBuf);
429    CMCHKPK(SPkU32, pkParam->localInf, mBuf);
430
431    RETVALUE(ROK);
432 }   /* cmPkCmNetMCastInf6 */
433 #endif /* IPV6_SUPPORTED */
434
435 \f
436 /*
437 *
438 *       Fun:   cmPkCmSockOpts
439 *
440 *       Desc:  This function packs the 
441 *
442 *       Ret:   ROK
443 *
444 *       Notes: None
445 *
446 *       File:  cm_tpt.c
447 *
448 */
449 #ifdef ANSI
450 PRIVATE S16 cmPkCmSockOpts
451 (
452 CmSockOpts               *pkParam,     
453 Buffer                   *mBuf         /* message buffer */
454 )
455 #else
456 PRIVATE S16 cmPkCmSockOpts (pkParam, mBuf)
457 CmSockOpts               *pkParam;     
458 Buffer                   *mBuf;        /* message buffer */
459 #endif
460 {
461    TRC3(cmPkCmSockOpts)
462
463    switch (pkParam->option)
464    {
465       case CM_SOCKOPT_OPT_ADD_MCAST_MBR:
466       case CM_SOCKOPT_OPT_DRP_MCAST_MBR:
467 #ifdef CM_INET2
468          CMCHKPK(cmPkCmNetAddr, &pkParam->optVal.mCastInfo.mCastAddr, mBuf);
469          CMCHKPK(cmPkCmNetAddr, &pkParam->optVal.mCastInfo.localAddr, mBuf);
470 #else
471          CMCHKPK(cmPkCmNetAddr, &pkParam->optVal.mCastAddr, mBuf);
472 #endif /* CM_INET2 */
473          break;
474
475       case CM_SOCKOPT_OPT_MCAST_IF:
476          CMCHKPK(cmPkCmNetAddr, &pkParam->optVal.lclAddr, mBuf);
477          break;
478
479 #ifdef IPV6_SUPPORTED
480       case CM_SOCKOPT_OPT_ADD_MCAST6_MBR:
481       case CM_SOCKOPT_OPT_DRP_MCAST6_MBR:
482          CMCHKPK(cmPkCmNetMCastInf6, &pkParam->optVal.mCastInfo6, mBuf);
483          break;
484
485       case CM_SOCKOPT_OPT_MCAST6_IF:
486          CMCHKPK(SPkU32, pkParam->optVal.infId, mBuf);
487          break;
488
489 #endif /* IPV6_SUPPORTED */
490
491       default:
492          CMCHKPK(SPkU32, pkParam->optVal.value, mBuf);
493          break;
494    }
495    CMCHKPK(SPkU32, pkParam->option, mBuf);
496    CMCHKPK(SPkU32, pkParam->level, mBuf);
497
498    RETVALUE(ROK);
499 }   /* cmPkCmSockOpts */
500
501 \f
502 /*
503 *
504 *       Fun:   cmPkCmSockParam
505 *
506 *       Desc:  This function packs the 
507 *
508 *       Ret:   ROK
509 *
510 *       Notes: None
511 *
512 *       File:  cm_tpt.c
513 *
514 */
515 #ifdef ANSI
516 PRIVATE S16 cmPkCmSockParam
517 (
518 CmSockParam              *pkParam,     
519 Buffer                   *mBuf         /* message buffer */
520 )
521 #else
522 PRIVATE S16 cmPkCmSockParam (pkParam, mBuf)
523 CmSockParam              *pkParam;     
524 Buffer                   *mBuf;        /* message buffer */
525 #endif
526 {
527    U32 num;
528
529    TRC3(cmPkCmSockParam)
530
531    if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
532    {
533       RETVALUE(RFAILED);
534    }
535    for(num = 0; num < pkParam->numOpts; num++)
536    {
537       CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
538    }
539    CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
540    CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
541
542    RETVALUE(ROK);
543 }   /* cmPkCmSockParam */
544
545 \f
546 #ifdef CM_TLS
547 /*
548 *
549 *       Fun:   cmPkTlsTptParam
550 *
551 *       Desc:  This function packs the 
552 *
553 *       Ret:   ROK
554 *
555 *       Notes: None
556 *
557 *       File:  cm_tpt.c
558 *
559 */
560 #ifdef ANSI
561 PRIVATE S16 cmPkTlsTptParam
562 (
563 TlsTptParam              *pkParam,     /**/
564 Buffer                   *mBuf         /* message buffer */
565 )
566 #else
567 PRIVATE S16 cmPkTlsTptParam(pkParam, mBuf)
568 TlsTptParam              *pkParam;     /**/
569 Buffer                   *mBuf;        /* message buffer */
570 #endif
571 {
572    U32 num;
573
574    TRC3(cmPkTlsTptParam)
575
576    if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
577    {
578       RETVALUE(RFAILED);
579    }
580    for(num = 0; num < pkParam->numOpts; num++)
581    {
582       CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
583    }
584    CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
585    CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
586    CMCHKPK(SPkS16, pkParam->ctxId, mBuf);
587
588    RETVALUE(ROK);
589 }  /* cmPkTlsTptParam */
590
591 #endif  /* CM_TLS */
592
593 \f
594 /*
595 *
596 *       Fun:   cmPkCmTptParam
597 *
598 *       Desc:  This function packs the 
599 *
600 *       Ret:   ROK
601 *
602 *       Notes: None
603 *
604 *       File:  cm_tpt.c
605 *
606 */
607 #ifdef ANSI
608 PUBLIC S16 cmPkCmTptParam
609 (
610 CmTptParam               *pkParam,     
611 Buffer                   *mBuf         /* message buffer */
612 )
613 #else
614 PUBLIC S16 cmPkCmTptParam (pkParam, mBuf)
615 CmTptParam               *pkParam;     
616 Buffer                   *mBuf;        /* message buffer */
617 #endif
618 {
619    TRC3(cmPkCmTptParam)
620
621    switch (pkParam->type)
622    {
623       case CM_TPTPARAM_NOTPRSNT:
624          break;
625
626       case CM_TPTPARAM_SOCK:
627          CMCHKPK(cmPkCmSockParam, &pkParam->u.sockParam, mBuf);
628          break;
629
630 #ifdef CM_AAL
631       case CM_TPTPARAM_AAL:
632          CMCHKPK(cmPkAalConParam, &pkParam->u.aalParam, mBuf);
633          break;
634 #endif
635
636 #ifdef CM_TLS
637       case CM_TPTPARAM_TLS:
638          CMCHKPK(cmPkTlsTptParam, &pkParam->u.tlsParam, mBuf);
639          break;
640 #endif
641
642       default:
643          RETVALUE(RFAILED);
644    }
645
646    CMCHKPK(SPkU8, pkParam->type, mBuf);
647
648    RETVALUE(ROK);
649 }   /* cmPkCmTptParam */
650
651 \f  
652 /*
653  *      UNPACKING FUNCTIONS
654  */
655
656 /* Moving IPv4 address un-packing functions from cm_inet.c file */
657
658 /*
659 *
660 *       Fun:   cmUnpkCmIpv4TptAddr
661 *
662 *       Desc:  This function unpacks the IPv4 address
663 *
664 *       Ret:   ROK
665 *
666 *       Notes: None
667 *
668 *       File:  cm_tpt.c
669 *
670 */
671 #ifdef ANSI
672 PUBLIC S16 cmUnpkCmIpv4TptAddr 
673 (
674 CmIpv4TptAddr            *unpkParam,     /* IPv4 Address */
675 Buffer                   *mBuf           /* message buffer */
676 )
677 #else
678 PUBLIC S16 cmUnpkCmIpv4TptAddr (unpkParam, mBuf)
679 CmIpv4TptAddr            *unpkParam;     /* IPv4 Address */
680 Buffer                   *mBuf;          /* message buffer */
681 #endif
682 {
683    TRC2(cmUnpkCmIpv4TptAddr)
684
685    CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
686    CMCHKUNPK(cmUnpkCmIpv4NetAddr, &unpkParam->address, mBuf);
687
688    RETVALUE(ROK);
689 }   /* cmUnpkCmIpv4TptAddr */
690
691 \f
692 /*
693 *
694 *       Fun:   cmUnpkCmIpv6NetAddr
695 *
696 *       Desc:  This function unpacks the 16 bytes of IPv6 address 
697 *
698 *       Ret:   ROK
699 *
700 *       Notes: None
701 *
702 *       File:  cm_tpt.c
703 *
704 */
705 #ifdef ANSI
706 PRIVATE S16 cmUnpkCmIpv6NetAddr
707 (
708 CmIpv6NetAddr            *unpkParam,   /* IPv6 address */
709 Buffer                   *mBuf         /* message buffer */
710 )
711 #else
712 PRIVATE S16 cmUnpkCmIpv6NetAddr (unpkParam, mBuf)
713 CmIpv6NetAddr            *unpkParam;   /* IPv6 address */
714 Buffer                   *mBuf;        /* message buffer */
715 #endif
716 {
717    U32 num;
718    U8 *ptr = (U8*)unpkParam;
719
720    TRC3(cmUnpkCmIpv6NetAddr)
721
722    ptr += (CM_INET_IPV6ADDR_SIZE - 1);
723
724    for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
725    {
726       CMCHKUNPK(SUnpkU8, (ptr-num), mBuf);
727    }
728
729    RETVALUE(ROK);
730 } /* end of cmUnpkCmIpv6NetAddr */
731
732 \f
733 /*
734 *
735 *       Fun:   cmUnpkCmIpv6TptAddr
736 *
737 *       Desc:  This function unpacks the IPv6 transport address
738 *
739 *       Ret:   ROK
740 *
741 *       Notes: None
742 *
743 *       File:  cm_tpt.c
744 *
745 */
746 #ifdef ANSI
747 PRIVATE S16 cmUnpkCmIpv6TptAddr
748 (
749 CmIpv6TptAddr            *unpkParam,   /* IPv6 transport address */
750 Buffer                   *mBuf         /* message buffer */
751 )
752 #else
753 PRIVATE S16 cmUnpkCmIpv6TptAddr (unpkParam, mBuf)
754 CmIpv6TptAddr            *unpkParam;   /* IPv6 transport address */
755 Buffer                   *mBuf;        /* message buffer */
756 #endif
757 {
758    TRC3(cmUnpkCmIpv6TptAddr)
759
760    CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
761    CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6NetAddr, mBuf);
762
763    RETVALUE(ROK);
764 }   /* cmUnpkCmIpv6TptAddr */
765
766 \f
767 /*
768 *
769 *       Fun:   cmUnpkCmNetAddrTbl
770 *
771 *       Desc:  This function unpacks the 
772 *
773 *       Ret:   ROK
774 *
775 *       Notes: None
776 *
777 *       File:  cm_tpt.c
778 *
779 */
780 #ifdef ANSI
781 PUBLIC S16 cmUnpkCmNetAddrTbl
782 (
783 CmNetAddrTbl            *unpkParam,    /* Network Address Table */
784 Buffer                  *mBuf          /* message buffer */
785 )
786 #else
787 PUBLIC S16 cmUnpkCmNetAddrTbl (unpkParam, mBuf )
788 CmNetAddrTbl            *unpkParam;    /* Network Address Table */
789 Buffer                  *mBuf;         /* message buffer */
790 #endif
791 {
792    U16                  idx;           /* Loop Index */
793    CmNetAddr            *netAddr;      /* Network Address */
794    
795    TRC2(cmUnpkCmNetAddrTbl)
796
797    /* Unpack the count */
798    CMCHKUNPK(SUnpkU16, &(unpkParam->count), mBuf);
799
800    /* Unpack the addresses */
801    for (idx = 0; idx < unpkParam->count; idx++)
802    {
803       netAddr = &(unpkParam->netAddr[idx]);
804
805       if ((cmUnpkCmNetAddr(netAddr, mBuf)) != ROK)
806          RETVALUE(RFAILED);
807    }
808
809    RETVALUE(ROK);
810
811 } /* end of cmUnpkCmNetAddrTbl() */
812
813 \f
814 /*
815 *
816 *       Fun:   cmUnpkCmNetAddr
817 *
818 *       Desc:  This function unpacks the network address
819 *
820 *       Ret:   ROK
821 *
822 *       Notes: None
823 *
824 *       File:  cm_tpt.c
825 *
826 */
827 #ifdef ANSI
828 PUBLIC S16 cmUnpkCmNetAddr
829 (
830 CmNetAddr                *unpkParam,   
831 Buffer                   *mBuf         /* message buffer */
832 )
833 #else
834 PUBLIC S16 cmUnpkCmNetAddr (unpkParam, mBuf )
835 CmNetAddr                *unpkParam;   
836 Buffer                   *mBuf;        /* message buffer */
837 #endif
838 {
839    TRC3(cmUnpkCmNetAddr)
840
841    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
842
843    switch (unpkParam->type)
844    {
845       case CM_NETADDR_NOTPRSNT:
846          break;
847
848       case CM_NETADDR_IPV4:
849          CMCHKUNPK(cmUnpkCmIpv4NetAddr, &unpkParam->u.ipv4NetAddr, mBuf);
850          break;
851
852       case CM_NETADDR_IPV6:
853          CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->u.ipv6NetAddr, mBuf);
854          break;
855
856       default:
857          RETVALUE(RFAILED);
858    }
859
860    RETVALUE(ROK);
861 }   /* cmUnpkCmNetAddr */
862
863 \f
864 /*
865 *
866 *       Fun:   cmUnpkCmTptAddr
867 *
868 *       Desc:  This function unpacks the 
869 *
870 *       Ret:   ROK
871 *
872 *       Notes: None
873 *
874 *       File:  cm_tpt.c
875 *
876 */
877 #ifdef ANSI
878 PUBLIC S16 cmUnpkCmTptAddr
879 (
880 CmTptAddr                *unpkParam,   
881 Buffer                   *mBuf         /* message buffer */
882 )
883 #else
884 PUBLIC S16 cmUnpkCmTptAddr (unpkParam, mBuf)
885 CmTptAddr                *unpkParam;   
886 Buffer                   *mBuf;        /* message buffer */
887 #endif
888 {
889    TRC3(cmUnpkCmTptAddr)
890
891    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
892
893    switch (unpkParam->type)
894    {
895       case CM_TPTADDR_NOTPRSNT:
896          break;
897
898       case CM_TPTADDR_IPV4:
899          CMCHKUNPK(cmUnpkCmIpv4TptAddr, &unpkParam->u.ipv4TptAddr, mBuf);
900          break;
901
902       case CM_TPTADDR_IPV6:
903          CMCHKUNPK(cmUnpkCmIpv6TptAddr, &unpkParam->u.ipv6TptAddr, mBuf);
904          break;
905
906       default:
907          RETVALUE(RFAILED);
908    }
909
910    RETVALUE(ROK);
911 }   /* cmUnpkCmTptAddr */
912
913 /* Moving IPv6 multicast information unpacking functions from cm_inet.c */
914 #ifdef IPV6_SUPPORTED
915 \f
916 /*
917 *
918 *       Fun:   cmUnpkCmNetMCastInf6
919 *
920 *       Desc:  This function unpacks the IPv6 multicast information 
921 *
922 *       Ret:   ROK
923 *
924 *       Notes: None
925 *
926 *       File:  cm_tpt.c
927 *
928 */
929 #ifdef ANSI
930 PUBLIC S16 cmUnpkCmNetMCastInf6
931 (
932 CmNetMCastInf6            *unpkParam,   /* IPv6 multicast information */
933 Buffer                    *mBuf         /* message buffer */
934 )
935 #else
936 PUBLIC S16 cmUnpkCmNetMCastInf6(unpkParam, mBuf)
937 CmNetMCastInf6            *unpkParam;   /* IPv6 multicast information */
938 Buffer                    *mBuf;        /* message buffer */
939 #endif
940 {
941    TRC3(cmUnpkCmNetMCastInf6)
942
943     CMCHKUNPK(SUnpkU32, &unpkParam->localInf, mBuf);
944     CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->mCastAddr, mBuf);
945
946    RETVALUE(ROK);
947 }   /* cmUnpkCmNetMCastInf6 */
948 #endif /* IPV6_SUPPORTED */
949
950 \f
951 /*
952 *
953 *       Fun:   cmUnpkCmSockOpts
954 *
955 *       Desc:  This function unpacks the socket options
956 *
957 *       Ret:   ROK
958 *
959 *       Notes: None
960 *
961 *       File:  cm_tpt.c
962 *
963 */
964 #ifdef ANSI
965 PRIVATE S16 cmUnpkCmSockOpts
966 (
967 CmSockOpts               *unpkParam,   /* socket options */
968 Buffer                   *mBuf         /* message buffer */
969 )
970 #else
971 PRIVATE S16 cmUnpkCmSockOpts (unpkParam, mBuf)
972 CmSockOpts               *unpkParam;   /* socket options */
973 Buffer                   *mBuf;        /* message buffer */
974 #endif
975 {
976    TRC3(cmUnpkCmSockOpts)
977
978    CMCHKUNPK(SUnpkU32, &unpkParam->level, mBuf);
979    CMCHKUNPK(SUnpkU32, &unpkParam->option, mBuf);
980
981    switch (unpkParam->option)
982    {
983       case CM_SOCKOPT_OPT_ADD_MCAST_MBR:
984       case CM_SOCKOPT_OPT_DRP_MCAST_MBR:
985 #ifdef CM_INET2
986          CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->optVal.mCastInfo.localAddr, 
987                    mBuf);
988          CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->optVal.mCastInfo.mCastAddr, 
989                    mBuf);
990 #else
991          CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->optVal.mCastAddr, mBuf);
992 #endif /* CM_INET2 */
993          break;
994
995       case CM_SOCKOPT_OPT_MCAST_IF:
996          CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->optVal.lclAddr, mBuf);
997          break;
998
999 #ifdef IPV6_SUPPORTED
1000       case CM_SOCKOPT_OPT_ADD_MCAST6_MBR:
1001       case CM_SOCKOPT_OPT_DRP_MCAST6_MBR:
1002          CMCHKUNPK(cmUnpkCmNetMCastInf6, &unpkParam->optVal.mCastInfo6, mBuf);
1003          break;
1004
1005       case CM_SOCKOPT_OPT_MCAST6_IF:
1006          CMCHKUNPK(SUnpkU32, &unpkParam->optVal.infId, mBuf);
1007          break;
1008 #endif /* IPV6_SUPPORTED */
1009
1010       default:
1011          CMCHKUNPK(SUnpkU32, &unpkParam->optVal.value, mBuf);
1012          break;
1013    }
1014
1015    RETVALUE(ROK);
1016 }   /* cmUnpkCmSockOpts */
1017
1018 \f
1019 /*
1020 *
1021 *       Fun:   cmUnpkCmSockParam
1022 *
1023 *       Desc:  This function unpacks the socket parameters
1024 *
1025 *       Ret:   ROK
1026 *
1027 *       Notes: None
1028 *
1029 *       File:  cm_tpt.c
1030 *
1031 */
1032 #ifdef ANSI
1033 PRIVATE S16 cmUnpkCmSockParam
1034 (
1035 CmSockParam              *unpkParam,   /* socket parameters */
1036 Buffer                   *mBuf         /* message buffer */
1037 )
1038 #else
1039 PRIVATE S16 cmUnpkCmSockParam (unpkParam, mBuf)
1040 CmSockParam              *unpkParam;   /* socket parameters */
1041 Buffer                   *mBuf;        /* message buffer */
1042 #endif
1043 {
1044    U32 num;
1045
1046    TRC3(cmUnpkCmSockParam)
1047
1048    CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
1049    CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
1050
1051    if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
1052    {
1053       RETVALUE(RFAILED);
1054    }
1055
1056    for(num = 0; num < unpkParam->numOpts; num++)
1057    {
1058       CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
1059    }
1060
1061    RETVALUE(ROK);
1062 }   /* cmUnpkCmSockParam */
1063
1064 \f
1065 #ifdef CM_TLS
1066 /*
1067 *
1068 *       Fun:   cmUnpkTlsTptParam
1069 *
1070 *       Desc:  This function unpacks the socket parameters
1071 *
1072 *       Ret:   ROK
1073 *
1074 *       Notes: None
1075 *
1076 *       File:  cm_tpt.c
1077 *
1078 */
1079 #ifdef ANSI
1080 PRIVATE S16 cmUnpkTlsTptParam
1081 (
1082 TlsTptParam              *unpkParam,   /* TLS parameters */
1083 Buffer                   *mBuf         /* message buffer */
1084 )
1085 #else
1086 PRIVATE S16 cmUnpkTlsTptParam (unpkParam, mBuf)
1087 TlsTptParam              *unpkParam;   /* TLS parameters */
1088 Buffer                   *mBuf;        /* message buffer */
1089 #endif
1090 {
1091    U32 num;
1092
1093    TRC3(cmUnpkTlsTptParam)
1094
1095    CMCHKUNPK(SUnpkS16, &unpkParam->ctxId, mBuf);
1096    CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
1097    CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
1098
1099    if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
1100    {
1101       RETVALUE(RFAILED);
1102    }
1103
1104    for(num = 0; num < unpkParam->numOpts; num++)
1105    {
1106       CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
1107    }
1108
1109    RETVALUE(ROK);
1110 }  /* cmUnpkTlsTptParam */
1111
1112 #endif  /* CM_TLS */
1113
1114 \f
1115 /*
1116 *
1117 *       Fun:   cmUnpkCmTptParam
1118 *
1119 *       Desc:  This function unpacks the transport parameters 
1120 *
1121 *       Ret:   ROK
1122 *
1123 *       Notes: None
1124 *
1125 *       File:  cm_tpt.c
1126 *
1127 */
1128 #ifdef ANSI
1129 PUBLIC S16 cmUnpkCmTptParam
1130 (
1131 CmTptParam               *unpkParam,   /* transport parameters */
1132 Buffer                   *mBuf         /* message buffer */
1133 )
1134 #else
1135 PUBLIC S16 cmUnpkCmTptParam (unpkParam, mBuf)
1136 CmTptParam               *unpkParam;   /* transport parameters */
1137 Buffer                   *mBuf;        /* message buffer */
1138 #endif
1139 {
1140    TRC3(cmUnpkCmTptParam)
1141
1142    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
1143
1144    switch (unpkParam->type)
1145    {
1146       case CM_TPTPARAM_NOTPRSNT:
1147          break;
1148
1149       case CM_TPTPARAM_SOCK:
1150          CMCHKUNPK(cmUnpkCmSockParam, &unpkParam->u.sockParam, mBuf);
1151          break;
1152
1153 #ifdef CM_AAL
1154       case CM_TPTPARAM_AAL:
1155          CMCHKUNPK(cmUnpkAalConParam, &unpkParam->u.aalParam, mBuf);
1156          break;
1157 #endif
1158
1159 #ifdef CM_TLS
1160       case CM_TPTPARAM_TLS:
1161          CMCHKUNPK(cmUnpkTlsTptParam, &unpkParam->u.tlsParam, mBuf);
1162          break;
1163 #endif
1164
1165       default:
1166          RETVALUE(RFAILED);
1167    }
1168
1169    RETVALUE(ROK);
1170 }   /* cmUnpkCmTptParam */
1171
1172
1173 #ifdef CM_INET2  
1174 \f
1175 /*
1176 *
1177 *       Fun:   cmPkCmIpHdrParm
1178 *
1179 *       Desc:  This function packs the the IP hedear parameters for both 
1180 *              IPV4 and IPV6. 
1181 *
1182 *       Ret:   ROK
1183 *
1184 *       Notes: None
1185 *
1186 *       File:  cm_tpt.c
1187 *
1188 */
1189 #ifdef ANSI
1190 PUBLIC S16 cmPkCmIpHdrParm
1191 (
1192 CmIpHdrParm             *pkParam,   /* IP hdr parameters */ 
1193 Buffer                  *mBuf       /* message buffer */
1194 )
1195 #else
1196 PUBLIC S16 cmPkCmIpHdrParm (pkParam, mBuf)
1197 CmIpHdrParm             *pkParam;   /* IP hdr parameters */
1198 Buffer                  *mBuf;      /* message buffer */
1199 #endif
1200 {
1201    TRC3(cmPkCmIpHdrParm)
1202
1203    switch (pkParam->type)
1204    {
1205       case CM_HDRPARM_NOTPRSNT:
1206       case CM_HDRPARM_ICMP6:
1207          break;
1208
1209       case CM_HDRPARM_IPV4:
1210
1211          /* call to pack ipv4 options */
1212 #ifdef IPV4_OPTS_SUPPORTED
1213          /* ipv4 IP options */
1214          CMCHKPK(cmPkTknStr64, &pkParam->u.hdrParmIpv4.ipv4HdrOpt, mBuf);
1215 #endif /* IPV4_OPTS_SUPPORTED */
1216          
1217          CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.ttl, mBuf);
1218          CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.tos, mBuf);
1219          CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.dfBit, mBuf); 
1220          CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.proto, mBuf);
1221          break;
1222
1223       case CM_HDRPARM_IPV6:
1224 #ifdef IPV6_SUPPORTED    
1225          /* call to pack ipv6 extn hdrs */
1226 #ifdef IPV6_OPTS_SUPPORTED 
1227          /* pack IPV6 extension headers */
1228          CMCHKPK(cmPkCmIpv6ExtHdr, &pkParam->u.hdrParmIpv6.ipv6ExtHdr, mBuf);
1229 #endif /* IPV6_OPTS_SUPPORTED */
1230          CMCHKPK(cmPkCmNetAddr, &pkParam->u.hdrParmIpv6.srcAddr6, mBuf); 
1231          CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv6.ttl, mBuf);          
1232 #endif /* IPV6_SUPPORTED */ 
1233          break;
1234    
1235       default:
1236          RETVALUE(RFAILED);
1237    }
1238    CMCHKPK(SPkU8, pkParam->type, mBuf);
1239
1240    RETVALUE(ROK);
1241 }   /* End of cmPkCmIpHdrParm */
1242
1243 \f
1244 /* added new unpack function for local interface */
1245 #ifdef LOCAL_INTF
1246 /*
1247 *
1248 *       Fun:   cmUnpkCmTptLocalInf
1249 *
1250 *       Desc:  This function unpacks the local interface info on which 
1251 *              IPV4/IPV6 packet was received on.
1252 *
1253 *       Ret:   ROK
1254 *
1255 *       Notes: None
1256 *
1257 *       File:  cm_tpt.c
1258 *
1259 */
1260 #ifdef ANSI
1261 PUBLIC S16 cmUnpkCmTptLocalInf
1262 (
1263 CmTptLocalInf           *unpkParam, /* local interface info */
1264 Buffer                  *mBuf       /* message buffer */
1265 )
1266 #else
1267 PUBLIC S16 cmUnpkCmTptLocalInf (unpkParam, mBuf)
1268 CmTptLocalInf           *unpkParam; /* local interface info */
1269 Buffer                  *mBuf;      /* message buffer */
1270 #endif
1271 {
1272    TRC3(cmUnpkCmTptLocalInf)
1273
1274    /* first unpack the bool intfPrsnt value which is always packed */
1275    CMCHKUNPK(cmUnpkBool, &unpkParam->intfPrsnt, mBuf);
1276    
1277    /* if the above unpacked bool is TRUE then we have to unpack further
1278     * to get the local intf index and intf address */   
1279    if (unpkParam->intfPrsnt == TRUE)
1280    {   
1281       CMCHKUNPK(SUnpkU32, &unpkParam->localIf, mBuf);
1282       CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->localIfAddr, mBuf); 
1283    }
1284    RETVALUE(ROK);
1285 }   /* cmUnpkCmTptLocalInf */
1286 #endif /* LOCAL_INTF */
1287
1288 \f
1289 /* added new functions */
1290 #ifdef IPV6_OPTS_SUPPORTED 
1291 /*
1292 *       Fun:   cmPkCmIpv6ExtHdr
1293 *
1294 *       Desc:  This function packs the IPV6 extension headers
1295 *
1296 *       Ret:   ROK
1297 *
1298 *       Notes: None
1299 *
1300 *       File:  cm_tpt.c
1301 *
1302 */
1303 #ifdef ANSI
1304 PUBLIC S16 cmPkCmIpv6ExtHdr
1305 (
1306 CmIpv6ExtHdr             *pkParam,   /* IPV6 extension hdrs */
1307 Buffer                   *mBuf       /* message buffer */
1308 )
1309 #else
1310 PUBLIC S16 cmPkCmIpv6ExtHdr (pkParam, mBuf)
1311 CmIpv6ExtHdr             *pkParam;   /*IPV6 extension hdrs */
1312 Buffer                   *mBuf;      /* message buffer */
1313 #endif
1314 {
1315    TRC3(cmPkCmIpv6ExtHdr)
1316
1317    /* pack first Route hdr */   
1318    if (pkParam->rtOptsPrsnt)
1319       CMCHKPK(cmPkCmIpv6RtHdr, &pkParam->rtOpts, mBuf);  
1320    CMCHKPK(cmPkBool, pkParam->rtOptsPrsnt, mBuf);  
1321
1322    /* pack Dest Opt hdr */
1323    if (pkParam->destOptsPrsnt)
1324       CMCHKPK(cmPkCmIpv6DestOptsArr, &pkParam->destOptsArr, mBuf);  
1325    CMCHKPK(cmPkBool, pkParam->destOptsPrsnt, mBuf);  
1326
1327    /* pack HBH hdr */
1328    if (pkParam->hbhHdrPrsnt)
1329       CMCHKPK(cmPkCmIpv6HBHHdrArr, &pkParam->hbhOptsArr, mBuf);  
1330    CMCHKPK(cmPkBool, pkParam->hbhHdrPrsnt, mBuf);  
1331
1332    RETVALUE(ROK);
1333 } /* end of cmPkCmIpv6ExtHdr */
1334
1335 \f
1336 /*
1337 *
1338 *       Fun:   cmPkCmIpv6RtHdr
1339 *
1340 *       Desc:  This function packs the IPV6 route header
1341 *
1342 *       Ret:   ROK
1343 *
1344 *       Notes: None
1345 *
1346 *       File:  cm_tpt.c
1347 *
1348 */
1349 #ifdef ANSI
1350 PUBLIC S16 cmPkCmIpv6RtHdr
1351 (
1352 CmIpv6RtHdr             *pkParam,   /* IPV6 Route hdr */
1353 Buffer                   *mBuf      /* message buffer */
1354 )
1355 #else
1356 PUBLIC S16 cmPkCmIpv6RtHdr (pkParam, mBuf)
1357 CmIpv6RtHdr             *pkParam;   /* IPV6 Route hdr */
1358 Buffer                   *mBuf;     /* message buffer */
1359 #endif
1360 {
1361    U8 idx;
1362    
1363    TRC3(cmPkCmIpv6RtHdr);
1364
1365    /* pack all IPV6 addrs in the route hdr */
1366    for(idx = 0; idx < pkParam->numAddrs; idx++)
1367    {
1368       CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6Addrs[idx], mBuf);
1369    }
1370    /* pack reserve byte & strict/loose bit map */
1371    CMCHKPK(SPkU32, pkParam->slMap, mBuf);
1372    CMCHKPK(SPkU8, pkParam->numAddrs, mBuf);  
1373
1374    RETVALUE(ROK);
1375 } /* end of cmPkCmIpv6RtHdr */
1376
1377 \f
1378 /*
1379 *
1380 *       Fun:   cmUnpkCmIpv6RtHdr
1381 *
1382 *       Desc:  This function unpacks the IPV6 route header
1383 *
1384 *       Ret:   ROK
1385 *              ROUTRES - out of resources
1386 *
1387 *       Notes: None
1388 *
1389 *       File:  cm_tpt.c
1390 *
1391 */
1392 #ifdef ANSI
1393 PUBLIC S16 cmUnpkCmIpv6RtHdr
1394 (
1395 CmIpv6RtHdr             *unpkParam,  /* IPV6 Route hdr */
1396 Buffer                  *mBuf,       /* message buffer */
1397 Mem                     *memInfo     /* meminfo to allocate for Route hdr */
1398 )
1399 #else
1400 PUBLIC S16 cmUnpkCmIpv6RtHdr (unpkParam, mBuf, memInfo)
1401 CmIpv6RtHdr             *unpkParam;  /* IPV6 Route hdr */
1402 Buffer                  *mBuf;       /* message buffer */
1403 Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
1404 #endif
1405 {
1406    U8 idx;  /* array index */
1407    S32 retVal; /* temporary return value */
1408    
1409    TRC3(cmUnpkCmIpv6RtHdr);
1410    
1411    CMCHKUNPK(SUnpkU8, &unpkParam->numAddrs, mBuf);
1412    
1413    /* unpack reserve byte & strict/loose bit map */
1414    CMCHKUNPK(SUnpkU32, &unpkParam->slMap, mBuf);
1415    
1416    retVal = SGetSBuf(memInfo->region,    
1417                   memInfo->pool,                     
1418                  (Data **)&unpkParam->ipv6Addrs, 
1419                  (unpkParam->numAddrs * 16));
1420       
1421    if (retVal != ROK)
1422    {
1423       RETVALUE(ROUTRES);
1424    }
1425    
1426    /* unpack all IPV6 addrs in the route hdr */
1427    for(idx = 0; idx < unpkParam->numAddrs; idx++)
1428    {
1429       CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6Addrs[idx], mBuf);
1430    }
1431
1432    RETVALUE(ROK);
1433 } /* end of cmUnpkCmIpv6RtHdr */
1434
1435 \f
1436 /*
1437 *
1438 *       Fun:   cmUnpkCmIpv6ExtHdr
1439 *
1440 *       Desc:  This function unpacks the IPv6 extension header
1441 *
1442 *       Ret:   ROK
1443 *
1444 *       Notes: None
1445 *
1446 *       File:  cm_tpt.c
1447 *
1448 */
1449 #ifdef ANSI
1450 PUBLIC S16 cmUnpkCmIpv6ExtHdr
1451 (
1452 CmIpv6ExtHdr             *unpkParam,  /* IPV6 extension hdrs */
1453 Buffer                   *mBuf,       /* message buffer */
1454 Mem                      *memInfo     /* meminfo to allocate for IPV6 ext hdr */
1455 )
1456 #else
1457 PUBLIC S16 cmUnpkCmIpv6ExtHdr (unpkParam, mBuf, memInfo)
1458 CmIpv6ExtHdr             *unpkParam; /* IPV6 extension hdrs */
1459 Buffer                   *mBuf;      /* message buffer */
1460 Mem                      *memInfo;   /* meminfo to allocate for IPV6 ext hdr */
1461 #endif
1462 {
1463    TRC3(cmUnpkCmIpv6ExtHdr)
1464       
1465    /* unpack HBH hdr first */
1466    CMCHKUNPK(cmUnpkBool, &unpkParam->hbhHdrPrsnt, mBuf); 
1467    if (unpkParam->hbhHdrPrsnt)
1468       cmUnpkCmIpv6HBHHdrArr(&unpkParam->hbhOptsArr, mBuf, memInfo);         
1469                                                          
1470    /* unpack DEST opt hdr */
1471    CMCHKUNPK(cmUnpkBool, &unpkParam->destOptsPrsnt, mBuf);
1472    if (unpkParam->destOptsPrsnt)
1473       cmUnpkCmIpv6DestOptsArr(&unpkParam->destOptsArr, mBuf, memInfo);   
1474
1475    /* unpack Route hdr last */
1476    CMCHKUNPK(cmUnpkBool, &unpkParam->rtOptsPrsnt, mBuf); 
1477    if (unpkParam->rtOptsPrsnt)
1478       cmUnpkCmIpv6RtHdr(&unpkParam->rtOpts, mBuf, memInfo);  
1479                                                         
1480    RETVALUE(ROK);
1481 } /* end of cmUnpkCmIpv6ExtHdr */
1482
1483 \f
1484 /*
1485 *
1486 *       Fun:   cmPkCmIpv6DestOptsArr
1487 *
1488 *       Desc:  This function packs the IPV6 Destination Option array
1489 *
1490 *       Ret:   ROK
1491 *
1492 *       Notes: None
1493 *
1494 *       File:  cm_tpt.c
1495 *
1496 */
1497 #ifdef ANSI
1498 PUBLIC S16 cmPkCmIpv6DestOptsArr
1499 (
1500 CmIpv6DestOptsArr       *pkParam,  /* IPV6 Dest hdr array */
1501 Buffer                  *mBuf      /* message buffer */
1502 )
1503 #else
1504 PUBLIC S16 cmPkCmIpv6DestOptsArr (pkParam, mBuf)
1505 CmIpv6DestOptsArr       *pkParam;  /* IPV6 Dest hdr array */
1506 Buffer                  *mBuf;     /* message buffer */
1507 #endif
1508 {
1509
1510    U8 numOptions;
1511
1512    TRC3(cmPkCmIpv6DestOptsArr);
1513    
1514    /* pack all HBH options */
1515    for(numOptions = 0; numOptions<pkParam->numDestOpts; numOptions++)  
1516       CMCHKPK(cmPkCmIpv6DestOptsHdr, &pkParam->destOpts[numOptions], mBuf);
1517    CMCHKPK(SPkU8, pkParam->numDestOpts, mBuf);  
1518
1519    RETVALUE(ROK);
1520 } /* end of cmPkCmIpv6DestOptsArr */
1521
1522 \f
1523 /*
1524 *
1525 *       Fun:   cmPkCmIpv6DestOptsHdr
1526 *
1527 *       Desc:  This function packs individua IPV6 Destination Option
1528 *
1529 *       Ret:   ROK
1530 *
1531 *       Notes: None
1532 *
1533 *       File:  cm_tpt.c
1534 *
1535 */
1536 #ifdef ANSI
1537 PUBLIC S16 cmPkCmIpv6DestOptsHdr
1538 (
1539 CmIpv6DestOptsHdr       *pkParam,  /* IPV6 Dest opt */
1540 Buffer                  *mBuf      /* message buffer */
1541 )
1542 #else
1543 PUBLIC S16 cmPkCmIpv6DestOptsHdr (pkParam, mBuf)
1544 CmIpv6DestOptsHdr       *pkParam;  /* IPV6 Dest opt */
1545 Buffer                  *mBuf;     /* message buffer */
1546 #endif
1547 {
1548    U8 optLen;
1549    
1550    TRC3(cmPkCmIpv6DestOptsHdr);
1551
1552    for(optLen = 0; optLen < pkParam->length; optLen++)
1553    {
1554       CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
1555    }
1556    CMCHKPK(SPkU8, pkParam->length, mBuf);  
1557    CMCHKPK(SPkU8, pkParam->type, mBuf);  
1558
1559    RETVALUE(ROK);
1560 } /* end of cmPkCmIpv6DestOptsHdr */
1561
1562 \f
1563 /*
1564 *
1565 *       Fun:   cmUnpkCmIpv6DestOptsHdr
1566 *
1567 *       Desc:  This function unpacks individual IPV6 Dest Option
1568 *
1569 *       Ret:   ROK
1570 *
1571 *       Notes: None
1572 *
1573 *       File:  cm_tpt.c
1574 *
1575 */
1576 #ifdef ANSI
1577 PUBLIC S16 cmUnpkCmIpv6DestOptsHdr
1578 (
1579 CmIpv6DestOptsHdr       *unpkParam,/* IPV6 Dest Option */
1580 Buffer                  *mBuf,     /* message buffer */
1581 Mem                     *memInfo   /* meminfo to allocate mem for dest opt */
1582 )
1583 #else
1584 PUBLIC S16 cmUnpkCmIpv6DestOptsHdr (unpkParam, mBuf, memInfo)
1585 CmIpv6DestOptsHdr       *unpkParam;/* IPV6 Dest Option */
1586 Buffer                  *mBuf;     /* message buffer */
1587 Mem                     *memInfo;  /* meminfo to allocate mem for dest opt */
1588 #endif
1589 {
1590    S32 retVal;                        /* temporary return value */
1591    U8 optLen;                      /* length of value field */
1592
1593    TRC3(cmUnpkCmIpv6DestOptsHdr);
1594   
1595    /* unpack type, length */
1596    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);  
1597    CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
1598
1599    /* allocate static memory to hold the unpacked values */
1600    retVal = SGetSBuf(memInfo->region,                   
1601                   memInfo->pool,                     
1602                   (Data **)&unpkParam->value, (Size)unpkParam->length);
1603    if (retVal != ROK)
1604    {
1605       RETVALUE(ROUTRES);
1606    }
1607       
1608    /* unpack value fieldof this option */
1609    for(optLen = 0; optLen<unpkParam->length; optLen++)
1610    {
1611       CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);  
1612    }    
1613    
1614    RETVALUE(ROK);
1615 } /* end of cmUnpkCmIpv6DestOptsHdr */
1616
1617 \f
1618 /*
1619 *
1620 *       Fun:   cmUnpkCmIpv6DestOptsArr
1621 *
1622 *       Desc:  This function unpacks the IPV6 Destination Option array
1623 *
1624 *       Ret:   ROK
1625 *
1626 *       Notes: None
1627 *
1628 *       File:  cm_tpt.c
1629 *
1630 */
1631 #ifdef ANSI
1632 PUBLIC S16 cmUnpkCmIpv6DestOptsArr
1633 (
1634 CmIpv6DestOptsArr       *unpkParam, /* all IPV6 Destination Options */
1635 Buffer                  *mBuf,      /* message buffer */
1636 Mem                     *memInfo    /* meminfo to allocate mem for dest opts */
1637 )
1638 #else
1639 PUBLIC S16 cmUnpkCmIpv6DestOptsArr (unpkParam, mBuf, memInfo)
1640 CmIpv6DestOptsArr       *unpkParam; /* all IPV6 Destination Options */
1641 Buffer                  *mBuf;      /* message buffer */
1642 Mem                     *memInfo;   /* meminfo to allocate mem for dest opts */
1643 #endif
1644 {
1645    U8 numOptions;
1646    S16 retVal;
1647    
1648    TRC3(cmUnpkCmIpv6DestOptsArr);
1649
1650    CMCHKUNPK(SUnpkU8, &unpkParam->numDestOpts, mBuf); 
1651    if (unpkParam->numDestOpts)
1652    {
1653       /* allocate mem to hold all dest options */
1654       retVal = SGetSBuf(memInfo->region,    
1655                      memInfo->pool,                     
1656                      (Data **)&unpkParam->destOpts, 
1657                      (unpkParam->numDestOpts * sizeof(CmIpv6DestOptsHdr)));
1658       
1659       if (retVal != ROK)
1660       {
1661          RETVALUE(ROUTRES);
1662       }
1663    
1664       /* unpack all dest options */
1665       for(numOptions = 0; numOptions<unpkParam->numDestOpts; numOptions++)
1666          if ((retVal = cmUnpkCmIpv6DestOptsHdr(&unpkParam->destOpts[numOptions],
1667                                             mBuf, memInfo)) != ROK)
1668             RETVALUE(RFAILED);   
1669    
1670    }                                             
1671    RETVALUE(ROK);
1672 } /* end of cmUnpkCmIpv6DestOptsArr */
1673
1674 \f
1675 /*
1676 *
1677 *       Fun:   cmPkCmIpv6HBHHdrArr
1678 *
1679 *       Desc:  This function packs the all IPV6 HopByHop options
1680 *
1681 *       Ret:   ROK
1682 *
1683 *       Notes: None
1684 *
1685 *       File:  cm_tpt.c
1686 *
1687 */
1688 #ifdef ANSI
1689 PUBLIC S16 cmPkCmIpv6HBHHdrArr
1690 (
1691 CmIpv6HBHHdrArr         *pkParam,  /* all IPV6 HopByHop options */
1692 Buffer                  *mBuf      /* message buffer */
1693 )
1694 #else
1695 PUBLIC S16 cmPkCmIpv6HBHHdrArr (pkParam, mBuf)
1696 CmIpv6HBHHdrArr         *pkParam;  /* IPV6 HopByHop options */
1697 Buffer                  *mBuf;     /* message buffer */
1698 #endif
1699 {
1700    U8 numOptions;
1701    
1702    TRC3(cmPkCmIpv6HBHHdrArr);
1703
1704    for(numOptions = 0; numOptions<pkParam->numHBHOpts; numOptions++)
1705       CMCHKPK(cmPkCmIpv6HBHHdr, &pkParam->hbhOpts[numOptions], mBuf);
1706                           
1707    CMCHKPK(SPkU8, pkParam->numHBHOpts, mBuf);  
1708
1709    RETVALUE(ROK);
1710 } /* end of cmPkCmIpv6HBHHdrArr */
1711
1712 \f
1713 /*
1714 *
1715 *       Fun:   cmPkCmIpv6HBHHdr
1716 *
1717 *       Desc:  This function packs individual IPV6 HBH options
1718 *
1719 *       Ret:   ROK
1720 *
1721 *       Notes: None
1722 *
1723 *       File:  cm_tpt.c
1724 *
1725 */
1726 #ifdef ANSI
1727 PUBLIC S16 cmPkCmIpv6HBHHdr
1728 (
1729 CmIpv6HBHHdr            *pkParam,  /* individual IPV6 HBH options */
1730 Buffer                  *mBuf      /* message buffer */
1731 )
1732 #else
1733 PUBLIC S16 cmPkCmIpv6HBHHdr (pkParam, mBuf)
1734 CmIpv6HBHHdr            *pkParam;  /* individual IPV6 HBH options */
1735 Buffer                  *mBuf;     /* message buffer */
1736 #endif
1737 {
1738    U8 optLen;
1739
1740    TRC3(cmPkCmIpv6HBHHdr);
1741
1742    /* pack value field */
1743    for(optLen = 0; optLen<pkParam->length; optLen++)
1744    {
1745       CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
1746    }
1747
1748    /* pack type, length fields */
1749    CMCHKPK(SPkU8, pkParam->length, mBuf);  
1750    CMCHKPK(SPkU8, pkParam->type, mBuf);  
1751
1752    RETVALUE(ROK);
1753 } /* end of cmPkCmIpv6HBHHdr */
1754
1755 \f
1756 /*
1757 *
1758 *       Fun:   cmUnpkCmIpv6HBHHdr
1759 *
1760 *       Desc:  This function unpacks individual IPV6 HBH Option
1761 *
1762 *       Ret:   ROK
1763 *
1764 *       Notes: None
1765 *
1766 *       File:  cm_tpt.c
1767 *
1768 */
1769 #ifdef ANSI
1770 PUBLIC S16 cmUnpkCmIpv6HBHHdr
1771 (
1772 CmIpv6HBHHdr            *unpkParam,/* individual IPV6 HBH Option */
1773 Buffer                  *mBuf,     /* message buffer */
1774 Mem                     *memInfo   /* meminfo to allocate mem for HBH opt */
1775 )
1776 #else
1777 PUBLIC S16 cmUnpkCmIpv6HBHHdr (unpkParam, mBuf, memInfo)
1778 CmIpv6HBHHdr            *unpkParam;/* individual IPV6 HBH Option */
1779 Buffer                  *mBuf;     /* message buffer */
1780 Mem                     *memInfo;  /* meminfo to allocate mem for HBH opt */
1781 #endif
1782 {
1783    S32 retVal;                     /* temporary return value */
1784    U8 optLen;                      /* length of value field */
1785   
1786    TRC3(cmUnpkCmIpv6HBHHdr)
1787    
1788    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);   
1789    CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
1790
1791    /* allocate static memory to hold the unpacked values */
1792    if (unpkParam->length)
1793    {
1794       retVal = SGetSBuf(memInfo->region,                   
1795                      memInfo->pool,                     
1796                      (Data **)&unpkParam->value, (Size)unpkParam->length); 
1797       if (retVal != ROK)
1798       {
1799          RETVALUE(ROUTRES);
1800       }
1801
1802       for(optLen = 0; optLen<unpkParam->length; optLen++)
1803          CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);  
1804    } 
1805       
1806    RETVALUE(ROK);
1807 } /* end of cmUnpkCmIpv6HBHHdr */
1808
1809 \f
1810 /*
1811 *
1812 *       Fun:   cmUnpkCmIpv6HBHHdrArr
1813 *
1814 *       Desc:  This function unpacks all IPV6 HopByHop options
1815 *
1816 *       Ret:   ROK
1817 *
1818 *       Notes: None
1819 *
1820 *       File:  cm_tpt.c
1821 *
1822 */
1823 #ifdef ANSI
1824 PUBLIC S16 cmUnpkCmIpv6HBHHdrArr
1825 (
1826 CmIpv6HBHHdrArr       *unpkParam,  /* all HBH options */
1827 Buffer                *mBuf,       /* message buffer */
1828 Mem                   *memInfo     /* meminfo to allocate space for HBH opt */
1829 )
1830 #else
1831 PUBLIC S16 cmUnpkCmIpv6HBHHdrArr (unpkParam, mBuf, memInfo)
1832 CmIpv6HBHHdrArr       *unpkParam;  /*  all HBH options */
1833 Buffer                *mBuf;       /* message buffer */
1834 Mem                   *memInfo;    /* meminfo to allocate space for HBH opt */
1835 #endif
1836 {
1837    U8 numOptions; 
1838    S16 retVal;
1839
1840    TRC3(cmUnpkCmIpv6HBHHdrArr);
1841
1842    CMCHKUNPK(SUnpkU8, &unpkParam->numHBHOpts, mBuf);   
1843    if (unpkParam->numHBHOpts)
1844    {
1845       /*  allocate space for all HBH options */
1846       retVal = SGetSBuf(memInfo->region,    
1847                      memInfo->pool,                     
1848                      (Data **)&unpkParam->hbhOpts, 
1849                      (unpkParam->numHBHOpts * sizeof(CmIpv6HBHHdr)));
1850       
1851       if (retVal != ROK)
1852       {
1853          RETVALUE(ROUTRES);
1854       }
1855
1856       for(numOptions = 0; numOptions<unpkParam->numHBHOpts; numOptions++)
1857          cmUnpkCmIpv6HBHHdr(&unpkParam->hbhOpts[numOptions], mBuf, memInfo);
1858    }                                              
1859    RETVALUE(ROK);
1860 } /* end of cmUnpkCmIpv6HBHHdrArr */
1861 #endif /* IPV6_OPTS_SUPPORTED */
1862
1863 \f  
1864 /*
1865 *
1866 *       Fun:   cmUnpkCmIPHdrParm
1867 *
1868 *       Desc:  This function unpacks the IP header parameters
1869 *
1870 *       Ret:   ROK
1871 *
1872 *       Notes: None
1873 *
1874 *       File:  cm_tpt.c
1875 *
1876 */
1877 #ifdef ANSI
1878 /* added */
1879 #ifdef IPV6_OPTS_SUPPORTED
1880 PUBLIC S16 cmUnpkCmIpHdrParm
1881 (
1882 CmIpHdrParm              *unpkParam,/* ip hdr parameters */
1883 Buffer                   *mBuf,     /* message buffer */
1884 Mem                      *memInfo   /* meminfo to allocate mem for ipHdrParam */
1885 )
1886 #else
1887 PUBLIC S16 cmUnpkCmIpHdrParm
1888 (
1889 CmIpHdrParm              *unpkParam,/* ip hdr parameters */
1890 Buffer                   *mBuf     /* message buffer */
1891 )
1892 #endif /* IPV6_OPTS_SUPPORTED */
1893 #else
1894 /* added */
1895 #ifdef IPV6_OPTS_SUPPORTED
1896 PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf, memInfo)
1897 CmIpHdrParm              *unpkParam;/* ip hdr parameters */
1898 Buffer                   *mBuf;     /* message buffer */
1899 Mem                      *memInfo;  /* meminfo to allocate mem for ipHdrParam */
1900 #else
1901 PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf)
1902 CmIpHdrParm              *unpkParam;/* ip hdr parameters */
1903 Buffer                   *mBuf;     /* message buffer */
1904 #endif /* IPV6_OPTS_SUPPORTED */
1905 #endif
1906 {
1907    TRC3(cmUnpkCmIpHdrParm)
1908
1909    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
1910
1911    switch (unpkParam->type)
1912    {
1913       case CM_HDRPARM_NOTPRSNT:
1914       case CM_HDRPARM_ICMP6:
1915          break;
1916
1917       case CM_HDRPARM_IPV4:
1918          CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.proto, mBuf);
1919          CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.dfBit, mBuf);
1920          CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.tos, mBuf);
1921          CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.ttl, mBuf);
1922 #ifdef IPV4_OPTS_SUPPORTED
1923          CMCHKUNPK(cmUnpkTknStr64, &unpkParam->u.hdrParmIpv4.ipv4HdrOpt, mBuf);
1924 #endif /* IPV4_OPTS_SUPPORTED */
1925          break;
1926
1927       case CM_HDRPARM_IPV6:
1928 #ifdef IPV6_SUPPORTED         
1929          CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv6.ttl, mBuf);
1930    
1931          CMCHKUNPK(cmUnpkCmNetAddr, 
1932                    &unpkParam->u.hdrParmIpv6.srcAddr6, mBuf);
1933  
1934 #ifdef IPV6_OPTS_SUPPORTED
1935          /* memInfo is passed forward to alloc mem to hold unpacked 
1936           * IPV6 etx hdr data */
1937          cmUnpkCmIpv6ExtHdr(&unpkParam->u.hdrParmIpv6.ipv6ExtHdr, 
1938                             mBuf, memInfo);
1939 #endif /* IPV6_OPTS_SUPPORTED */         
1940 #endif /* IPV6_SUPPORTED */
1941          break;
1942    
1943       default:
1944          RETVALUE(RFAILED);
1945    }
1946    
1947    RETVALUE(ROK);
1948 }   /* End of cmUnpkCmIpHdrParm */
1949
1950 \f
1951 /*
1952 *
1953 *       Fun:   cmPkCmIcmpFilter
1954 *
1955 *       Desc:  This function packs the ICMP filter parameters
1956 *
1957 *       Ret:   ROK
1958 *
1959 *       Notes: None
1960 *
1961 *       File:  cm_tpt.c
1962 *
1963 */
1964 #ifdef ANSI
1965 PUBLIC S16 cmPkCmIcmpFilter
1966 (
1967 CmIcmpFilter             *pkParam,   
1968 Buffer                   *mBuf       /* message buffer */
1969 )
1970 #else
1971 PUBLIC S16 cmPkCmIcmpFilter (pkParam, mBuf)
1972 CmIcmpFilter             *pkParam;   
1973 Buffer                   *mBuf;      /* message buffer */
1974 #endif
1975 {
1976    /* Variable declaration */
1977    S16   idx;
1978   
1979    TRC3(cmPkCmIcmpFilter)
1980
1981    switch (pkParam->type)
1982    {
1983       case CM_ICMP_NO_FILTER:
1984          break;
1985
1986       case CM_ICMPVER4_FILTER:
1987          for(idx = (pkParam->u.icmpv4Filter.num-1); idx >= 0; idx--)
1988          {
1989             CMCHKPK(SPkU32, pkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
1990                     mBuf);
1991             CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpError[idx].errType,
1992                     mBuf);
1993          }
1994          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.num, mBuf);
1995          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.protocol, mBuf);
1996          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf);
1997          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
1998          break;
1999
2000       case CM_ICMPVER6_FILTER:
2001      /* The structure is yet to be decided */
2002      /* CMCHKPK(cmPkCmIpv6HdrParm, &pkParam->u.ipv6HdrParm, mBuf); */
2003 #ifdef IPV6_SUPPORTED
2004          for(idx = (pkParam->u.icmpv6Filter.num - 1); idx >= 0; idx--)
2005          {
2006             CMCHKPK(SPkU32, pkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
2007                     mBuf);
2008             CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.icmpError[idx].errType,
2009                     mBuf);
2010          }
2011          CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.num, mBuf);
2012          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf); 
2013          CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
2014 #endif /* IPV6_SUPPORTED */
2015          break;
2016    
2017       default:
2018          RETVALUE(RFAILED);
2019    }
2020    CMCHKPK(SPkU8, pkParam->type, mBuf);
2021
2022    RETVALUE(ROK);
2023 }
2024
2025 \f  
2026 /*
2027 *
2028 *       Fun:   cmUnpkCmIcmpFilter
2029 *
2030 *       Desc:  This function unpacks the 
2031 *
2032 *       Ret:   ROK
2033 *
2034 *       Notes: None
2035 *
2036 *       File:  cm_tpt.c
2037 *
2038 */
2039 #ifdef ANSI
2040 PUBLIC S16 cmUnpkCmIcmpFilter
2041 (
2042 CmIcmpFilter             *unpkParam,   
2043 Buffer                   *mBuf         /* message buffer */
2044 )
2045 #else
2046 PUBLIC S16 cmUnpkCmIcmpFilter (unpkParam, mBuf)
2047 CmIcmpFilter             *unpkParam;   
2048 Buffer                   *mBuf;        /* message buffer */
2049 #endif
2050 {
2051    /* Variable declaration */ 
2052    S16     idx;
2053
2054    TRC3(cmUnpkCmIcmpFilter)
2055
2056    CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
2057
2058    switch (unpkParam->type)
2059    {
2060       case CM_ICMP_NO_FILTER:
2061          break;
2062
2063       case CM_ICMPVER4_FILTER:
2064          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
2065          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.allMsg, mBuf);
2066          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.protocol, mBuf);
2067          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.num, mBuf);
2068
2069          for(idx = 0; idx < (unpkParam->u.icmpv4Filter.num); idx++)
2070          {
2071             CMCHKUNPK(SUnpkU8, 
2072                       &unpkParam->u.icmpv4Filter.icmpError[idx].errType, mBuf);
2073             CMCHKUNPK(SUnpkU32, 
2074                       &unpkParam->u.icmpv4Filter.icmpError[idx].errCodeMask, 
2075                       mBuf);
2076          }
2077          break;
2078
2079       case CM_ICMPVER6_FILTER:
2080 #ifdef IPV6_SUPPORTED
2081          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.icmpMsgFlag, mBuf);
2082          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.allMsg, mBuf); 
2083          CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.num, mBuf);
2084
2085          for(idx = 0; idx < (unpkParam->u.icmpv6Filter.num); idx++)
2086          {
2087             CMCHKUNPK(SUnpkU8, 
2088                       &unpkParam->u.icmpv6Filter.icmpError[idx].errType, mBuf);
2089             CMCHKUNPK(SUnpkU32, 
2090                       &unpkParam->u.icmpv6Filter.icmpError[idx].errCodeMask, 
2091                       mBuf);
2092          }
2093 #endif /* IPV6_SUPPORTED */
2094          break;
2095    
2096       default:
2097          RETVALUE(RFAILED);
2098
2099    }
2100    
2101    RETVALUE(ROK);
2102 }   /* End of cmUnpkCmIcmpFilter */
2103
2104 #endif  /* CM_INET2 */ 
2105
2106 \f  
2107 #endif /* if(LCHCT || LCHIT || LCLHC || LCHRT || LCLHR) */
2108
2109 \f  
2110 /********************************************************************30**
2111          End of file
2112 *********************************************************************31*/