[JIRA ID:ODUHIGH-236] Security Authentication in UL

[o-du/l2.git] / src / cm / crg.c

diff --git a/src/cm/crg.c b/src/cm/crg.c
index 9d2dc3a..3613b57 100755 (executable)
--- a/src/cm/crg.c
+++ b/src/cm/crg.c
@@ -34,28 +34,12 @@
        primitives.
 */
 /* header include files (.h) */
-#include "envopt.h"        /* environment options */
-#include "envdep.h"        /* environment dependent */
-#include "envind.h"        /* environment independent */
-#include "gen.h"           /* general */
-#include "ssi.h"           /* system services */
-#include "cm_tkns.h"       /* Common Token Defines */
-#include "cm_llist.h"      /* Common Link List Defines */
-#include "cm_hash.h"       /* Common Hash List Defines */
-#include "cm_lte.h"        /* Common LTE Defines */
+#include "common_def.h"
 #include "crg.h"           /* CRG Interface defines */
 
 /* header/extern include files (.x) */
-#include "gen.x"           /* general */
-#include "ssi.x"           /* system services */
-#include "cm_tkns.x"       /* Common Token Definitions */
-#include "cm_llist.x"      /* Common Link List Definitions */
-#include "cm_lib.x"        /* Common Library Definitions */
-#include "cm_hash.x"       /* Common Hash List Definitions */
-#include "cm_lte.x"        /* Common LTE Defines */
 #include "crg.x"           /* CRG Interface includes */
 
-
 #ifdef LCCRG
 \f
 /**
@@ -72,21 +56,20 @@
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgBndReq
+S16 cmPkCrgBndReq
 (
 Pst* pst,
 SuId suId,
 SpId spId
 )
 #else
-PUBLIC S16 cmPkCrgBndReq(pst, suId, spId)
+S16 cmPkCrgBndReq(pst, suId, spId)
 Pst* pst;
 SuId suId;
 SpId spId;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkCrgBndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -94,7 +77,7 @@ SpId spId;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG001, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -103,7 +86,7 @@ SpId spId;
          (ErrVal)ECRG002, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -112,10 +95,10 @@ SpId spId;
          (ErrVal)ECRG003, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTCRGBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -133,14 +116,14 @@ SpId spId;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgBndReq
+S16 cmUnpkCrgBndReq
 (
 CrgBndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgBndReq(func, pst, mBuf)
+S16 cmUnpkCrgBndReq(func, pst, mBuf)
 CrgBndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -149,7 +132,6 @@ Buffer *mBuf;
    SuId suId;
    SpId spId;
    
-   TRC3(cmUnpkCrgBndReq)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -158,7 +140,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG004, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -167,10 +149,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG005, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, spId));
+   return ((*func)(pst, suId, spId));
 }
 
 \f
@@ -189,21 +171,20 @@ Buffer *mBuf;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgBndCfm
+S16 cmPkCrgBndCfm
 (
 Pst* pst,
 SuId suId,
 U8 status
 )
 #else
-PUBLIC S16 cmPkCrgBndCfm(pst, suId, status)
+S16 cmPkCrgBndCfm(pst, suId, status)
 Pst* pst;
 SuId suId;
 U8 status;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkCrgBndCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -211,16 +192,16 @@ U8 status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG006, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG007, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -229,10 +210,10 @@ U8 status;
          (ErrVal)ECRG008, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTCRGBNDCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -251,14 +232,14 @@ U8 status;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgBndCfm
+S16 cmUnpkCrgBndCfm
 (
 CrgBndCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgBndCfm(func, pst, mBuf)
+S16 cmUnpkCrgBndCfm(func, pst, mBuf)
 CrgBndCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -267,7 +248,6 @@ Buffer *mBuf;
    SuId suId;
    U8 status;
    
-   TRC3(cmUnpkCrgBndCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -276,19 +256,19 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG009, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG010, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, status));
+   return ((*func)(pst, suId, status));
 }
 
 \f
@@ -306,21 +286,20 @@ Buffer *mBuf;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUbndReq
+S16 cmPkCrgUbndReq
 (
 Pst* pst,
 SpId spId,
 Reason reason
 )
 #else
-PUBLIC S16 cmPkCrgUbndReq(pst, spId, reason)
+S16 cmPkCrgUbndReq(pst, spId, reason)
 Pst* pst;
 SpId spId;
 Reason reason;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkCrgUbndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -328,7 +307,7 @@ Reason reason;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG011, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(reason, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -337,7 +316,7 @@ Reason reason;
          (ErrVal)ECRG012, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -346,10 +325,10 @@ Reason reason;
          (ErrVal)ECRG013, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTCRGUBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -367,14 +346,14 @@ Reason reason;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUbndReq
+S16 cmUnpkCrgUbndReq
 (
 CrgUbndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUbndReq(func, pst, mBuf)
+S16 cmUnpkCrgUbndReq(func, pst, mBuf)
 CrgUbndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -383,7 +362,6 @@ Buffer *mBuf;
    SpId spId;
    Reason reason;
    
-   TRC3(cmUnpkCrgUbndReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -392,7 +370,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG014, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&reason, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -401,10 +379,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG015, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, spId, reason));
+   return ((*func)(pst, spId, reason));
 }
 
 \f
@@ -424,7 +402,7 @@ Buffer *mBuf;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCfgReq
+S16 cmPkCrgCfgReq
 (
 Pst* pst,
 SpId spId,
@@ -432,7 +410,7 @@ CrgCfgTransId transId,
 CrgCfgReqInfo  * cfgReqInfo
 )
 #else
-PUBLIC S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
 Pst* pst;
 SpId spId;
 CrgCfgTransId transId;
@@ -440,7 +418,6 @@ CrgCfgReqInfo  * cfgReqInfo;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkCrgCfgReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -449,7 +426,7 @@ CrgCfgReqInfo  * cfgReqInfo;
          (ErrVal)ECRG016, (ErrVal)0, "Packing failed");
 #endif
       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -459,7 +436,7 @@ CrgCfgReqInfo  * cfgReqInfo;
 #endif
       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 /* crg_c_001.main_5: MOD - Updating ERR code */
    if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
