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*/