Code Review / o-du / l2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
replaced cmMemSet, cmMemcpy with memset and memcpy resp AND Removed TRC() traces...
[o-du/l2.git] / src / cm / cm_tpt.c
diff --git a/src/cm/cm_tpt.c b/src/cm/cm_tpt.c
index 7bd9d87..3e52dbb 100755 (executable)
--- a/src/cm/cm_tpt.c
+++ b/src/cm/cm_tpt.c
@@ -115,23 +115,22 @@ extern "C" {
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv4TptAddr
+S16 cmPkCmIpv4TptAddr
 (
 CmIpv4TptAddr            *pkParam,  /* IPv4 Address structure */
 Buffer                   *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv4TptAddr (pkParam, mBuf)
+S16 cmPkCmIpv4TptAddr (pkParam, mBuf)
 CmIpv4TptAddr            *pkParam;  /* IPv4 Address structure */
 Buffer                   *mBuf;     /* message buffer */
 #endif
 {
-   TRC2(cmPkCmIpv4TptAddr)
 
    CMCHKPK(cmPkCmIpv4NetAddr, pkParam->address, mBuf);
-   CMCHKPK(SPkU16, pkParam->port, mBuf);
+   CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkCmIpv4TptAddr */
 
 /*
@@ -162,14 +161,13 @@ Buffer                   *mBuf;        /* message buffer */
    U8 num;
    U8 *ptr = (U8*)pkParam;
 
-   TRC3(cmPkCmIpv6NetAddr)
 
    for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
    {
-      CMCHKPK(SPkU8, *(ptr+num), mBuf);
+      CMCHKPK(oduUnpackUInt8, *(ptr+num), mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6NetAddr */
 
 \f
@@ -198,12 +196,11 @@ CmIpv6TptAddr            *pkParam;     /* IPv6 transport address */
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmIpv6TptAddr)
 
    CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6NetAddr, mBuf);
-   CMCHKPK(SPkU16, pkParam->port, mBuf);
+   CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmIpv6TptAddr */
 
 \f
@@ -221,13 +218,13 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmNetAddrTbl
+S16 cmPkCmNetAddrTbl
 (
 CmNetAddrTbl            *pkParam,      /* Network Address Table */
 Buffer                  *mBuf          /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmNetAddrTbl (pkParam, mBuf)
+S16 cmPkCmNetAddrTbl (pkParam, mBuf)
 CmNetAddrTbl            *pkParam;      /* Network Address Table */
 Buffer                  *mBuf;         /* message buffer */
 #endif
@@ -235,10 +232,9 @@ Buffer                  *mBuf;         /* message buffer */
    U16                  idx;           /* Loop Index */
    CmNetAddr            *netAddr;      /* Network Address */
 
-   TRC2(cmPkCmNetAddrTbl)
 
    if (pkParam->count > CM_MAX_NET_ADDR)
-      RETVALUE(RFAILED);
+      return RFAILED;
 
    /* Pack All the addresses */
    for (idx = pkParam->count; idx; idx--)
@@ -246,13 +242,13 @@ Buffer                  *mBuf;         /* message buffer */
       netAddr = &(pkParam->netAddr[idx - 1]);
 
       if ((cmPkCmNetAddr(netAddr, mBuf)) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
    /* Pack the total number of addresses present in the table */
-   CMCHKPK(SPkU16, pkParam->count, mBuf);
+   CMCHKPK(oduUnpackUInt16, pkParam->count, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 
 } /* end of cmPkCmNetAddrTbl() */
 
@@ -270,18 +266,17 @@ Buffer                  *mBuf;         /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmNetAddr
+S16 cmPkCmNetAddr
 (
 CmNetAddr                *pkParam,     
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmNetAddr (pkParam, mBuf)
+S16 cmPkCmNetAddr (pkParam, mBuf)
 CmNetAddr                *pkParam;     
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmNetAddr)
 
    switch (pkParam->type)
    {
@@ -297,11 +292,11 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   CMCHKPK(SPkU8, pkParam->type, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmNetAddr */
 
 \f
@@ -319,18 +314,17 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmTptAddr
+S16 cmPkCmTptAddr
 (
 CmTptAddr                *pkParam,     
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmTptAddr (pkParam, mBuf)
+S16 cmPkCmTptAddr (pkParam, mBuf)
 CmTptAddr                *pkParam;     
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmTptAddr)
 
    switch (pkParam->type)
    {
@@ -346,11 +340,11 @@ Buffer                   *mBuf;        /* message buffer */
          break;
    
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   CMCHKPK(SPkU8, pkParam->type, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmTptAddr */
 
 /* added new packing functions */
@@ -370,29 +364,28 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmTptLocalInf
+S16 cmPkCmTptLocalInf
 (
 CmTptLocalInf           *pkParam,   /* local interface info */
 Buffer                  *mBuf       /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmTptLocalInf (pkParam, mBuf)
+S16 cmPkCmTptLocalInf (pkParam, mBuf)
 CmTptLocalInf           *pkParam;   /* local interface info */
 Buffer                  *mBuf;      /* message buffer */
 #endif
 {
-   TRC3(cmPkCmTptLocalInf)
 
    if (pkParam->intfPrsnt == TRUE)
    {  
       /* pack the actual interface address */ 
       CMCHKPK(cmPkCmNetAddr, &pkParam->localIfAddr, mBuf); 
       /* pack the interface index value */
-      CMCHKPK(SPkU32, pkParam->localIf, mBuf);
+      CMCHKPK(oduUnpackUInt32, pkParam->localIf, mBuf);
    }
    /* pack the boll which indicates if valid local intf is present or not */
-   CMCHKPK(SPkU8, pkParam->intfPrsnt, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, pkParam->intfPrsnt, mBuf);
+   return ROK;
 }   /* cmPkCmTptLocalInf */
 #endif /* LOCAL_INTF */
 
@@ -412,23 +405,22 @@ Buffer                  *mBuf;      /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmNetMCastInf6
+S16 cmPkCmNetMCastInf6
 (
 CmNetMCastInf6            *pkParam,     /* IPv6 multicast information */
 Buffer                    *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmNetMCastInf6(pkParam, mBuf)
+S16 cmPkCmNetMCastInf6(pkParam, mBuf)
 CmNetMCastInf6            *pkParam;     /* IPv6 multicast information */
 Buffer                    *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmNetMCastInf6)
 
    CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->mCastAddr, mBuf);
-   CMCHKPK(SPkU32, pkParam->localInf, mBuf);
+   CMCHKPK(oduUnpackUInt32, pkParam->localInf, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmNetMCastInf6 */
 #endif /* IPV6_SUPPORTED */
 
@@ -458,7 +450,6 @@ CmSockOpts               *pkParam;
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmSockOpts)
 
    switch (pkParam->option)
    {
@@ -483,19 +474,19 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       case CM_SOCKOPT_OPT_MCAST6_IF:
-         CMCHKPK(SPkU32, pkParam->optVal.infId, mBuf);
+         CMCHKPK(oduUnpackUInt32, pkParam->optVal.infId, mBuf);
          break;
 
 #endif /* IPV6_SUPPORTED */
 
       default:
-         CMCHKPK(SPkU32, pkParam->optVal.value, mBuf);
+         CMCHKPK(oduUnpackUInt32, pkParam->optVal.value, mBuf);
          break;
    }
-   CMCHKPK(SPkU32, pkParam->option, mBuf);
-   CMCHKPK(SPkU32, pkParam->level, mBuf);
+   CMCHKPK(oduUnpackUInt32, pkParam->option, mBuf);
+   CMCHKPK(oduUnpackUInt32, pkParam->level, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmSockOpts */
 
 \f
@@ -526,20 +517,19 @@ Buffer                   *mBuf;        /* message buffer */
 {
    U32 num;
 
-   TRC3(cmPkCmSockParam)
 
    if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
    {
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    for(num = 0; num < pkParam->numOpts; num++)
    {
       CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
    }
-   CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
-   CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->numOpts, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->listenQSize, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmSockParam */
 
 \f
@@ -571,21 +561,20 @@ Buffer                   *mBuf;        /* message buffer */
 {
    U32 num;
 
-   TRC3(cmPkTlsTptParam)
 
    if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
    {
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    for(num = 0; num < pkParam->numOpts; num++)
    {
       CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
    }
-   CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
-   CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->numOpts, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->listenQSize, mBuf);
    CMCHKPK(SPkS16, pkParam->ctxId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }  /* cmPkTlsTptParam */
 
 #endif  /* CM_TLS */
@@ -605,18 +594,17 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmTptParam
+S16 cmPkCmTptParam
 (
 CmTptParam               *pkParam,     
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmTptParam (pkParam, mBuf)
+S16 cmPkCmTptParam (pkParam, mBuf)
 CmTptParam               *pkParam;     
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmPkCmTptParam)
 
    switch (pkParam->type)
    {
@@ -640,12 +628,12 @@ Buffer                   *mBuf;        /* message buffer */
 #endif
 
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
-   CMCHKPK(SPkU8, pkParam->type, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmPkCmTptParam */
 
 \f  
@@ -669,23 +657,22 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv4TptAddr 
+S16 cmUnpkCmIpv4TptAddr 
 (
 CmIpv4TptAddr            *unpkParam,     /* IPv4 Address */
 Buffer                   *mBuf           /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv4TptAddr (unpkParam, mBuf)
+S16 cmUnpkCmIpv4TptAddr (unpkParam, mBuf)
 CmIpv4TptAddr            *unpkParam;     /* IPv4 Address */
 Buffer                   *mBuf;          /* message buffer */
 #endif
 {
-   TRC2(cmUnpkCmIpv4TptAddr)
 
-   CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
+   CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
    CMCHKUNPK(cmUnpkCmIpv4NetAddr, &unpkParam->address, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmIpv4TptAddr */
 
 \f
@@ -717,16 +704,15 @@ Buffer                   *mBuf;        /* message buffer */
    U32 num;
    U8 *ptr = (U8*)unpkParam;
 
-   TRC3(cmUnpkCmIpv6NetAddr)
 
    ptr += (CM_INET_IPV6ADDR_SIZE - 1);
 
    for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
    {
-      CMCHKUNPK(SUnpkU8, (ptr-num), mBuf);
+      CMCHKUNPK(oduPackUInt8, (ptr-num), mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6NetAddr */
 
 \f
@@ -755,12 +741,11 @@ CmIpv6TptAddr            *unpkParam;   /* IPv6 transport address */
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmIpv6TptAddr)
 
-   CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
+   CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
    CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6NetAddr, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmIpv6TptAddr */
 
 \f
@@ -778,13 +763,13 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmNetAddrTbl
+S16 cmUnpkCmNetAddrTbl
 (
 CmNetAddrTbl            *unpkParam,    /* Network Address Table */
 Buffer                  *mBuf          /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmNetAddrTbl (unpkParam, mBuf )
+S16 cmUnpkCmNetAddrTbl (unpkParam, mBuf )
 CmNetAddrTbl            *unpkParam;    /* Network Address Table */
 Buffer                  *mBuf;         /* message buffer */
 #endif
@@ -792,10 +777,9 @@ Buffer                  *mBuf;         /* message buffer */
    U16                  idx;           /* Loop Index */
    CmNetAddr            *netAddr;      /* Network Address */
    
-   TRC2(cmUnpkCmNetAddrTbl)
 
    /* Unpack the count */
-   CMCHKUNPK(SUnpkU16, &(unpkParam->count), mBuf);
+   CMCHKUNPK(oduPackUInt16, &(unpkParam->count), mBuf);
 
    /* Unpack the addresses */
    for (idx = 0; idx < unpkParam->count; idx++)
@@ -803,10 +787,10 @@ Buffer                  *mBuf;         /* message buffer */
       netAddr = &(unpkParam->netAddr[idx]);
 
       if ((cmUnpkCmNetAddr(netAddr, mBuf)) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 
 } /* end of cmUnpkCmNetAddrTbl() */
 
@@ -825,20 +809,19 @@ Buffer                  *mBuf;         /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmNetAddr
+S16 cmUnpkCmNetAddr
 (
 CmNetAddr                *unpkParam,   
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmNetAddr (unpkParam, mBuf )
+S16 cmUnpkCmNetAddr (unpkParam, mBuf )
 CmNetAddr                *unpkParam;   
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmNetAddr)
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
 
    switch (unpkParam->type)
    {
@@ -854,10 +837,10 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmNetAddr */
 
 \f
@@ -875,20 +858,19 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmTptAddr
+S16 cmUnpkCmTptAddr
 (
 CmTptAddr                *unpkParam,   
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmTptAddr (unpkParam, mBuf)
+S16 cmUnpkCmTptAddr (unpkParam, mBuf)
 CmTptAddr                *unpkParam;   
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmTptAddr)
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
 
    switch (unpkParam->type)
    {
@@ -904,10 +886,10 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmTptAddr */
 
 /* Moving IPv6 multicast information unpacking functions from cm_inet.c */
@@ -927,23 +909,22 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmNetMCastInf6
+S16 cmUnpkCmNetMCastInf6
 (
 CmNetMCastInf6            *unpkParam,   /* IPv6 multicast information */
 Buffer                    *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmNetMCastInf6(unpkParam, mBuf)
+S16 cmUnpkCmNetMCastInf6(unpkParam, mBuf)
 CmNetMCastInf6            *unpkParam;   /* IPv6 multicast information */
 Buffer                    *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmNetMCastInf6)
 
-    CMCHKUNPK(SUnpkU32, &unpkParam->localInf, mBuf);
+    CMCHKUNPK(oduPackUInt32, &unpkParam->localInf, mBuf);
     CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->mCastAddr, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmNetMCastInf6 */
 #endif /* IPV6_SUPPORTED */
 
@@ -973,10 +954,9 @@ CmSockOpts               *unpkParam;   /* socket options */
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmSockOpts)
 
-   CMCHKUNPK(SUnpkU32, &unpkParam->level, mBuf);
-   CMCHKUNPK(SUnpkU32, &unpkParam->option, mBuf);
+   CMCHKUNPK(oduPackUInt32, &unpkParam->level, mBuf);
+   CMCHKUNPK(oduPackUInt32, &unpkParam->option, mBuf);
 
    switch (unpkParam->option)
    {
@@ -1003,16 +983,16 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       case CM_SOCKOPT_OPT_MCAST6_IF:
-         CMCHKUNPK(SUnpkU32, &unpkParam->optVal.infId, mBuf);
+         CMCHKUNPK(oduPackUInt32, &unpkParam->optVal.infId, mBuf);
          break;
 #endif /* IPV6_SUPPORTED */
 
       default:
-         CMCHKUNPK(SUnpkU32, &unpkParam->optVal.value, mBuf);
+         CMCHKUNPK(oduPackUInt32, &unpkParam->optVal.value, mBuf);
          break;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmSockOpts */
 
 \f
@@ -1043,14 +1023,13 @@ Buffer                   *mBuf;        /* message buffer */
 {
    U32 num;
 
-   TRC3(cmUnpkCmSockParam)
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
-   CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->numOpts, mBuf);
 
    if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
    {
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    for(num = 0; num < unpkParam->numOpts; num++)
@@ -1058,7 +1037,7 @@ Buffer                   *mBuf;        /* message buffer */
       CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmSockParam */
 
 \f
@@ -1090,15 +1069,14 @@ Buffer                   *mBuf;        /* message buffer */
 {
    U32 num;
 
-   TRC3(cmUnpkTlsTptParam)
 
    CMCHKUNPK(SUnpkS16, &unpkParam->ctxId, mBuf);
-   CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
-   CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->numOpts, mBuf);
 
    if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
    {
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    for(num = 0; num < unpkParam->numOpts; num++)
@@ -1106,7 +1084,7 @@ Buffer                   *mBuf;        /* message buffer */
       CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }  /* cmUnpkTlsTptParam */
 
 #endif  /* CM_TLS */
@@ -1126,20 +1104,19 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmTptParam
+S16 cmUnpkCmTptParam
 (
 CmTptParam               *unpkParam,   /* transport parameters */
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmTptParam (unpkParam, mBuf)
+S16 cmUnpkCmTptParam (unpkParam, mBuf)
 CmTptParam               *unpkParam;   /* transport parameters */
 Buffer                   *mBuf;        /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmTptParam)
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
 
    switch (unpkParam->type)
    {
@@ -1163,10 +1140,10 @@ Buffer                   *mBuf;        /* message buffer */
 #endif
 
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmTptParam */
 
 
@@ -1187,18 +1164,17 @@ Buffer                   *mBuf;        /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpHdrParm
+S16 cmPkCmIpHdrParm
 (
 CmIpHdrParm             *pkParam,   /* IP hdr parameters */ 
 Buffer                  *mBuf       /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpHdrParm (pkParam, mBuf)
+S16 cmPkCmIpHdrParm (pkParam, mBuf)
 CmIpHdrParm             *pkParam;   /* IP hdr parameters */
 Buffer                  *mBuf;      /* message buffer */
 #endif
 {
-   TRC3(cmPkCmIpHdrParm)
 
    switch (pkParam->type)
    {
@@ -1233,11 +1209,11 @@ Buffer                  *mBuf;      /* message buffer */
          break;
    
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   CMCHKPK(SPkU8, pkParam->type, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }   /* End of cmPkCmIpHdrParm */
 
 \f
@@ -1258,30 +1234,29 @@ Buffer                  *mBuf;      /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmTptLocalInf
+S16 cmUnpkCmTptLocalInf
 (
 CmTptLocalInf           *unpkParam, /* local interface info */
 Buffer                  *mBuf       /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmTptLocalInf (unpkParam, mBuf)
+S16 cmUnpkCmTptLocalInf (unpkParam, mBuf)
 CmTptLocalInf           *unpkParam; /* local interface info */
 Buffer                  *mBuf;      /* message buffer */
 #endif
 {
-   TRC3(cmUnpkCmTptLocalInf)
 
    /* first unpack the bool intfPrsnt value which is always packed */
-   CMCHKUNPK(cmUnpkBool, &unpkParam->intfPrsnt, mBuf);
+   CMCHKUNPK(oduUnpackBool, &unpkParam->intfPrsnt, mBuf);
    
    /* if the above unpacked bool is TRUE then we have to unpack further
     * to get the local intf index and intf address */   
    if (unpkParam->intfPrsnt == TRUE)
    {   
-      CMCHKUNPK(SUnpkU32, &unpkParam->localIf, mBuf);
+      CMCHKUNPK(oduPackUInt32, &unpkParam->localIf, mBuf);
       CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->localIfAddr, mBuf); 
    }
-   RETVALUE(ROK);
+   return ROK;
 }   /* cmUnpkCmTptLocalInf */
 #endif /* LOCAL_INTF */
 
@@ -1301,35 +1276,34 @@ Buffer                  *mBuf;      /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6ExtHdr
+S16 cmPkCmIpv6ExtHdr
 (
 CmIpv6ExtHdr             *pkParam,   /* IPV6 extension hdrs */
 Buffer                   *mBuf       /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6ExtHdr (pkParam, mBuf)
+S16 cmPkCmIpv6ExtHdr (pkParam, mBuf)
 CmIpv6ExtHdr             *pkParam;   /*IPV6 extension hdrs */
 Buffer                   *mBuf;      /* message buffer */
 #endif
 {
-   TRC3(cmPkCmIpv6ExtHdr)
 
    /* pack first Route hdr */   
    if (pkParam->rtOptsPrsnt)
       CMCHKPK(cmPkCmIpv6RtHdr, &pkParam->rtOpts, mBuf);  
-   CMCHKPK(cmPkBool, pkParam->rtOptsPrsnt, mBuf);  
+   CMCHKPK(oduPackBool, pkParam->rtOptsPrsnt, mBuf);  
 
    /* pack Dest Opt hdr */
    if (pkParam->destOptsPrsnt)
       CMCHKPK(cmPkCmIpv6DestOptsArr, &pkParam->destOptsArr, mBuf);  
-   CMCHKPK(cmPkBool, pkParam->destOptsPrsnt, mBuf);  
+   CMCHKPK(oduPackBool, pkParam->destOptsPrsnt, mBuf);  
 
    /* pack HBH hdr */
    if (pkParam->hbhHdrPrsnt)
       CMCHKPK(cmPkCmIpv6HBHHdrArr, &pkParam->hbhOptsArr, mBuf);  
-   CMCHKPK(cmPkBool, pkParam->hbhHdrPrsnt, mBuf);  
+   CMCHKPK(oduPackBool, pkParam->hbhHdrPrsnt, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6ExtHdr */
 
 \f
@@ -1347,20 +1321,19 @@ Buffer                   *mBuf;      /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6RtHdr
+S16 cmPkCmIpv6RtHdr
 (
 CmIpv6RtHdr             *pkParam,   /* IPV6 Route hdr */
 Buffer                   *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6RtHdr (pkParam, mBuf)
+S16 cmPkCmIpv6RtHdr (pkParam, mBuf)
 CmIpv6RtHdr             *pkParam;   /* IPV6 Route hdr */
 Buffer                   *mBuf;     /* message buffer */
 #endif
 {
    U8 idx;
    
-   TRC3(cmPkCmIpv6RtHdr);
 
    /* pack all IPV6 addrs in the route hdr */
    for(idx = 0; idx < pkParam->numAddrs; idx++)
@@ -1368,10 +1341,10 @@ Buffer                   *mBuf;     /* message buffer */
       CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6Addrs[idx], mBuf);
    }
    /* pack reserve byte & strict/loose bit map */
-   CMCHKPK(SPkU32, pkParam->slMap, mBuf);
-   CMCHKPK(SPkU8, pkParam->numAddrs, mBuf);  
+   CMCHKPK(oduUnpackUInt32, pkParam->slMap, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->numAddrs, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6RtHdr */
 
 \f
@@ -1390,14 +1363,14 @@ Buffer                   *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6RtHdr
+S16 cmUnpkCmIpv6RtHdr
 (
 CmIpv6RtHdr             *unpkParam,  /* IPV6 Route hdr */
 Buffer                  *mBuf,       /* message buffer */
 Mem                     *memInfo     /* meminfo to allocate for Route hdr */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6RtHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6RtHdr (unpkParam, mBuf, memInfo)
 CmIpv6RtHdr             *unpkParam;  /* IPV6 Route hdr */
 Buffer                  *mBuf;       /* message buffer */
 Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
@@ -1406,12 +1379,11 @@ Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
    U8 idx;  /* array index */
    S32 retVal; /* temporary return value */
    
-   TRC3(cmUnpkCmIpv6RtHdr);
    
-   CMCHKUNPK(SUnpkU8, &unpkParam->numAddrs, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->numAddrs, mBuf);
    
    /* unpack reserve byte & strict/loose bit map */
-   CMCHKUNPK(SUnpkU32, &unpkParam->slMap, mBuf);
+   CMCHKUNPK(oduPackUInt32, &unpkParam->slMap, mBuf);
    
    retVal = SGetSBuf(memInfo->region,    
                   memInfo->pool,                     
@@ -1420,7 +1392,7 @@ Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
       
    if (retVal != ROK)
    {
-      RETVALUE(ROUTRES);
+      return (ROUTRES);
    }
    
    /* unpack all IPV6 addrs in the route hdr */
@@ -1429,7 +1401,7 @@ Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
       CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6Addrs[idx], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6RtHdr */
 
 \f
@@ -1447,37 +1419,36 @@ Mem                     *memInfo;    /* meminfo to allocate for Route hdr */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6ExtHdr
+S16 cmUnpkCmIpv6ExtHdr
 (
 CmIpv6ExtHdr             *unpkParam,  /* IPV6 extension hdrs */
 Buffer                   *mBuf,       /* message buffer */
 Mem                      *memInfo     /* meminfo to allocate for IPV6 ext hdr */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6ExtHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6ExtHdr (unpkParam, mBuf, memInfo)
 CmIpv6ExtHdr             *unpkParam; /* IPV6 extension hdrs */
 Buffer                   *mBuf;      /* message buffer */
 Mem                      *memInfo;   /* meminfo to allocate for IPV6 ext hdr */
 #endif
 {
-   TRC3(cmUnpkCmIpv6ExtHdr)
       
    /* unpack HBH hdr first */
-   CMCHKUNPK(cmUnpkBool, &unpkParam->hbhHdrPrsnt, mBuf); 
+   CMCHKUNPK(oduUnpackBool, &unpkParam->hbhHdrPrsnt, mBuf); 
    if (unpkParam->hbhHdrPrsnt)
       cmUnpkCmIpv6HBHHdrArr(&unpkParam->hbhOptsArr, mBuf, memInfo);         
                                                          
    /* unpack DEST opt hdr */
-   CMCHKUNPK(cmUnpkBool, &unpkParam->destOptsPrsnt, mBuf);
+   CMCHKUNPK(oduUnpackBool, &unpkParam->destOptsPrsnt, mBuf);
    if (unpkParam->destOptsPrsnt)
       cmUnpkCmIpv6DestOptsArr(&unpkParam->destOptsArr, mBuf, memInfo);   
 
    /* unpack Route hdr last */
-   CMCHKUNPK(cmUnpkBool, &unpkParam->rtOptsPrsnt, mBuf); 
+   CMCHKUNPK(oduUnpackBool, &unpkParam->rtOptsPrsnt, mBuf); 
    if (unpkParam->rtOptsPrsnt)
       cmUnpkCmIpv6RtHdr(&unpkParam->rtOpts, mBuf, memInfo);  
                                                         
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6ExtHdr */
 
 \f
@@ -1495,13 +1466,13 @@ Mem                      *memInfo;   /* meminfo to allocate for IPV6 ext hdr */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6DestOptsArr
+S16 cmPkCmIpv6DestOptsArr
 (
 CmIpv6DestOptsArr       *pkParam,  /* IPV6 Dest hdr array */
 Buffer                  *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6DestOptsArr (pkParam, mBuf)
+S16 cmPkCmIpv6DestOptsArr (pkParam, mBuf)
 CmIpv6DestOptsArr       *pkParam;  /* IPV6 Dest hdr array */
 Buffer                  *mBuf;     /* message buffer */
 #endif
@@ -1509,14 +1480,13 @@ Buffer                  *mBuf;     /* message buffer */
 
    U8 numOptions;
 
-   TRC3(cmPkCmIpv6DestOptsArr);
    
    /* pack all HBH options */
    for(numOptions = 0; numOptions<pkParam->numDestOpts; numOptions++)  
       CMCHKPK(cmPkCmIpv6DestOptsHdr, &pkParam->destOpts[numOptions], mBuf);
-   CMCHKPK(SPkU8, pkParam->numDestOpts, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->numDestOpts, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6DestOptsArr */
 
 \f
@@ -1534,29 +1504,28 @@ Buffer                  *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6DestOptsHdr
+S16 cmPkCmIpv6DestOptsHdr
 (
 CmIpv6DestOptsHdr       *pkParam,  /* IPV6 Dest opt */
 Buffer                  *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6DestOptsHdr (pkParam, mBuf)
+S16 cmPkCmIpv6DestOptsHdr (pkParam, mBuf)
 CmIpv6DestOptsHdr       *pkParam;  /* IPV6 Dest opt */
 Buffer                  *mBuf;     /* message buffer */
 #endif
 {
    U8 optLen;
    
-   TRC3(cmPkCmIpv6DestOptsHdr);
 
    for(optLen = 0; optLen < pkParam->length; optLen++)
    {
-      CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
+      CMCHKPK(oduUnpackUInt8, pkParam->value[optLen], mBuf);
    }
-   CMCHKPK(SPkU8, pkParam->length, mBuf);  
-   CMCHKPK(SPkU8, pkParam->type, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->length, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6DestOptsHdr */
 
 \f
@@ -1574,14 +1543,14 @@ Buffer                  *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6DestOptsHdr
+S16 cmUnpkCmIpv6DestOptsHdr
 (
 CmIpv6DestOptsHdr       *unpkParam,/* IPV6 Dest Option */
 Buffer                  *mBuf,     /* message buffer */
 Mem                     *memInfo   /* meminfo to allocate mem for dest opt */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6DestOptsHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6DestOptsHdr (unpkParam, mBuf, memInfo)
 CmIpv6DestOptsHdr       *unpkParam;/* IPV6 Dest Option */
 Buffer                  *mBuf;     /* message buffer */
 Mem                     *memInfo;  /* meminfo to allocate mem for dest opt */
@@ -1590,11 +1559,10 @@ Mem                     *memInfo;  /* meminfo to allocate mem for dest opt */
    S32 retVal;                        /* temporary return value */
    U8 optLen;                      /* length of value field */
 
-   TRC3(cmUnpkCmIpv6DestOptsHdr);
   
    /* unpack type, length */
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);  
-   CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);  
+   CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
 
    /* allocate static memory to hold the unpacked values */
    retVal = SGetSBuf(memInfo->region,                   
@@ -1602,16 +1570,16 @@ Mem                     *memInfo;  /* meminfo to allocate mem for dest opt */
                   (Data **)&unpkParam->value, (Size)unpkParam->length);
    if (retVal != ROK)
    {
-      RETVALUE(ROUTRES);
+      return (ROUTRES);
    }
       
    /* unpack value fieldof this option */
    for(optLen = 0; optLen<unpkParam->length; optLen++)
    {
-      CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);  
+      CMCHKUNPK(oduPackUInt8, &unpkParam->value[optLen], mBuf);  
    }    
    
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6DestOptsHdr */
 
 \f
@@ -1629,14 +1597,14 @@ Mem                     *memInfo;  /* meminfo to allocate mem for dest opt */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6DestOptsArr
+S16 cmUnpkCmIpv6DestOptsArr
 (
 CmIpv6DestOptsArr       *unpkParam, /* all IPV6 Destination Options */
 Buffer                  *mBuf,      /* message buffer */
 Mem                     *memInfo    /* meminfo to allocate mem for dest opts */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6DestOptsArr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6DestOptsArr (unpkParam, mBuf, memInfo)
 CmIpv6DestOptsArr       *unpkParam; /* all IPV6 Destination Options */
 Buffer                  *mBuf;      /* message buffer */
 Mem                     *memInfo;   /* meminfo to allocate mem for dest opts */
@@ -1645,9 +1613,8 @@ Mem                     *memInfo;   /* meminfo to allocate mem for dest opts */
    U8 numOptions;
    S16 retVal;
    
-   TRC3(cmUnpkCmIpv6DestOptsArr);
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->numDestOpts, mBuf); 
+   CMCHKUNPK(oduPackUInt8, &unpkParam->numDestOpts, mBuf); 
    if (unpkParam->numDestOpts)
    {
       /* allocate mem to hold all dest options */
@@ -1658,17 +1625,17 @@ Mem                     *memInfo;   /* meminfo to allocate mem for dest opts */
       
       if (retVal != ROK)
       {
-         RETVALUE(ROUTRES);
+         return (ROUTRES);
       }
    
       /* unpack all dest options */
       for(numOptions = 0; numOptions<unpkParam->numDestOpts; numOptions++)
          if ((retVal = cmUnpkCmIpv6DestOptsHdr(&unpkParam->destOpts[numOptions],
                                             mBuf, memInfo)) != ROK)
-            RETVALUE(RFAILED);   
+            return RFAILED;   
    
    }                                             
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6DestOptsArr */
 
 \f
@@ -1686,27 +1653,26 @@ Mem                     *memInfo;   /* meminfo to allocate mem for dest opts */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6HBHHdrArr
+S16 cmPkCmIpv6HBHHdrArr
 (
 CmIpv6HBHHdrArr         *pkParam,  /* all IPV6 HopByHop options */
 Buffer                  *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6HBHHdrArr (pkParam, mBuf)
+S16 cmPkCmIpv6HBHHdrArr (pkParam, mBuf)
 CmIpv6HBHHdrArr         *pkParam;  /* IPV6 HopByHop options */
 Buffer                  *mBuf;     /* message buffer */
 #endif
 {
    U8 numOptions;
    
-   TRC3(cmPkCmIpv6HBHHdrArr);
 
    for(numOptions = 0; numOptions<pkParam->numHBHOpts; numOptions++)
       CMCHKPK(cmPkCmIpv6HBHHdr, &pkParam->hbhOpts[numOptions], mBuf);
                           
-   CMCHKPK(SPkU8, pkParam->numHBHOpts, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->numHBHOpts, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6HBHHdrArr */
 
 \f
@@ -1724,32 +1690,31 @@ Buffer                  *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIpv6HBHHdr
+S16 cmPkCmIpv6HBHHdr
 (
 CmIpv6HBHHdr            *pkParam,  /* individual IPV6 HBH options */
 Buffer                  *mBuf      /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIpv6HBHHdr (pkParam, mBuf)
+S16 cmPkCmIpv6HBHHdr (pkParam, mBuf)
 CmIpv6HBHHdr            *pkParam;  /* individual IPV6 HBH options */
 Buffer                  *mBuf;     /* message buffer */
 #endif
 {
    U8 optLen;
 
-   TRC3(cmPkCmIpv6HBHHdr);
 
    /* pack value field */
    for(optLen = 0; optLen<pkParam->length; optLen++)
    {
-      CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
+      CMCHKPK(oduUnpackUInt8, pkParam->value[optLen], mBuf);
    }
 
    /* pack type, length fields */
-   CMCHKPK(SPkU8, pkParam->length, mBuf);  
-   CMCHKPK(SPkU8, pkParam->type, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->length, mBuf);  
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);  
 
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmPkCmIpv6HBHHdr */
 
 \f
@@ -1767,14 +1732,14 @@ Buffer                  *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6HBHHdr
+S16 cmUnpkCmIpv6HBHHdr
 (
 CmIpv6HBHHdr            *unpkParam,/* individual IPV6 HBH Option */
 Buffer                  *mBuf,     /* message buffer */
 Mem                     *memInfo   /* meminfo to allocate mem for HBH opt */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6HBHHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6HBHHdr (unpkParam, mBuf, memInfo)
 CmIpv6HBHHdr            *unpkParam;/* individual IPV6 HBH Option */
 Buffer                  *mBuf;     /* message buffer */
 Mem                     *memInfo;  /* meminfo to allocate mem for HBH opt */
@@ -1783,10 +1748,9 @@ Mem                     *memInfo;  /* meminfo to allocate mem for HBH opt */
    S32 retVal;                     /* temporary return value */
    U8 optLen;                      /* length of value field */
   
-   TRC3(cmUnpkCmIpv6HBHHdr)
    
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);   
-   CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);   
+   CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
 
    /* allocate static memory to hold the unpacked values */
    if (unpkParam->length)
@@ -1796,14 +1760,14 @@ Mem                     *memInfo;  /* meminfo to allocate mem for HBH opt */
                      (Data **)&unpkParam->value, (Size)unpkParam->length); 
       if (retVal != ROK)
       {
-         RETVALUE(ROUTRES);
+         return (ROUTRES);
       }
 
       for(optLen = 0; optLen<unpkParam->length; optLen++)
-         CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);  
+         CMCHKUNPK(oduPackUInt8, &unpkParam->value[optLen], mBuf);  
    } 
       
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6HBHHdr */
 
 \f
@@ -1821,14 +1785,14 @@ Mem                     *memInfo;  /* meminfo to allocate mem for HBH opt */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6HBHHdrArr
+S16 cmUnpkCmIpv6HBHHdrArr
 (
 CmIpv6HBHHdrArr       *unpkParam,  /* all HBH options */
 Buffer                *mBuf,       /* message buffer */
 Mem                   *memInfo     /* meminfo to allocate space for HBH opt */
 )
 #else
-PUBLIC S16 cmUnpkCmIpv6HBHHdrArr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6HBHHdrArr (unpkParam, mBuf, memInfo)
 CmIpv6HBHHdrArr       *unpkParam;  /*  all HBH options */
 Buffer                *mBuf;       /* message buffer */
 Mem                   *memInfo;    /* meminfo to allocate space for HBH opt */
@@ -1837,9 +1801,8 @@ Mem                   *memInfo;    /* meminfo to allocate space for HBH opt */
    U8 numOptions; 
    S16 retVal;
 
-   TRC3(cmUnpkCmIpv6HBHHdrArr);
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->numHBHOpts, mBuf);   
+   CMCHKUNPK(oduPackUInt8, &unpkParam->numHBHOpts, mBuf);   
    if (unpkParam->numHBHOpts)
    {
       /*  allocate space for all HBH options */
@@ -1850,13 +1813,13 @@ Mem                   *memInfo;    /* meminfo to allocate space for HBH opt */
       
       if (retVal != ROK)
       {
-         RETVALUE(ROUTRES);
+         return (ROUTRES);
       }
 
       for(numOptions = 0; numOptions<unpkParam->numHBHOpts; numOptions++)
          cmUnpkCmIpv6HBHHdr(&unpkParam->hbhOpts[numOptions], mBuf, memInfo);
    }                                              
-   RETVALUE(ROK);
+   return ROK;
 } /* end of cmUnpkCmIpv6HBHHdrArr */
 #endif /* IPV6_OPTS_SUPPORTED */
 
@@ -1877,14 +1840,14 @@ Mem                   *memInfo;    /* meminfo to allocate space for HBH opt */
 #ifdef ANSI
 /* added */
 #ifdef IPV6_OPTS_SUPPORTED
-PUBLIC S16 cmUnpkCmIpHdrParm
+S16 cmUnpkCmIpHdrParm
 (
 CmIpHdrParm              *unpkParam,/* ip hdr parameters */
 Buffer                   *mBuf,     /* message buffer */
 Mem                      *memInfo   /* meminfo to allocate mem for ipHdrParam */
 )
 #else
-PUBLIC S16 cmUnpkCmIpHdrParm
+S16 cmUnpkCmIpHdrParm
 (
 CmIpHdrParm              *unpkParam,/* ip hdr parameters */
 Buffer                   *mBuf     /* message buffer */
@@ -1893,20 +1856,19 @@ Buffer                   *mBuf     /* message buffer */
 #else
 /* added */
 #ifdef IPV6_OPTS_SUPPORTED
-PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpHdrParm (unpkParam, mBuf, memInfo)
 CmIpHdrParm              *unpkParam;/* ip hdr parameters */
 Buffer                   *mBuf;     /* message buffer */
 Mem                      *memInfo;  /* meminfo to allocate mem for ipHdrParam */
 #else
-PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf)
+S16 cmUnpkCmIpHdrParm (unpkParam, mBuf)
 CmIpHdrParm              *unpkParam;/* ip hdr parameters */
 Buffer                   *mBuf;     /* message buffer */
 #endif /* IPV6_OPTS_SUPPORTED */
 #endif
 {
-   TRC3(cmUnpkCmIpHdrParm)
 
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
 
    switch (unpkParam->type)
    {
@@ -1941,10 +1903,10 @@ Buffer                   *mBuf;     /* message buffer */
          break;
    
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
    
-   RETVALUE(ROK);
+   return ROK;
 }   /* End of cmUnpkCmIpHdrParm */
 
 \f
@@ -1962,13 +1924,13 @@ Buffer                   *mBuf;     /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCmIcmpFilter
+S16 cmPkCmIcmpFilter
 (
 CmIcmpFilter             *pkParam,   
 Buffer                   *mBuf       /* message buffer */
 )
 #else
-PUBLIC S16 cmPkCmIcmpFilter (pkParam, mBuf)
+S16 cmPkCmIcmpFilter (pkParam, mBuf)
 CmIcmpFilter             *pkParam;   
 Buffer                   *mBuf;      /* message buffer */
 #endif
@@ -1976,7 +1938,6 @@ Buffer                   *mBuf;      /* message buffer */
    /* Variable declaration */
    S16   idx;
   
-   TRC3(cmPkCmIcmpFilter)
 
    switch (pkParam->type)
    {
@@ -1986,15 +1947,15 @@ Buffer                   *mBuf;      /* message buffer */
       case CM_ICMPVER4_FILTER:
          for(idx = (pkParam->u.icmpv4Filter.num-1); idx >= 0; idx--)
          {
-            CMCHKPK(SPkU32, pkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
+            CMCHKPK(oduUnpackUInt32, pkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
                     mBuf);
-            CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpError[idx].errType,
+            CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpError[idx].errType,
                     mBuf);
          }
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.num, mBuf);
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.protocol, mBuf);
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf);
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.num, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.protocol, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.allMsg, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
          break;
 
       case CM_ICMPVER6_FILTER:
@@ -2003,23 +1964,23 @@ Buffer                   *mBuf;      /* message buffer */
 #ifdef IPV6_SUPPORTED
          for(idx = (pkParam->u.icmpv6Filter.num - 1); idx >= 0; idx--)
          {
-            CMCHKPK(SPkU32, pkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
+            CMCHKPK(oduUnpackUInt32, pkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
                     mBuf);
-            CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.icmpError[idx].errType,
+            CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv6Filter.icmpError[idx].errType,
                     mBuf);
          }
-         CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.num, mBuf);
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf); 
-         CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv6Filter.num, mBuf);
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.allMsg, mBuf); 
+         CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
 #endif /* IPV6_SUPPORTED */
          break;
    
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   CMCHKPK(SPkU8, pkParam->type, mBuf);
+   CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f  
@@ -2037,13 +1998,13 @@ Buffer                   *mBuf;      /* message buffer */
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCmIcmpFilter
+S16 cmUnpkCmIcmpFilter
 (
 CmIcmpFilter             *unpkParam,   
 Buffer                   *mBuf         /* message buffer */
 )
 #else
-PUBLIC S16 cmUnpkCmIcmpFilter (unpkParam, mBuf)
+S16 cmUnpkCmIcmpFilter (unpkParam, mBuf)
 CmIcmpFilter             *unpkParam;   
 Buffer                   *mBuf;        /* message buffer */
 #endif
@@ -2051,9 +2012,7 @@ Buffer                   *mBuf;        /* message buffer */
    /* Variable declaration */ 
    S16     idx;
 
-   TRC3(cmUnpkCmIcmpFilter)
-
-   CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
 
    switch (unpkParam->type)
    {
@@ -2061,16 +2020,16 @@ Buffer                   *mBuf;        /* message buffer */
          break;
 
       case CM_ICMPVER4_FILTER:
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.allMsg, mBuf);
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.protocol, mBuf);
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.num, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.allMsg, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.protocol, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.num, mBuf);
 
          for(idx = 0; idx < (unpkParam->u.icmpv4Filter.num); idx++)
          {
-            CMCHKUNPK(SUnpkU8, 
+            CMCHKUNPK(oduPackUInt8, 
                       &unpkParam->u.icmpv4Filter.icmpError[idx].errType, mBuf);
-            CMCHKUNPK(SUnpkU32, 
+            CMCHKUNPK(oduPackUInt32, 
                       &unpkParam->u.icmpv4Filter.icmpError[idx].errCodeMask, 
                       mBuf);
          }
@@ -2078,15 +2037,15 @@ Buffer                   *mBuf;        /* message buffer */
 
       case CM_ICMPVER6_FILTER:
 #ifdef IPV6_SUPPORTED
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.icmpMsgFlag, mBuf);
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.allMsg, mBuf); 
-         CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.num, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.icmpMsgFlag, mBuf);
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.allMsg, mBuf); 
+         CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.num, mBuf);
 
          for(idx = 0; idx < (unpkParam->u.icmpv6Filter.num); idx++)
          {
-            CMCHKUNPK(SUnpkU8, 
+            CMCHKUNPK(oduPackUInt8, 
                       &unpkParam->u.icmpv6Filter.icmpError[idx].errType, mBuf);
-            CMCHKUNPK(SUnpkU32, 
+            CMCHKUNPK(oduPackUInt32, 
                       &unpkParam->u.icmpv6Filter.icmpError[idx].errCodeMask, 
                       mBuf);
          }
@@ -2094,11 +2053,11 @@ Buffer                   *mBuf;        /* message buffer */
          break;
    
       default:
-         RETVALUE(RFAILED);
+         return RFAILED;
 
    }
    
-   RETVALUE(ROK);
+   return ROK;
 }   /* End of cmUnpkCmIcmpFilter */
 
 #endif  /* CM_INET2 */ 
O-RAN DU Layer 2