@@ -470,7 +447,7 @@ CrgCfgReqInfo  * cfgReqInfo;
 #endif
       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -480,7 +457,7 @@ CrgCfgReqInfo  * cfgReqInfo;
 #endif
       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -489,10 +466,10 @@ CrgCfgReqInfo  * cfgReqInfo;
          (ErrVal)ECRG020, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTCRGCFGREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -512,14 +489,14 @@ CrgCfgReqInfo  * cfgReqInfo;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgReq
+S16 cmUnpkCrgCfgReq
 (
 CrgCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCfgReq(func, pst, mBuf)
+S16 cmUnpkCrgCfgReq(func, pst, mBuf)
 CrgCfgReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -529,7 +506,6 @@ Buffer *mBuf;
    CrgCfgTransId transId;
    CrgCfgReqInfo *cfgReqInfo;
    
-   TRC3(cmUnpkCrgCfgReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -538,7 +514,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG021, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -547,7 +523,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG022, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -556,7 +532,7 @@ Buffer *mBuf;
          (ErrVal)ECRG023, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
     
    if (cmUnpkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
@@ -567,10 +543,10 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG024, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+   return ((*func)(pst, spId, transId, cfgReqInfo));
 }
 
 \f
@@ -589,7 +565,7 @@ Buffer *mBuf;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCfgCfm
+S16 cmPkCrgCfgCfm
 (
 Pst* pst,
 SuId suId,
@@ -597,7 +573,7 @@ CrgCfgTransId transId,
 U8 status
 )
 #else
-PUBLIC S16 cmPkCrgCfgCfm(pst, suId, transId, status)
+S16 cmPkCrgCfgCfm(pst, suId, transId, status)
 Pst* pst;
 SuId suId;
 CrgCfgTransId transId;
@@ -605,7 +581,6 @@ U8 status;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkCrgCfgCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -613,17 +588,17 @@ U8 status;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG025, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 /* crg_c_001.main_5 - ADD - Added the packing for status. */
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG026, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -632,7 +607,7 @@ U8 status;
          (ErrVal)ECRG027, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -641,10 +616,10 @@ U8 status;
          (ErrVal)ECRG028, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTCRGCFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -663,14 +638,14 @@ U8 status;
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgCfm
+S16 cmUnpkCrgCfgCfm
 (
 CrgCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
+S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
 CrgCfgCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -680,7 +655,6 @@ Buffer *mBuf;
    CrgCfgTransId transId;
    U8 status;
    
-   TRC3(cmUnpkCrgCfgCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -689,7 +663,7 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG029, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -698,19 +672,19 @@ Buffer *mBuf;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG030, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ECRG031, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, transId, status));
+   return ((*func)(pst, suId, transId, status));
 }
 
 \f
@@ -730,25 +704,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCfgTransId
+S16 cmPkCrgCfgTransId
 (
 CrgCfgTransId *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgCfgTransId(param, mBuf)
+S16 cmPkCrgCfgTransId(param, mBuf)
 CrgCfgTransId *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkCrgCfgTransId)
 
    for (i=CRG_CFG_TRANSID_SIZE-1; i >= 0; i--) {
-      CMCHKPK(SPkU8, param->trans[i], mBuf);
+      CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -769,25 +742,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgTransId
+S16 cmUnpkCrgCfgTransId
 (
 CrgCfgTransId *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCfgTransId(param, mBuf)
+S16 cmUnpkCrgCfgTransId(param, mBuf)
 CrgCfgTransId *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkCrgCfgTransId)
 
    for (i=0; i<CRG_CFG_TRANSID_SIZE; i++) {
-      CMCHKUNPK(SUnpkU8, &param->trans[i], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->trans[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -808,23 +780,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgBwCfg
+S16 cmPkCrgBwCfg
 (
 CrgBwCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgBwCfg(param, mBuf)
+S16 cmPkCrgBwCfg(param, mBuf)
 CrgBwCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgBwCfg)
 
-   CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
-   CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
+   return ROK;
 }
 
 
@@ -845,23 +816,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgBwCfg
+S16 cmUnpkCrgBwCfg
 (
 CrgBwCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgBwCfg(param, mBuf)
+S16 cmUnpkCrgBwCfg(param, mBuf)
 CrgBwCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgBwCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->dlTotalBw, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ulTotalBw, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->dlTotalBw, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ulTotalBw, mBuf);
+   return ROK;
 }
 
 
@@ -882,22 +852,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgRachCfg
+S16 cmPkCrgRachCfg
 (
 CrgRachCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgRachCfg(param, mBuf)
+S16 cmPkCrgRachCfg(param, mBuf)
 CrgRachCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgRachCfg)
 
-   CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
+   return ROK;
 }
 
 
@@ -918,22 +887,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgRachCfg
+S16 cmUnpkCrgRachCfg
 (
 CrgRachCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgRachCfg(param, mBuf)
+S16 cmUnpkCrgRachCfg(param, mBuf)
 CrgRachCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgRachCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->maxMsg3Tx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->maxMsg3Tx, mBuf);
+   return ROK;
 }
 
 
@@ -954,22 +922,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCellCfg
+S16 cmPkCrgCellCfg
 (
 CrgCellCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgCellCfg(param, mBuf)
+S16 cmPkCrgCellCfg(param, mBuf)
 CrgCellCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgCellCfg)
 
 #ifdef EMTC_ENABLE
-   CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
 #endif
 #ifdef TENB_MULT_CELL_SUPPRT
    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
@@ -978,7 +945,7 @@ Buffer *mBuf;
    CMCHKPK(cmPkCrgBwCfg, &param->bwCfg, mBuf);
    CMCHKPK(cmPkCrgRachCfg, &param->rachCfg, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -999,19 +966,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCellCfg
+S16 cmUnpkCrgCellCfg
 (
 CrgCellCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCellCfg(param, mBuf)
+S16 cmUnpkCrgCellCfg(param, mBuf)
 CrgCellCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgCellCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachCfg, mBuf);
@@ -1021,9 +987,9 @@ Buffer *mBuf;
    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
 #endif
 #ifdef EMTC_ENABLE
-   CMCHKUNPK(SUnpkU8, &param->emtcEnable, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->emtcEnable, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1044,22 +1010,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUeUlHqCfg
+S16 cmPkCrgUeUlHqCfg
 (
 CrgUeUlHqCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgUeUlHqCfg(param, mBuf)
+S16 cmPkCrgUeUlHqCfg(param, mBuf)
 CrgUeUlHqCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgUeUlHqCfg)
 
-   CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
+   return ROK;
 }
 
 #ifdef LTE_ADV
@@ -1092,10 +1057,10 @@ Buffer *mBuf;
 {
    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
-   CMCHKPK(SPkU8, param->macInst, mBuf);
-   CMCHKPK(SPkU16, param->sCellId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -1124,11 +1089,11 @@ CrgUeSCellInfo *param;
 Buffer *mBuf;
 #endif
 {
-   CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->macInst, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->macInst, mBuf);
    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 /***********************************************************
 *
@@ -1146,13 +1111,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUeSecCellInfo
+S16 cmPkCrgUeSecCellInfo
 (
 CrgUeSecCellInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgUeSecCellInfo(param, mBuf)
+S16 cmPkCrgUeSecCellInfo(param, mBuf)
 CrgUeSecCellInfo *param;
 Buffer *mBuf;
 #endif
@@ -1163,10 +1128,10 @@ Buffer *mBuf;
       CMCHKPK(cmPkCrgUeSCellCfg, &param->ueSCellCfg[(U8)idx], mBuf);
    }
 
-   CMCHKPK(SPkU8, param->numSCells, mBuf);
-   CMCHKPK(SPkU8, param->isSCellCfgPres, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isSCellCfgPres, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -1185,23 +1150,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeSecCellInfo
+S16 cmUnpkCrgUeSecCellInfo
 (
 CrgUeSecCellInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
+S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
 CrgUeSecCellInfo *param;
 Buffer *mBuf;
 #endif
 {
    U8 idx;
 
-   CMCHKUNPK(SUnpkU8, &param->isSCellCfgPres, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isSCellCfgPres, mBuf);
    if(TRUE == param->isSCellCfgPres)
    {
-      CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
 
       for(idx = 0; idx < param->numSCells; idx++)
       {
@@ -1209,7 +1174,7 @@ Buffer *mBuf;
       }
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 #endif /* LTE_ADV */
@@ -1231,22 +1196,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeUlHqCfg
+S16 cmUnpkCrgUeUlHqCfg
 (
 CrgUeUlHqCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
+S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
 CrgUeUlHqCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgUeUlHqCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->maxUlHqTx, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->maxUlHqTx, mBuf);
+   return ROK;
 }
 
 
@@ -1267,29 +1231,28 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUeCfg
+S16 cmPkCrgUeCfg
 (
 CrgUeCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgUeCfg(param, mBuf)
+S16 cmPkCrgUeCfg(param, mBuf)
 CrgUeCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgUeCfg)
 #ifdef TENB_MULT_CELL_SUPPRT
    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
 #endif
-   CMCHKPK(SPkU32, param->txMode.tm, mBuf);
-   CMCHKPK(SPkU8, param->txMode.pres, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->txMode.tm, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->txMode.pres, mBuf);
    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1310,32 +1273,31 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeCfg
+S16 cmUnpkCrgUeCfg
 (
 CrgUeCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUeCfg(param, mBuf)
+S16 cmUnpkCrgUeCfg(param, mBuf)
 CrgUeCfg *param;
 Buffer *mBuf;
 #endif
 {
    U32 tmpEnum;
    
-   TRC3(cmUnpkCrgUeCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->txMode.pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
    param->txMode.tm = (CrgTxMode) tmpEnum;
 #ifdef TENB_MULT_CELL_SUPPRT
    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1356,22 +1318,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgDlLchCfg
+S16 cmPkCrgDlLchCfg
 (
 CrgDlLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgDlLchCfg(param, mBuf)
+S16 cmPkCrgDlLchCfg(param, mBuf)
 CrgDlLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgDlLchCfg)
 
-   CMCHKPK(SPkU8, param->dlTrchType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+   return ROK;
 }
 
 
@@ -1392,22 +1353,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgDlLchCfg
+S16 cmUnpkCrgDlLchCfg
 (
 CrgDlLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgDlLchCfg(param, mBuf)
+S16 cmUnpkCrgDlLchCfg(param, mBuf)
 CrgDlLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgDlLchCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->dlTrchType, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
+   return ROK;
 }
 
 
@@ -1428,23 +1388,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUlLchCfg
+S16 cmPkCrgUlLchCfg
 (
 CrgUlLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgUlLchCfg(param, mBuf)
+S16 cmPkCrgUlLchCfg(param, mBuf)
 CrgUlLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgUlLchCfg)
 
-   CMCHKPK(SPkU8, param->lcgId, mBuf);
-   CMCHKPK(SPkU8, param->ulTrchType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
+   return ROK;
 }
 
 
@@ -1465,23 +1424,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUlLchCfg
+S16 cmUnpkCrgUlLchCfg
 (
 CrgUlLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUlLchCfg(param, mBuf)
+S16 cmUnpkCrgUlLchCfg(param, mBuf)
 CrgUlLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgUlLchCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->ulTrchType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->ulTrchType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
+   return ROK;
 }
 
 
@@ -1502,31 +1460,30 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgLchCfg
+S16 cmPkCrgLchCfg
 (
 CrgLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgLchCfg(param, mBuf)
+S16 cmPkCrgLchCfg(param, mBuf)
 CrgLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgLchCfg)
 /* crg_c_001.main_5 - ADD - Added the packing for LTE_L2_MEAS. */
 #ifdef LTE_L2_MEAS
-   CMCHKPK(SPkU8, param->qci, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
 #endif
    CMCHKPK(cmPkCrgUlLchCfg, &param->ulInfo, mBuf);
    CMCHKPK(cmPkCrgDlLchCfg, &param->dlInfo, mBuf);
-   CMCHKPK(SPkU8, param->dir, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1547,32 +1504,31 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgLchCfg
+S16 cmUnpkCrgLchCfg
 (
 CrgLchCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgLchCfg(param, mBuf)
+S16 cmUnpkCrgLchCfg(param, mBuf)
 CrgLchCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgLchCfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->dir, mBuf);
    CMCHKUNPK(cmUnpkCrgDlLchCfg, &param->dlInfo, mBuf);
    CMCHKUNPK(cmUnpkCrgUlLchCfg, &param->ulInfo, mBuf);
 /* crg_c_001.main_5 - ADD - Added the unpacking for LTE_L2_MEAS. */
 #ifdef LTE_L2_MEAS
-   CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1593,19 +1549,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCfg
+S16 cmPkCrgCfg
 (
 CrgCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgCfg(param, mBuf)
+S16 cmPkCrgCfg(param, mBuf)
 CrgCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgCfg)
 
       switch(param->cfgType) {
          case CRG_LCH_CFG:
@@ -1618,10 +1573,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkCrgCellCfg, &param->u.cellCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->cfgType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+   return ROK;
 }
 
 
@@ -1642,21 +1597,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfg
+S16 cmUnpkCrgCfg
 (
 CrgCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCfg(param, mBuf)
+S16 cmUnpkCrgCfg(param, mBuf)
 CrgCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->cfgType, mBuf);
       switch(param->cfgType) {
          case CRG_CELL_CFG:
             CMCHKUNPK(cmUnpkCrgCellCfg, &param->u.cellCfg, mBuf);
@@ -1668,9 +1622,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkCrgLchCfg, &param->u.lchCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1691,23 +1645,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCellRecfg
+S16 cmPkCrgCellRecfg
 (
 CrgCellRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgCellRecfg(param, mBuf)
+S16 cmPkCrgCellRecfg(param, mBuf)
 CrgCellRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgCellRecfg)
 
    CMCHKPK(cmPkCrgRachCfg, &param->rachRecfg, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1728,23 +1681,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCellRecfg
+S16 cmUnpkCrgCellRecfg
 (
 CrgCellRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCellRecfg(param, mBuf)
+S16 cmUnpkCrgCellRecfg(param, mBuf)
 CrgCellRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgCellRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachRecfg, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1765,19 +1717,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgUeRecfg
+S16 cmPkCrgUeRecfg
 (
 CrgUeRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgUeRecfg(param, mBuf)
+S16 cmPkCrgUeRecfg(param, mBuf)
 CrgUeRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgUeRecfg)
 #ifdef LTE_ADV
    if(TRUE == param->crgSCellCfg.isSCellCfgPres)
    {
@@ -1785,16 +1736,16 @@ Buffer *mBuf;
    }
    else
    {
-      CMCHKPK(SPkU8, param->crgSCellCfg.isSCellCfgPres, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->crgSCellCfg.isSCellCfgPres, mBuf);
    }
 #endif /* LTE_ADV */
-   CMCHKPK(SPkU32, param->txMode.tm, mBuf);
-   CMCHKPK(SPkU8, param->txMode.pres, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->txMode.tm, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->txMode.pres, mBuf);
    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1815,30 +1766,29 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeRecfg
+S16 cmUnpkCrgUeRecfg
 (
 CrgUeRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgUeRecfg(param, mBuf)
+S16 cmUnpkCrgUeRecfg(param, mBuf)
 CrgUeRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgUeRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
-   CMCHKUNPK(SUnpkU32, (U32 *)&param->txMode.tm, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->txMode.pres, mBuf);
+   CMCHKUNPK(oduPackUInt32, (U32 *)&param->txMode.tm, mBuf);
 #ifdef LTE_ADV 
       CMCHKUNPK(cmUnpkCrgUeSecCellInfo, &param->crgSCellCfg, mBuf);
 #endif /* LTE_ADV */
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1859,25 +1809,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgLchRecfg
+S16 cmPkCrgLchRecfg
 (
 CrgLchRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgLchRecfg(param, mBuf)
+S16 cmPkCrgLchRecfg(param, mBuf)
 CrgLchRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgLchRecfg)
 
-      CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1898,25 +1847,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgLchRecfg
+S16 cmUnpkCrgLchRecfg
 (
 CrgLchRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgLchRecfg(param, mBuf)
+S16 cmUnpkCrgLchRecfg(param, mBuf)
 CrgLchRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgLchRecfg)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
-      CMCHKUNPK(SUnpkU8, &param->ulRecfg.lcgId, mBuf);
-   RETVALUE(ROK);
+      CMCHKUNPK(oduPackUInt8, &param->ulRecfg.lcgId, mBuf);
+   return ROK;
 }
 
 
@@ -1937,19 +1885,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgRecfg
+S16 cmPkCrgRecfg
 (
 CrgRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgRecfg(param, mBuf)
+S16 cmPkCrgRecfg(param, mBuf)
 CrgRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgRecfg)
 
       switch(param->recfgType) {
          case CRG_LCH_CFG:
@@ -1962,10 +1909,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkCrgCellRecfg, &param->u.cellRecfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->recfgType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->recfgType, mBuf);
+   return ROK;
 }
 
 
@@ -1986,21 +1933,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgRecfg
+S16 cmUnpkCrgRecfg
 (
 CrgRecfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgRecfg(param, mBuf)
+S16 cmUnpkCrgRecfg(param, mBuf)
 CrgRecfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgRecfg)
 
-   CMCHKUNPK(SUnpkU8, &param->recfgType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->recfgType, mBuf);
       switch(param->recfgType) {
          case CRG_CELL_CFG:
             CMCHKUNPK(cmUnpkCrgCellRecfg, &param->u.cellRecfg, mBuf);
@@ -2012,9 +1958,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkCrgLchRecfg, &param->u.lchRecfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2035,23 +1981,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgDel
+S16 cmPkCrgDel
 (
 CrgDel *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgDel(param, mBuf)
+S16 cmPkCrgDel(param, mBuf)
 CrgDel *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgDel)
 
       switch(param->delType) {
          case CRG_LCH_CFG:
-            CMCHKPK(SPkU8, param->u.lchDel.dir, mBuf);
+            CMCHKPK(oduUnpackUInt8, param->u.lchDel.dir, mBuf);
             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
@@ -2064,10 +2009,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
          break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->delType, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
+   return ROK;
 }
 
 
@@ -2088,21 +2033,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgDel
+S16 cmUnpkCrgDel
 (
 CrgDel *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgDel(param, mBuf)
+S16 cmUnpkCrgDel(param, mBuf)
 CrgDel *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgDel)
 
-   CMCHKUNPK(SUnpkU8, &param->delType, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->delType, mBuf);
       switch(param->delType) {
          case CRG_CELL_CFG:
             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
@@ -2115,12 +2059,12 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
-            CMCHKUNPK(SUnpkU8, &param->u.lchDel.dir, mBuf);
+            CMCHKUNPK(oduPackUInt8, &param->u.lchDel.dir, mBuf);
          break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2141,23 +2085,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgRst
+S16 cmPkCrgRst
 (
 CrgRst *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgRst(param, mBuf)
+S16 cmPkCrgRst(param, mBuf)
 CrgRst *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgRst)
 
    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2178,23 +2121,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgRst
+S16 cmUnpkCrgRst
 (
 CrgRst *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgRst(param, mBuf)
+S16 cmUnpkCrgRst(param, mBuf)
 CrgRst *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgRst)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2215,19 +2157,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkCrgCfgReqInfo
+S16 cmPkCrgCfgReqInfo
 (
 CrgCfgReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkCrgCfgReqInfo(param, mBuf)
+S16 cmPkCrgCfgReqInfo(param, mBuf)
 CrgCfgReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkCrgCfgReqInfo)
 
       switch(param->action) {
          case CRG_RESET:
@@ -2243,10 +2184,10 @@ Buffer *mBuf;
             CMCHKPK(cmPkCrgCfg, &param->u.cfgInfo, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   CMCHKPK(SPkU8, param->action, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->action, mBuf);
+   return ROK;
 }
 
 
@@ -2267,21 +2208,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgReqInfo
+S16 cmUnpkCrgCfgReqInfo
 (
 CrgCfgReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCrgCfgReqInfo(param, mBuf)
+S16 cmUnpkCrgCfgReqInfo(param, mBuf)
 CrgCfgReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkCrgCfgReqInfo)
 
-   CMCHKUNPK(SUnpkU8, &param->action, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
       switch(param->action) {
          case CRG_CONFIG:
             CMCHKUNPK(cmUnpkCrgCfg, &param->u.cfgInfo, mBuf);
@@ -2296,9 +2236,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkCrgRst, &param->u.rstInfo, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif