src/5gnrpdcp/pj_udx.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
  19 /********************************************************************20**
  20
  21         Name:    LTE PDCP Interface
  22
  23         Type:    C file
  24
  25         Desc:    This file contains the pack/unpack functions for the
  26                  data structures at UDX Interface.
  27
  28         File:    pj_udx.c
  29
  30 *********************************************************************21*/
  31 #if(defined(LCUDX) || defined(LWLCUDX))
  32 static const char* RLOG_MODULE_NAME="PDCP";
  33 static int RLOG_MODULE_ID=1024;
  34 static int RLOG_FILE_ID=224;
  35 #endif
  36
  37 /* header include files (.h) */
  38
  39 #include "envopt.h"             /* Environment options */
  40 #include "envdep.h"             /* Environment dependent */
  41 #include "envind.h"             /* Environment independent */
  42 #include "gen.h"                /* General */
  43 #include "ssi.h"                /* System services interface */
  44 #include "cm_lte.h"             /* Common LTE header file */
  45 #include "cm_llist.h"           /* Linked List header file */
  46 #include "cm_tkns.h"            /* Common tokens header file */
  47 #include "cm_hash.h"            /* Hash List header file */
  48 #include "cpj.h"                /* CPJ Interface header file */
  49 #include "lpj.h"
  50 #include "pj_udx.h"
  51
  52
  53
  54 /* header/extern include files (.x) */
  55
  56 #include "gen.x"                /* General */
  57 #include "ssi.x"                /* System services interface */
  58 #include "cm_lib.x"             /* Common lib header file */
  59 #include "cm_hash.x"            /* Hash List header file */
  60 #include "cm_llist.x"           /* Linked List header file */
  61 #include "cm_tkns.x"            /* Common tokens header file */
  62 #include "cm_lte.x"             /* Common LTE header file */
  63 #include "cpj.x"                /* CPJ Interface header file */
  64 #include "pj.h"
  65 #include "lpj.x"
  66 #include "pj_udx.x"
  67
  68 #if(defined(LCUDX) || defined(LWLCUDX))
  69 /* Packing/Unpacking Macros */
  70
  71 #ifdef ANSI
  72 PUBLIC S16 cmPkPjUdxBndReq
  73 (
  74 Pst * pst,
  75 SuId suId,
  76 SpId spId
  77 )
  78 #else
  79 PUBLIC S16 cmPkPjUdxBndReq(pst, suId, spId)
  80 Pst * pst;
  81 SuId suId;
  82 SpId spId;
  83 #endif
  84 {
  85    Buffer *mBuf = NULLP;
  86    TRC3(cmPkPjUdxBndReq)
  87
  88    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
  89 #if (ERRCLASS & ERRCLS_ADD_RES)
  90       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  91          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  92          (ErrVal)EUDX001, (ErrVal)0, "Packing failed");
  93 #endif
  94       RETVALUE(RFAILED);
  95    }
  96    if (SPkS16(spId, mBuf) != ROK) {
  97 #if (ERRCLASS & ERRCLS_ADD_RES)
  98       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  99          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 100          (ErrVal)EUDX002, (ErrVal)0, "Packing failed");
 101 #endif
 102       PJ_FREE_BUF(mBuf);
 103       RETVALUE(RFAILED);
 104    }
 105    if (SPkS16(suId, mBuf) != ROK) {
 106 #if (ERRCLASS & ERRCLS_ADD_RES)
 107       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 108          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 109          (ErrVal)EUDX003, (ErrVal)0, "Packing failed");
 110 #endif
 111       PJ_FREE_BUF(mBuf);
 112       RETVALUE(RFAILED);
 113    }
 114    pst->event = (Event) EVTUDXBNDREQ;
 115    RETVALUE(SPstTsk(pst,mBuf));
 116 }
 117
 118 #ifdef ANSI
 119 PUBLIC S16 cmUnpkPjUdxBndReq
 120 (
 121 UdxBndReq func,
 122 Pst *pst,
 123 Buffer *mBuf
 124 )
 125 #else
 126 PUBLIC S16 cmUnpkPjUdxBndReq(func, pst, mBuf)
 127 UdxBndReq func;
 128 Pst *pst;
 129 Buffer *mBuf;
 130 #endif
 131 {
 132    SuId suId;
 133    SpId spId;
 134
 135    TRC3(cmUnpkPjUdxBndReq)
 136
 137    if (SUnpkS16(&suId, mBuf) != ROK) {
 138       PJ_FREE_BUF(mBuf);
 139 #if (ERRCLASS & ERRCLS_ADD_RES)
 140       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 141          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 142          (ErrVal)EUDX004, (ErrVal)0, "Packing failed");
 143 #endif
 144       RETVALUE(RFAILED);
 145    }
 146    if (SUnpkS16(&spId, mBuf) != ROK) {
 147       PJ_FREE_BUF(mBuf);
 148 #if (ERRCLASS & ERRCLS_ADD_RES)
 149       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 150          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 151          (ErrVal)EUDX005, (ErrVal)0, "Packing failed");
 152 #endif
 153       RETVALUE(RFAILED);
 154    }
 155    PJ_FREE_BUF(mBuf);
 156    RETVALUE((*func)(pst, suId, spId));
 157 }
 158
 159 #ifdef ANSI
 160 PUBLIC S16 cmPkPjUdxBndCfm
 161 (
 162 Pst * pst,
 163 SuId suId,
 164 U8 status
 165 )
 166 #else
 167 PUBLIC S16 cmPkPjUdxBndCfm(pst, suId, status)
 168 Pst * pst;
 169 SuId suId;
 170 U8 status;
 171 #endif
 172 {
 173    Buffer *mBuf = NULLP;
 174    TRC3(cmPkPjUdxBndCfm)
 175
 176    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 177 #if (ERRCLASS & ERRCLS_ADD_RES)
 178       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 179          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 180          (ErrVal)ECPJ006, (ErrVal)0, "Packing failed");
 181 #endif
 182       RETVALUE(RFAILED);
 183    }
 184    if (SPkU8(status, mBuf) != ROK) {
 185 #if (ERRCLASS & ERRCLS_ADD_RES)
 186       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 187          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 188          (ErrVal)ECPJ007, (ErrVal)0, "Packing failed");
 189 #endif
 190       PJ_FREE_BUF(mBuf);
 191       RETVALUE(RFAILED);
 192    }
 193    if (SPkS16(suId, mBuf) != ROK) {
 194 #if (ERRCLASS & ERRCLS_ADD_RES)
 195       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 196          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 197          (ErrVal)ECPJ008, (ErrVal)0, "Packing failed");
 198 #endif
 199       PJ_FREE_BUF(mBuf);
 200       RETVALUE(RFAILED);
 201    }
 202    pst->event = (Event) EVTCPJBNDCFM;
 203    RETVALUE(SPstTsk(pst,mBuf));
 204 }
 205
 206 #ifdef ANSI
 207 PUBLIC S16 cmUnpkPjUdxBndCfm
 208 (
 209 UdxBndCfm func,
 210 Pst *pst,
 211 Buffer *mBuf
 212 )
 213 #else
 214 PUBLIC S16 cmUnpkPjUdxBndCfm(func, pst, mBuf)
 215 UdxBndCfm func;
 216 Pst *pst;
 217 Buffer *mBuf;
 218 #endif
 219 {
 220    SuId suId;
 221    U8 status;
 222
 223    TRC3(cmUnpkPjUdxBndCfm)
 224
 225    if (SUnpkS16(&suId, mBuf) != ROK) {
 226       PJ_FREE_BUF(mBuf);
 227 #if (ERRCLASS & ERRCLS_ADD_RES)
 228       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 229          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 230          (ErrVal)ECPJ009, (ErrVal)0, "Packing failed");
 231 #endif
 232       RETVALUE(RFAILED);
 233    }
 234    if (SUnpkU8(&status, mBuf) != ROK) {
 235       PJ_FREE_BUF(mBuf);
 236 #if (ERRCLASS & ERRCLS_ADD_RES)
 237       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 238          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 239          (ErrVal)ECPJ010, (ErrVal)0, "Packing failed");
 240 #endif
 241       RETVALUE(RFAILED);
 242    }
 243    PJ_FREE_BUF(mBuf);
 244    RETVALUE((*func)(pst, suId, status));
 245 }
 246
 247 #ifdef ANSI
 248 PUBLIC S16 cmPkPjUdxUbndReq
 249 (
 250 Pst * pst,
 251 SpId spId,
 252 Reason reason
 253 )
 254 #else
 255 PUBLIC S16 cmPkPjUdxUbndReq(pst, spId, reason)
 256 Pst * pst;
 257 SpId spId;
 258 Reason reason;
 259 #endif
 260 {
 261    Buffer *mBuf = NULLP;
 262    TRC3(cmPkPjUdxUbndReq)
 263
 264    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 265 #if (ERRCLASS & ERRCLS_ADD_RES)
 266       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 267          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 268          (ErrVal)EUDX011, (ErrVal)0, "Packing failed");
 269 #endif
 270       RETVALUE(RFAILED);
 271    }
 272
 273    if (SPkS16(reason, mBuf) != ROK) {
 274 #if (ERRCLASS & ERRCLS_ADD_RES)
 275       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 276          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 277          (ErrVal)EUDX012, (ErrVal)0, "Packing failed");
 278 #endif
 279       PJ_FREE_BUF(mBuf);
 280       RETVALUE(RFAILED);
 281    }
 282    if (SPkS16(spId, mBuf) != ROK) {
 283 #if (ERRCLASS & ERRCLS_ADD_RES)
 284       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 285          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 286          (ErrVal)EUDX013, (ErrVal)0, "Packing failed");
 287 #endif
 288       PJ_FREE_BUF(mBuf);
 289       RETVALUE(RFAILED);
 290    }
 291    pst->event = (Event) EVTUDXUBNDREQ;
 292    RETVALUE(SPstTsk(pst,mBuf));
 293 }
 294
 295 #ifdef ANSI
 296 PUBLIC S16 cmUnpkPjUdxUbndReq
 297 (
 298 UdxUbndReq func,
 299 Pst *pst,
 300 Buffer *mBuf
 301 )
 302 #else
 303 PUBLIC S16 cmUnpkPjUdxUbndReq(func, pst, mBuf)
 304 UdxUbndReq func;
 305 Pst *pst;
 306 Buffer *mBuf;
 307 #endif
 308 {
 309    SpId spId;
 310    Reason reason;
 311
 312    TRC3(cmUnpkPjUdxUbndReq)
 313
 314    if (SUnpkS16(&spId, mBuf) != ROK) {
 315       PJ_FREE_BUF(mBuf);
 316 #if (ERRCLASS & ERRCLS_ADD_RES)
 317       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 318          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 319          (ErrVal)EUDX014, (ErrVal)0, "Packing failed");
 320 #endif
 321       RETVALUE(RFAILED);
 322    }
 323    if (SUnpkS16(&reason, mBuf) != ROK) {
 324       PJ_FREE_BUF(mBuf);
 325 #if (ERRCLASS & ERRCLS_ADD_RES)
 326       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 327          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 328          (ErrVal)EUDX015, (ErrVal)0, "Packing failed");
 329 #endif
 330       RETVALUE(RFAILED);
 331    }
 332    PJ_FREE_BUF(mBuf);
 333    RETVALUE((*func)(pst, spId, reason));
 334 }
 335
 336 #ifdef ANSI
 337 PUBLIC S16 cmPkPjUdxCfgReq
 338 (
 339 Pst * pst,
 340 SpId spId,
 341 UdxCfgReqInfo * cfgReq
 342 )
 343 #else
 344 PUBLIC S16 cmPkPjUdxCfgReq(pst, spId, cfgReq)
 345 Pst * pst;
 346 SpId spId;
 347 UdxCfgReqInfo * cfgReq;
 348 #endif
 349 {
 350    Buffer *mBuf = NULLP;
 351    TRC3(cmPkPjUdxCfgReq)
 352
 353    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 354 #if (ERRCLASS & ERRCLS_ADD_RES)
 355       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 356          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 357          (ErrVal)EUDX016, (ErrVal)0, "Packing failed");
 358 #endif
 359       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgReq, sizeof(UdxCfgReqInfo));
 360       RETVALUE(RFAILED);
 361    }
 362
 363    switch(pst->selector)
 364    {
 365 #ifdef LCUDX
 366       case UDX_SEL_LC:
 367          {
 368
 369             if (cmPkPjUdxCfgReqInfo(pst, cfgReq, mBuf) != ROK) {
 370 #if (ERRCLASS & ERRCLS_ADD_RES)
 371                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 372                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 373                      (ErrVal)EUDX017, (ErrVal)0, "Packing failed");
 374 #endif
 375                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgReq, sizeof(UdxCfgReqInfo));
 376                PJ_FREE_BUF(mBuf);
 377                RETVALUE(RFAILED);
 378             }
 379
 380             /* Free Request Structure after packing */
 381             PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgReq, sizeof(UdxCfgReqInfo));
 382
 383
 384             break;
 385          }
 386       case UDX_SEL_LWLC:
 387          {
 388             CMCHKPKLOG(cmPkPtr,(PTR)cfgReq,mBuf,EUDXXXX,pst);
 389             break;
 390          }
 391 #endif /* LCUDX */
 392    }
 393
 394     if (SPkS16(spId, mBuf) != ROK) {
 395 #if (ERRCLASS & ERRCLS_ADD_RES)
 396       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 397          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 398          (ErrVal)EUDX019, (ErrVal)0, "Packing failed");
 399 #endif
 400       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgReq, sizeof(UdxCfgReqInfo));
 401       PJ_FREE_BUF(mBuf);
 402       RETVALUE(RFAILED);
 403    }
 404    pst->event = (Event) EVTUDXCFGREQ;
 405
 406    RETVALUE(SPstTsk(pst,mBuf));
 407 }
 408
 409 #ifdef ANSI
 410 PUBLIC S16 cmPkPjUdxUlStaRep
 411 (
 412 Pst * pst,
 413 SpId spId,
 414 UdxUlStaRepInfo *staRep
 415 )
 416 #else
 417 PUBLIC S16 cmPkPjUdxUlStaRep(pst, spId, staRep)
 418 Pst * pst;
 419 SpId spId;
 420 UdxUlStaRepInfo *staRep;
 421 #endif
 422 {
 423    S16 ret;
 424    Buffer *mBuf;
 425    mBuf = NULLP;
 426
 427    TRC3(cmPkPjUdxUlStaRep)
 428
 429    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 430 #if (ERRCLASS & ERRCLS_ADD_RES)
 431       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 432          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 433          (ErrVal)EUDX016, (ErrVal)0, "Packing failed");
 434 #endif
 435       PJ_FREE_BUF(mBuf);
 436       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staRep, sizeof(UdxUlStaRepInfo));
 437
 438       RETVALUE(RFAILED);
 439    }
 440
 441    switch(pst->selector)
 442    {
 443 #ifdef LCUDX
 444       case UDX_SEL_LC:
 445          {
 446             ret = cmPkPjUdxUlStaRepInfo( (staRep), pst, mBuf);
 447 #if (ERRCLASS & ERRCLS_ADD_RES)
 448             if(ret != ROK)
 449             {
 450                PJ_FREE_BUF(mBuf);
 451                PJ_FREE_BUF(staRep->sta);
 452                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, (Data *)staRep, sizeof(UdxUlStaRepInfo), 0);
 453
 454                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 455                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 456                      (ErrVal)EUDXXXX, (ErrVal)ret, "Packing failure");
 457                RETVALUE( ret );
 458             }
 459 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 460             PJ_FREE_BUF(staRep->sta);
 461 #ifndef XEON_SPECIFIC_CHANGES
 462             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staRep,
 463                      sizeof(UdxUlStaRepInfo), 0) != ROK)
 464 #else
 465             if (SPutSBuf(pst->region, pst->pool, (Data *)staRep,
 466                      sizeof(UdxUlStaRepInfo)) != ROK)
 467 #endif
 468             {
 469                PJ_FREE_BUF(mBuf);
 470                RETVALUE(RFAILED);
 471             }
 472
 473             break;
 474          }
 475        case UDX_SEL_LWLC:
 476          {
 477             CMCHKPKLOG(cmPkPtr,(PTR)staRep,mBuf,EUDXXXX,pst);
 478             break;
 479          }
 480 #endif /* LCUDX */
 481    }
 482
 483    CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 484    pst->event = (Event) EVTUDXULSTAREP;
 485
 486    RETVALUE(SPstTsk(pst,mBuf));
 487 }
 488
 489 #ifdef ANSI
 490 PUBLIC S16 cmPkPjUdxDlStaRep
 491 (
 492 Pst * pst,
 493 SpId spId,
 494 UdxDlStaRepInfo *staRep
 495 )
 496 #else
 497 PUBLIC S16 cmPkPjUdxDlStaRep(pst, spId, staRep)
 498 Pst * pst;
 499 SpId spId;
 500 UdxDlStaRepInfo *staRep;
 501 #endif
 502 {
 503    S16 ret;
 504    Buffer *mBuf;
 505    mBuf = NULLP;
 506
 507    TRC3(cmPkPjUdxDlStaRep)
 508
 509    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 510    {
 511 #if (ERRCLASS & ERRCLS_ADD_RES)
 512       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 513          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 514          (ErrVal)EUDX016, (ErrVal)0, "Packing failed");
 515 #endif
 516       PJ_FREE_BUF(staRep->staPdu);
 517       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staRep, sizeof(UdxDlStaRepInfo));
 518
 519       RETVALUE(RFAILED);
 520    }
 521
 522    switch(pst->selector)
 523    {
 524 #ifdef LCUDX
 525       case UDX_SEL_LC:
 526          {
 527             ret = cmPkPjUdxDlStaRepInfo( (staRep), pst, mBuf);
 528 #if (ERRCLASS & ERRCLS_ADD_RES)
 529             if(ret != ROK)
 530             {
 531                PJ_FREE_BUF(mBuf);
 532                PJ_FREE_BUF(staRep->staPdu);
 533                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staRep, sizeof(UdxDlStaRepInfo));
 534
 535                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 536                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 537                      (ErrVal)EUDXXXX, (ErrVal)ret, "Packing failure");
 538                RETVALUE( ret );
 539             }
 540 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 541             PJ_FREE_BUF(staRep->staPdu);
 542 #ifndef XEON_SPECIFIC_CHANGES
 543             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staRep,
 544                      sizeof(UdxDlStaRepInfo), 0) != ROK)
 545 #else
 546             if (SPutSBuf(pst->region, pst->pool, (Data *)staRep,
 547                      sizeof(UdxDlStaRepInfo)) != ROK)
 548 #endif
 549             {
 550                PJ_FREE_BUF(mBuf);
 551                RETVALUE(RFAILED);
 552             }
 553
 554             break;
 555          }
 556        case UDX_SEL_LWLC:
 557          {
 558             CMCHKPKLOG(cmPkPtr,(PTR)staRep,mBuf,EUDXXXX,pst);
 559             break;
 560          }
 561 #endif /* LCUDX */
 562    }
 563
 564    CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 565    pst->event = (Event) EVTUDXDLSTAREP;
 566
 567    RETVALUE(SPstTsk(pst,mBuf));
 568 }
 569
 570
 571 #ifdef ANSI
 572 PUBLIC S16 cmUnpkPjUdxCfgReq
 573 (
 574 UdxCfgReq func,
 575 Pst *pst,
 576 Buffer *mBuf
 577 )
 578 #else
 579 PUBLIC S16 cmUnpkPjUdxCfgReq(func, pst, mBuf)
 580 UdxCfgReq func;
 581 Pst *pst;
 582 Buffer *mBuf;
 583 #endif
 584 {
 585    S16   ret1;
 586    SpId spId;
 587    UdxCfgReqInfo *cfgReq;
 588
 589    TRC3(cmUnpkPjUdxCfgReq)
 590    if (SUnpkS16(&spId, mBuf) != ROK) {
 591       PJ_FREE_BUF(mBuf);
 592 #if (ERRCLASS & ERRCLS_ADD_RES)
 593       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 594          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 595          (ErrVal)EUDX021, (ErrVal)0, "Packing failed");
 596 #endif
 597       RETVALUE(RFAILED);
 598    }
 599
 600    switch(pst->selector)
 601    {
 602 #ifdef LCUDX
 603       case UDX_SEL_LC:
 604          {
 605
 606             if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgReq,\
 607                         sizeof(UdxCfgReqInfo))) != ROK)
 608             {
 609 #if (ERRCLASS & ERRCLS_ADD_RES)
 610                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 611                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 612                      (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
 613 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 614                RETVALUE(ret1);
 615             }
 616
 617             if (cmUnpkPjUdxCfgReqInfo(pst, cfgReq, mBuf) != ROK) {
 618                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgReq, sizeof(UdxCfgReqInfo);
 619                PJ_FREE_BUF(mBuf);
 620 #if (ERRCLASS & ERRCLS_ADD_RES)
 621                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 622                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 623                      (ErrVal)EUDX023, (ErrVal)0, "Packing failed");
 624 #endif
 625                RETVALUE(RFAILED);
 626             }
 627             break;
 628          }
 629       case UDX_SEL_LWLC:
 630          {
 631             CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgReq, mBuf);
 632             break;
 633          }
 634 #endif /* LCUDX */
 635    }
 636    PJ_FREE_BUF(mBuf);
 637    RETVALUE((*func)(pst, spId, cfgReq));
 638 }
 639
 640 #ifdef ANSI
 641 PUBLIC S16 cmPkPjUdxCfgCfm
 642 (
 643  Pst * pst,
 644  SuId suId,
 645  UdxCfgCfmInfo * cfgCfm
 646  )
 647 #else
 648 PUBLIC S16 cmPkPjUdxCfgCfm(pst, suId, cfgCfm)
 649         Pst * pst;
 650         SuId suId;
 651         UdxCfgCfmInfo * cfgCfm;
 652 #endif
 653 {
 654         Buffer *mBuf = NULLP;
 655         TRC3(cmPkPjUdxCfgCfm)
 656
 657                 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 658 #if (ERRCLASS & ERRCLS_ADD_RES)
 659                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 660                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 661                                         (ErrVal)ECPJ024, (ErrVal)0, "Packing failed");
 662 #endif
 663                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgCfm, sizeof(UdxCfgCfmInfo));
 664                         RETVALUE(RFAILED);
 665                 }
 666         switch(pst->selector)
 667         {
 668 #ifdef LCUDX
 669            case UDX_SEL_LC:
 670               {
 671
 672                  if (cmPkPjUdxCfgCfmInfo(cfgCfm, mBuf) != ROK) {
 673 #if (ERRCLASS & ERRCLS_ADD_RES)
 674                     SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 675                           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 676                           (ErrVal)ECPJ025, (ErrVal)0, "Packing failed");
 677 #endif
 678                     PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgCfm, sizeof(UdxCfgCfmInfo));
 679                     PJ_FREE_BUF(mBuf);
 680                     RETVALUE(RFAILED);
 681                  }
 682                  /* cpj_c_001.main_3 */
 683                  /* Free Confirm Structure after packing */
 684                  PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgCfm, sizeof(UdxCfgCfmInfo));
 685
 686
 687                  break;
 688               }
 689            case UDX_SEL_LWLC:
 690               {
 691                  CMCHKPKLOG(cmPkPtr,(PTR)cfgCfm,mBuf,EUDXXXX,pst);
 692                  break;
 693               }
 694 #endif /* LCUDX */
 695
 696         }
 697
 698         if (SPkS16(suId, mBuf) != ROK) {
 699 #if (ERRCLASS & ERRCLS_ADD_RES)
 700                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 701                                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 702                                 (ErrVal)ECPJ027, (ErrVal)0, "Packing failed");
 703 #endif
 704                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgCfm, sizeof(UdxCfgCfmInfo));
 705                 PJ_FREE_BUF(mBuf);
 706                 RETVALUE(RFAILED);
 707         }
 708         pst->event = (Event) EVTCPJCFGCFM;
 709         RETVALUE(SPstTsk(pst,mBuf));
 710 }
 711
 712 #ifdef ANSI
 713 PUBLIC S16 cmUnpkPjUdxCfgCfm
 714 (
 715  UdxCfgCfm func,
 716  Pst *pst,
 717  Buffer *mBuf
 718  )
 719 #else
 720 PUBLIC S16 cmUnpkPjUdxCfgCfm(func, pst, mBuf)
 721         UdxCfgCfm func;
 722         Pst *pst;
 723         Buffer *mBuf;
 724 #endif
 725 {
 726         S16   ret1;
 727         SuId suId;
 728         UdxCfgCfmInfo *cfgCfm;
 729
 730         TRC3(cmUnpkPjUdxCfgCfm)
 731         if (SUnpkS16(&suId, mBuf) != ROK) {
 732                    PJ_FREE_BUF(mBuf);
 733 #if (ERRCLASS & ERRCLS_ADD_RES)
 734                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 735                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 736                                         (ErrVal)ECPJ029, (ErrVal)0, "Packing failed");
 737 #endif
 738                         RETVALUE(RFAILED);
 739                 }
 740         switch(pst->selector)
 741         {
 742 #ifdef LCUDX
 743                 case UDX_SEL_LC:
 744                         {
 745
 746
 747                                 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfm,\
 748                                                                 sizeof(UdxCfgCfmInfo))) != ROK)
 749                                 {
 750 #if (ERRCLASS & ERRCLS_ADD_RES)
 751                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 752                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 753                                                         (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
 754 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 755                                         RETVALUE(ret1);
 756                                 }
 757
 758                                 if (cmUnpkPjUdxCfgCfmInfo(cfgCfm, mBuf) != ROK) {
 759                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, cfgCfm, sizeof(UdxCfgCfmInfo));
 760                                         PJ_FREE_BUF(mBuf);
 761 #if (ERRCLASS & ERRCLS_ADD_RES)
 762                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 763                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 764                                                         (ErrVal)ECPJ031, (ErrVal)0, "Packing failed");
 765 #endif
 766                                         RETVALUE(RFAILED);
 767                                 }
 768                                 break;
 769                         }
 770                 case UDX_SEL_LWLC:
 771                         {
 772                                 CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgCfm, mBuf);
 773                                 break;
 774                         }
 775 #endif /* LCUDX */
 776         }
 777         PJ_FREE_BUF(mBuf);
 778         RETVALUE((*func)(pst, suId, cfgCfm));
 779 }
 780
 781
 782 #ifdef ANSI
 783 PUBLIC S16 cmPkPjUdxReEstReq
 784 (
 785 Pst * pst,
 786 SpId spId,
 787 UdxReEstReqInfo * reEstReq
 788 )
 789 #else
 790 PUBLIC S16 cmPkPjUdxReEstReq(pst, spId, reEstReq)
 791 Pst * pst;
 792 SpId spId;
 793 UdxReEstReqInfo * reEstReq;
 794 #endif
 795 {
 796    Buffer *mBuf = NULLP;
 797    TRC3(cmPkPjUdxReEstReq)
 798
 799    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 800    {
 801 #if (ERRCLASS & ERRCLS_ADD_RES)
 802       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 803          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 804          (ErrVal)EUDX032, (ErrVal)0, "Packing failed");
 805 #endif
 806       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstReq, sizeof(UdxReEstReqInfo));
 807       RETVALUE(RFAILED);
 808    }
 809    switch(pst->selector)
 810    {
 811 #ifdef LCUDX
 812            case UDX_SEL_LC:
 813                    {
 814                            if (cmPkPjUdxReEstReqInfo(reEstReq, mBuf) != ROK) {
 815 #if (ERRCLASS & ERRCLS_ADD_RES)
 816                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 817                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 818                                                    (ErrVal)EUDX033, (ErrVal)0, "Packing failed");
 819 #endif
 820                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstReq, sizeof(UdxReEstReqInfo));
 821                                    PJ_FREE_BUF(mBuf);
 822                                    RETVALUE(RFAILED);
 823                            }
 824                            /* Free Request Structure after packing */
 825                            PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstReq, sizeof(UdxReEstReqInfo));
 826
 827                            break;
 828                    }
 829            case UDX_SEL_LWLC:
 830                    {
 831                            CMCHKPKLOG(cmPkPtr,(PTR)reEstReq,mBuf,EUDXXXX,pst);
 832                            break;
 833                    }
 834 #endif /* LCUDX */
 835    }
 836
 837    if (SPkS16(spId, mBuf) != ROK) {
 838 #if (ERRCLASS & ERRCLS_ADD_RES)
 839       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 840          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 841          (ErrVal)EUDX035, (ErrVal)0, "Packing failed");
 842 #endif
 843       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstReq, sizeof(UdxReEstReqInfo));
 844       PJ_FREE_BUF(mBuf);
 845       RETVALUE(RFAILED);
 846    }
 847
 848    pst->event = (Event) EVTUDXREESTREQ;
 849    RETVALUE(SPstTsk(pst,mBuf));
 850 }
 851
 852 #ifdef ANSI
 853 PUBLIC S16 cmUnpkPjUdxReEstReq
 854 (
 855 UdxReEstReq func,
 856 Pst *pst,
 857 Buffer *mBuf
 858 )
 859 #else
 860 PUBLIC S16 cmUnpkPjUdxReEstReq(func, pst, mBuf)
 861 UdxReEstReq func;
 862 Pst *pst;
 863 Buffer *mBuf;
 864 #endif
 865 {
 866    S16   ret1;
 867    SpId spId;
 868    UdxReEstReqInfo *reEstReq;
 869
 870    TRC3(cmUnpkPjUdxReEstReq)
 871
 872    if (SUnpkS16(&spId, mBuf) != ROK) {
 873       PJ_FREE_BUF(mBuf);
 874 #if (ERRCLASS & ERRCLS_ADD_RES)
 875       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 876          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 877          (ErrVal)EUDX037, (ErrVal)0, "Packing failed");
 878 #endif
 879       RETVALUE(RFAILED);
 880    }
 881    switch(pst->selector)
 882    {
 883 #ifdef LCUDX
 884            case UDX_SEL_LC:
 885                    {
 886
 887                            if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&reEstReq,\
 888                                                            sizeof(UdxReEstReqInfo))) != ROK)
 889                            {
 890 #if (ERRCLASS & ERRCLS_ADD_RES)
 891                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 892                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 893                                                    (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
 894 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 895                                    RETVALUE(ret1);
 896                            }
 897
 898                            if (cmUnpkPjUdxReEstReqInfo(reEstReq, mBuf) != ROK) {
 899                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstReq, sizeof(UdxReEstReqInfo));
 900                                    PJ_FREE_BUF(mBuf);
 901 #if (ERRCLASS & ERRCLS_ADD_RES)
 902                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 903                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 904                                                    (ErrVal)EUDX039, (ErrVal)0, "Packing failed");
 905 #endif
 906                                    RETVALUE(RFAILED);
 907                            }
 908                            break;
 909                    }
 910            case UDX_SEL_LWLC:
 911                    {
 912                            CMCHKUNPK(cmUnpkPtr,(PTR *) &reEstReq, mBuf);
 913                            break;
 914                    }
 915 #endif /* LCUDX */
 916 }
 917
 918    PJ_FREE_BUF(mBuf);
 919    RETVALUE((*func)(pst, spId, reEstReq));
 920 }
 921
 922
 923 #ifdef ANSI
 924 PUBLIC S16 cmPkPjUdxReEstCfm
 925 (
 926  Pst * pst,
 927  SuId suId,
 928  UdxReEstCfmInfo * reEstCfm
 929  )
 930 #else
 931 PUBLIC S16 cmPkPjUdxReEstCfm(pst, suId, reEstCfm)
 932         Pst * pst;
 933         SuId suId;
 934         UdxReEstCfmInfo * reEstCfm;
 935 #endif
 936 {
 937         Buffer *mBuf = NULLP;
 938         TRC3(cmPkPjUdxReEstCfm)
 939
 940                 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 941 #if (ERRCLASS & ERRCLS_ADD_RES)
 942                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 943                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 944                                         (ErrVal)ECPJ040, (ErrVal)0, "Packing failed");
 945 #endif
 946                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstCfm, sizeof(UdxReEstCfmInfo));
 947                         RETVALUE(RFAILED);
 948                 }
 949         switch(pst->selector)
 950         {
 951 #ifdef LCUDX
 952                 case UDX_SEL_LC:
 953                         {
 954
 955                                 if (cmPkPjUdxReEstCfmInfo(reEstCfm, mBuf) != ROK) {
 956 #if (ERRCLASS & ERRCLS_ADD_RES)
 957                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 958                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 959                                                         (ErrVal)ECPJ041, (ErrVal)0, "Packing failed");
 960 #endif
 961                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstCfm, sizeof(UdxReEstCfmInfo));
 962                                         PJ_FREE_BUF(mBuf);
 963                                         RETVALUE(RFAILED);
 964                                 }
 965
 966                                 /* Free Confirm Structure after packing */
 967                                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstCfm, sizeof(UdxReEstCfmInfo));
 968                                 break;
 969                         }
 970                 case UDX_SEL_LWLC:
 971                         {
 972                                 CMCHKPKLOG(cmPkPtr,(PTR)reEstCfm,mBuf,EUDXXXX,pst);
 973                                 break;
 974                         }
 975 #endif /* LCUDX */
 976         }
 977         if (SPkS16(suId, mBuf) != ROK)
 978         {
 979 #if (ERRCLASS & ERRCLS_ADD_RES)
 980                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 981                                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 982                                 (ErrVal)ECPJ043, (ErrVal)0, "Packing failed");
 983 #endif
 984                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstCfm, sizeof(UdxReEstCfmInfo));
 985                 PJ_FREE_BUF(mBuf);
 986                 RETVALUE(RFAILED);
 987         }
 988
 989
 990         pst->event = (Event) EVTCPJREESTCFM;
 991         RETVALUE(SPstTsk(pst,mBuf));
 992 }
 993
 994 #ifdef ANSI
 995 PUBLIC S16 cmUnpkPjUdxReEstCfm
 996 (
 997  UdxReEstCfm func,
 998  Pst *pst,
 999  Buffer *mBuf
1000  )
1001 #else
1002 PUBLIC S16 cmUnpkPjUdxReEstCfm(func, pst, mBuf)
1003         UdxReEstCfm func;
1004         Pst *pst;
1005         Buffer *mBuf;
1006 #endif
1007 {
1008         S16   ret1;
1009         SuId suId;
1010         UdxReEstCfmInfo *reEstCfm;
1011
1012         TRC3(cmUnpkPjUdxReEstCfm)
1013
1014                 if (SUnpkS16(&suId, mBuf) != ROK) {
1015                    PJ_FREE_BUF(mBuf);
1016 #if (ERRCLASS & ERRCLS_ADD_RES)
1017                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1018                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1019                                         (ErrVal)ECPJ045, (ErrVal)0, "Packing failed");
1020 #endif
1021                         RETVALUE(RFAILED);
1022                 }
1023         switch(pst->selector)
1024         {
1025 #ifdef LCUDX
1026                 case UDX_SEL_LC:
1027                         {
1028
1029
1030                                 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&reEstCfm,\
1031                                                                 sizeof(UdxReEstCfmInfo))) != ROK)
1032                                 {
1033 #if (ERRCLASS & ERRCLS_ADD_RES)
1034                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1035                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1036                                                         (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
1037 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1038                                         RETVALUE(ret1);
1039                                 }
1040
1041                                 if (cmUnpkPjUdxReEstCfmInfo(reEstCfm, mBuf) != ROK) {
1042                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, reEstCfm, sizeof(UdxReEstCfmInfo));
1043                                         PJ_FREE_BUF(mBuf);
1044 #if (ERRCLASS & ERRCLS_ADD_RES)
1045                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1046                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1047                                                         (ErrVal)ECPJ047, (ErrVal)0, "Packing failed");
1048 #endif
1049                                         RETVALUE(RFAILED);
1050                                 }
1051                                 break;
1052                         }
1053                 case UDX_SEL_LWLC:
1054                         {
1055                                 CMCHKUNPK(cmUnpkPtr,(PTR *) &reEstCfm, mBuf);
1056                                 break;
1057                         }
1058 #endif /* LCUDX */
1059         }
1060
1061         PJ_FREE_BUF(mBuf);
1062         RETVALUE((*func)(pst, suId, reEstCfm));
1063 }
1064
1065
1066 #ifdef ANSI
1067 PUBLIC S16 cmPkPjUdxSecCfgReq
1068 (
1069 Pst * pst,
1070 SpId spId,
1071 UdxSecCfgReqInfo * secCfgReq
1072 )
1073 #else
1074 PUBLIC S16 cmPkPjUdxSecCfgReq(pst, spId, secCfgReq)
1075 Pst * pst;
1076 SpId spId;
1077 UdxSecCfgReqInfo * secCfgReq;
1078 #endif
1079 {
1080    Buffer *mBuf = NULLP;
1081    TRC3(cmPkPjUdxSecCfgReq)
1082
1083    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1084 #if (ERRCLASS & ERRCLS_ADD_RES)
1085       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1086          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1087          (ErrVal)EUDX048, (ErrVal)0, "Packing failed");
1088 #endif
1089       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgReq, sizeof(UdxSecCfgReqInfo));
1090       RETVALUE(RFAILED);
1091    }
1092
1093    switch(pst->selector)
1094    {
1095 #ifdef LCUDX
1096            case UDX_SEL_LC:
1097                    {
1098
1099                            if (cmPkPjUdxSecCfgReqInfo(secCfgReq, mBuf) != ROK) {
1100 #if (ERRCLASS & ERRCLS_ADD_RES)
1101                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1102                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1103                                                    (ErrVal)EUDX049, (ErrVal)0, "Packing failed");
1104 #endif
1105                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgReq, sizeof(UdxSecCfgReqInfo));
1106                                    PJ_FREE_BUF(mBuf);
1107                                    RETVALUE(RFAILED);
1108                            }
1109                            /* Free Request Structure after packing */
1110                            PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgReq, sizeof(UdxSecCfgReqInfo));
1111                            break;
1112
1113                    }
1114            case UDX_SEL_LWLC:
1115                    {
1116                            CMCHKPKLOG(cmPkPtr,(PTR)secCfgReq,mBuf,EUDXXXX,pst);
1117                            break;
1118                    }
1119 #endif /* LCUDX */
1120    }
1121
1122    if (SPkS16(spId, mBuf) != ROK) {
1123 #if (ERRCLASS & ERRCLS_ADD_RES)
1124       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1125          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1126          (ErrVal)EUDX051, (ErrVal)0, "Packing failed");
1127 #endif
1128       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgReq, sizeof(UdxSecCfgReqInfo));
1129       PJ_FREE_BUF(mBuf);
1130       RETVALUE(RFAILED);
1131    }
1132
1133     pst->event = (Event) EVTUDXSECCFGREQ;
1134    RETVALUE(SPstTsk(pst,mBuf));
1135 }
1136
1137 #ifdef ANSI
1138 PUBLIC S16 cmUnpkPjUdxSecCfgReq
1139 (
1140 UdxSecCfgReq func,
1141 Pst *pst,
1142 Buffer *mBuf
1143 )
1144 #else
1145 PUBLIC S16 cmUnpkPjUdxSecCfgReq(func, pst, mBuf)
1146 UdxSecCfgReq func;
1147 Pst *pst;
1148 Buffer *mBuf;
1149 #endif
1150 {
1151    S16   ret1;
1152    SpId spId;
1153    UdxSecCfgReqInfo *secCfgReq;
1154
1155    TRC3(cmUnpkPjUdxSecCfgReq)
1156
1157    if (SUnpkS16(&spId, mBuf) != ROK) {
1158       PJ_FREE_BUF(mBuf);
1159 #if (ERRCLASS & ERRCLS_ADD_RES)
1160       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1161          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1162          (ErrVal)EUDX053, (ErrVal)0, "Packing failed");
1163 #endif
1164       RETVALUE(RFAILED);
1165    }
1166    switch(pst->selector)
1167    {
1168 #ifdef LCUDX
1169            case UDX_SEL_LC:
1170                    {
1171
1172                            if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&secCfgReq,\
1173                                                            sizeof(UdxSecCfgReqInfo))) != ROK)
1174                            {
1175 #if (ERRCLASS & ERRCLS_ADD_RES)
1176                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1177                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1178                                                    (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
1179 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1180                                    RETVALUE(ret1);
1181                            }
1182
1183                            if (cmUnpkPjUdxSecCfgReqInfo(secCfgReq, mBuf) != ROK) {
1184                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgReq, sizeof(UdxSecCfgReqInfo));
1185                                    PJ_FREE_BUF(mBuf);
1186 #if (ERRCLASS & ERRCLS_ADD_RES)
1187                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1188                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1189                                                    (ErrVal)EUDX055, (ErrVal)0, "Packing failed");
1190 #endif
1191                                    RETVALUE(RFAILED);
1192                            }
1193                            break;
1194
1195                    }
1196            case UDX_SEL_LWLC:
1197                    {
1198                            CMCHKUNPK(cmUnpkPtr,(PTR *) &secCfgReq,mBuf);
1199                            break;
1200                    }
1201 #endif /* LCUDX */
1202    }
1203    PJ_FREE_BUF(mBuf);
1204    RETVALUE((*func)(pst, spId, secCfgReq));
1205 }
1206
1207
1208 #ifdef ANSI
1209 PUBLIC S16 cmPkPjUdxSecCfgCfm
1210 (
1211  Pst * pst,
1212  SuId suId,
1213  UdxSecCfgCfmInfo * secCfgCfm
1214  )
1215 #else
1216 PUBLIC S16 cmPkPjUdxSecCfgCfm(pst, suId, secCfgCfm)
1217         Pst * pst;
1218         SuId suId;
1219         UdxSecCfgCfmInfo * secCfgCfm;
1220 #endif
1221 {
1222         Buffer *mBuf = NULLP;
1223         TRC3(cmPkPjUdxSecCfgCfm)
1224
1225                 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1226 #if (ERRCLASS & ERRCLS_ADD_RES)
1227                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1228                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1229                                         (ErrVal)ECPJ056, (ErrVal)0, "Packing failed");
1230 #endif
1231                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgCfm, sizeof(UdxSecCfgCfmInfo));
1232                         RETVALUE(RFAILED);
1233                 }
1234         switch(pst->selector)
1235         {
1236 #ifdef LCUDX
1237                 case UDX_SEL_LC:
1238                         {
1239
1240
1241                                 if (cmPkPjUdxSecCfgCfmInfo(secCfgCfm, mBuf) != ROK) {
1242 #if (ERRCLASS & ERRCLS_ADD_RES)
1243                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1244                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1245                                                         (ErrVal)ECPJ057, (ErrVal)0, "Packing failed");
1246 #endif
1247                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgCfm, sizeof(UdxSecCfgCfmInfo));
1248                                         PJ_FREE_BUF(mBuf);
1249                                         RETVALUE(RFAILED);
1250                                 }
1251                                 /* Free Confirm Structure after packing */
1252                                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgCfm, sizeof(UdxSecCfgCfmInfo));
1253
1254
1255                                 break;
1256
1257                         }
1258                 case UDX_SEL_LWLC:
1259                         {
1260                                 CMCHKPKLOG(cmPkPtr,(PTR)secCfgCfm,mBuf,EUDXXXX,pst);
1261                                 break;
1262                         }
1263 #endif /* LCUDX */
1264         }
1265
1266
1267
1268         if (SPkS16(suId, mBuf) != ROK) {
1269 #if (ERRCLASS & ERRCLS_ADD_RES)
1270                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1271                                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1272                                 (ErrVal)ECPJ059, (ErrVal)0, "Packing failed");
1273 #endif
1274                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgCfm, sizeof(UdxSecCfgCfmInfo));
1275                 PJ_FREE_BUF(mBuf);
1276                 RETVALUE(RFAILED);
1277         }
1278
1279         pst->event = (Event) EVTCPJSECCFGCFM;
1280         RETVALUE(SPstTsk(pst,mBuf));
1281 }
1282
1283 #ifdef ANSI
1284 PUBLIC S16 cmUnpkPjUdxSecCfgCfm
1285 (
1286  UdxSecCfgCfm func,
1287  Pst *pst,
1288  Buffer *mBuf
1289  )
1290 #else
1291 PUBLIC S16 cmUnpkPjUdxSecCfgCfm(func, pst, mBuf)
1292         UdxSecCfgCfm func;
1293         Pst *pst;
1294         Buffer *mBuf;
1295 #endif
1296 {
1297         S16   ret1;
1298         SuId suId;
1299         UdxSecCfgCfmInfo *secCfgCfm;
1300
1301         TRC3(cmUnpkPjUdxSecCfgCfm)
1302
1303                 if (SUnpkS16(&suId, mBuf) != ROK) {
1304                    PJ_FREE_BUF(mBuf);
1305 #if (ERRCLASS & ERRCLS_ADD_RES)
1306                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1307                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1308                                         (ErrVal)ECPJ061, (ErrVal)0, "Packing failed");
1309 #endif
1310                         RETVALUE(RFAILED);
1311                 }
1312         switch(pst->selector)
1313         {
1314 #ifdef LCUDX
1315                 case UDX_SEL_LC:
1316                         {
1317
1318
1319                                 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&secCfgCfm,\
1320                                                                 sizeof(UdxSecCfgCfmInfo))) != ROK)
1321                                 {
1322 #if (ERRCLASS & ERRCLS_ADD_RES)
1323                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1324                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1325                                                         (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
1326 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1327                                         RETVALUE(ret1);
1328                                 }
1329
1330                                 if (cmUnpkPjUdxSecCfgCfmInfo(secCfgCfm, mBuf) != ROK) {
1331                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, secCfgCfm, sizeof(UdxSecCfgCfmInfo));
1332                                         PJ_FREE_BUF(mBuf);
1333 #if (ERRCLASS & ERRCLS_ADD_RES)
1334                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1335                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1336                                                         (ErrVal)ECPJ063, (ErrVal)0, "Packing failed");
1337 #endif
1338                                         RETVALUE(RFAILED);
1339                                 }
1340                                 break;
1341
1342                         }
1343                 case UDX_SEL_LWLC:
1344                         {
1345                                 CMCHKUNPK(cmUnpkPtr,(PTR *)&secCfgCfm,mBuf);
1346                                 break;
1347                         }
1348 #endif /* LCUDX */
1349         }
1350         PJ_FREE_BUF(mBuf);
1351         RETVALUE((*func)(pst, suId, secCfgCfm));
1352 }
1353
1354
1355 #ifdef ANSI
1356 PUBLIC S16 cmPkPjUdxUeIdChgReq
1357 (
1358 Pst * pst,
1359 SpId spId,
1360 U32 transId,
1361 UdxUeInfo * oldUeInfo,
1362 UdxUeInfo * newUeInfo
1363 )
1364 #else
1365 PUBLIC S16 cmPkPjUdxUeIdChgReq(pst, spId, transId, oldUeInfo, newUeInfo)
1366 Pst * pst;
1367 SpId spId;
1368 U32 transId;
1369 UdxUeInfo * oldUeInfo;
1370 UdxUeInfo * newUeInfo;
1371 #endif
1372 {
1373    Buffer *mBuf = NULLP;
1374    TRC3(cmPkPjUdxUeIdChgReq)
1375
1376    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1377 #if (ERRCLASS & ERRCLS_ADD_RES)
1378       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1379          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1380          (ErrVal)EUDX064, (ErrVal)0, "Packing failed");
1381 #endif
1382       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1383       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1384       RETVALUE(RFAILED);
1385    }
1386    if (cmPkPjUdxUeInfo(newUeInfo, mBuf) != ROK) {
1387 #if (ERRCLASS & ERRCLS_ADD_RES)
1388          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1389             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1390             (ErrVal)EUDX065, (ErrVal)0, "Packing failed");
1391 #endif
1392          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1393          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1394          PJ_FREE_BUF(mBuf);
1395          RETVALUE(RFAILED);
1396    }
1397
1398    if (cmPkPjUdxUeInfo(oldUeInfo, mBuf) != ROK) {
1399 #if (ERRCLASS & ERRCLS_ADD_RES)
1400          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1401             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1402             (ErrVal)EUDX067, (ErrVal)0, "Packing failed");
1403 #endif
1404          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1405          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1406          PJ_FREE_BUF(mBuf);
1407          RETVALUE(RFAILED);
1408    }
1409
1410    if (SPkU32(transId, mBuf) != ROK) {
1411 #if (ERRCLASS & ERRCLS_ADD_RES)
1412       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1413          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1414          (ErrVal)EUDX069, (ErrVal)0, "Packing failed");
1415 #endif
1416       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1417       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1418       PJ_FREE_BUF(mBuf);
1419       RETVALUE(RFAILED);
1420    }
1421    if (SPkS16(spId, mBuf) != ROK) {
1422 #if (ERRCLASS & ERRCLS_ADD_RES)
1423       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1424          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1425          (ErrVal)EUDX070, (ErrVal)0, "Packing failed");
1426 #endif
1427       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1428       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1429       PJ_FREE_BUF(mBuf);
1430       RETVALUE(RFAILED);
1431    }
1432
1433    /* Free Request Structure after packing */
1434    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1435    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1436
1437    pst->event = (Event) EVTUDXUEIDCHGREQ;
1438    RETVALUE(SPstTsk(pst,mBuf));
1439 }
1440
1441 #ifdef ANSI
1442 PUBLIC S16 cmUnpkPjUdxUeIdChgReq
1443 (
1444 UdxUeIdChgReq func,
1445 Pst *pst,
1446 Buffer *mBuf
1447 )
1448 #else
1449 PUBLIC S16 cmUnpkPjUdxUeIdChgReq(func, pst, mBuf)
1450 UdxUeIdChgReq func;
1451 Pst *pst;
1452 Buffer *mBuf;
1453 #endif
1454 {
1455    S16 ret1;
1456    SpId spId;
1457    U32 transId;
1458    UdxUeInfo *oldUeInfo;
1459    UdxUeInfo *newUeInfo;
1460
1461    TRC3(cmUnpkPjUdxUeIdChgReq)
1462
1463    if (SUnpkS16(&spId, mBuf) != ROK) {
1464       PJ_FREE_BUF(mBuf);
1465 #if (ERRCLASS & ERRCLS_ADD_RES)
1466       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1467          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1468          (ErrVal)EUDX073, (ErrVal)0, "Packing failed");
1469 #endif
1470       RETVALUE(RFAILED);
1471    }
1472    if (SUnpkU32(&transId, mBuf) != ROK) {
1473       PJ_FREE_BUF(mBuf);
1474 #if (ERRCLASS & ERRCLS_ADD_RES)
1475       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1476          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1477          (ErrVal)EUDX074, (ErrVal)0, "Packing failed");
1478 #endif
1479       RETVALUE(RFAILED);
1480    }
1481
1482     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&oldUeInfo,\
1483                 sizeof(UdxUeInfo))) != ROK)
1484     {
1485 #if (ERRCLASS & ERRCLS_ADD_RES)
1486        SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1487              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1488              (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
1489 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1490        RETVALUE(ret1);
1491     }
1492
1493    if (cmUnpkPjUdxUeInfo(oldUeInfo, mBuf) != ROK) {
1494       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1495       PJ_FREE_BUF(mBuf);
1496 #if (ERRCLASS & ERRCLS_ADD_RES)
1497       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1498          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1499          (ErrVal)EUDX076, (ErrVal)0, "Packing failed");
1500 #endif
1501       RETVALUE(RFAILED);
1502    }
1503
1504    if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
1505                sizeof(UdxUeInfo))) != ROK)
1506    {
1507 #if (ERRCLASS & ERRCLS_ADD_RES)
1508       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1509             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1510             (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
1511 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1512       RETVALUE(ret1);
1513    }
1514
1515    if (cmUnpkPjUdxUeInfo(newUeInfo, mBuf) != ROK)
1516    {
1517       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, oldUeInfo, sizeof(UdxUeInfo));
1518       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, newUeInfo, sizeof(UdxUeInfo));
1519       PJ_FREE_BUF(mBuf);
1520 #if (ERRCLASS & ERRCLS_ADD_RES)
1521       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1522          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1523          (ErrVal)EUDX078, (ErrVal)0, "Packing failed");
1524 #endif
1525       RETVALUE(RFAILED);
1526    }
1527    PJ_FREE_BUF(mBuf);
1528    RETVALUE((*func)(pst, spId, transId, oldUeInfo, newUeInfo));
1529 }
1530
1531
1532 #ifdef ANSI
1533 PUBLIC S16 cmPkPjUdxUeIdChgCfm
1534 (
1535 Pst * pst,
1536 SuId suId,
1537 U32 transId,
1538 UdxUeInfo  * ueInfo,
1539 CmStatus status
1540 )
1541 #else
1542 PUBLIC S16 cmPkPjUdxUeIdChgCfm(pst, suId, transId, ueInfo, status)
1543 Pst * pst;
1544 SuId suId;
1545 U32 transId;
1546 UdxUeInfo  * ueInfo;
1547 CmStatus status;
1548 #endif
1549 {
1550    Buffer *mBuf = NULLP;
1551    TRC3(cmPkPjUdxUeIdChgCfm)
1552
1553    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1554 #if (ERRCLASS & ERRCLS_ADD_RES)
1555       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1556          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1557          (ErrVal)ECPJ079, (ErrVal)0, "Packing failed");
1558 #endif
1559       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1560       RETVALUE(RFAILED);
1561    }
1562    if (cmPkCmStatus(&status, mBuf) != ROK) {
1563 #if (ERRCLASS & ERRCLS_ADD_RES)
1564       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1565          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1566          (ErrVal)ECPJ080, (ErrVal)0, "Packing failed");
1567 #endif
1568       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1569       PJ_FREE_BUF(mBuf);
1570       RETVALUE(RFAILED);
1571    }
1572    if (cmPkPjUdxUeInfo(ueInfo, mBuf) != ROK) {
1573 #if (ERRCLASS & ERRCLS_ADD_RES)
1574          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1575             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1576             (ErrVal)ECPJ081, (ErrVal)0, "Packing failed");
1577 #endif
1578          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1579          PJ_FREE_BUF(mBuf);
1580          RETVALUE(RFAILED);
1581    }
1582
1583    if (SPkU32(transId, mBuf) != ROK) {
1584 #if (ERRCLASS & ERRCLS_ADD_RES)
1585       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1586          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1587          (ErrVal)ECPJ083, (ErrVal)0, "Packing failed");
1588 #endif
1589       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1590       PJ_FREE_BUF(mBuf);
1591       RETVALUE(RFAILED);
1592    }
1593    if (SPkS16(suId, mBuf) != ROK) {
1594 #if (ERRCLASS & ERRCLS_ADD_RES)
1595       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1596          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1597          (ErrVal)ECPJ084, (ErrVal)0, "Packing failed");
1598 #endif
1599       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1600       PJ_FREE_BUF(mBuf);
1601       RETVALUE(RFAILED);
1602    }
1603
1604    /* Free Confirm Structure after packing */
1605    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1606
1607    pst->event = (Event) EVTCPJUEIDCHGCFM;
1608    RETVALUE(SPstTsk(pst,mBuf));
1609 }
1610
1611 #ifdef ANSI
1612 PUBLIC S16 cmUnpkPjUdxUeIdChgCfm
1613 (
1614 UdxUeIdChgCfm func,
1615 Pst *pst,
1616 Buffer *mBuf
1617 )
1618 #else
1619 PUBLIC S16 cmUnpkPjUdxUeIdChgCfm(func, pst, mBuf)
1620 UdxUeIdChgCfm func;
1621 Pst *pst;
1622 Buffer *mBuf;
1623 #endif
1624 {
1625    S16   ret1;
1626    SuId suId;
1627    U32 transId;
1628    UdxUeInfo *ueInfo;
1629    CmStatus status;
1630
1631    TRC3(cmUnpkPjUdxUeIdChgCfm)
1632
1633    if (SUnpkS16(&suId, mBuf) != ROK) {
1634       PJ_FREE_BUF(mBuf);
1635 #if (ERRCLASS & ERRCLS_ADD_RES)
1636       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1637          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1638          (ErrVal)ECPJ086, (ErrVal)0, "Packing failed");
1639 #endif
1640       RETVALUE(RFAILED);
1641    }
1642    if (SUnpkU32(&transId, mBuf) != ROK) {
1643       PJ_FREE_BUF(mBuf);
1644 #if (ERRCLASS & ERRCLS_ADD_RES)
1645       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1646          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1647          (ErrVal)ECPJ087, (ErrVal)0, "Packing failed");
1648 #endif
1649       RETVALUE(RFAILED);
1650    }
1651
1652    if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1653                sizeof(UdxUeInfo))) != ROK)
1654    {
1655 #if (ERRCLASS & ERRCLS_ADD_RES)
1656       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1657             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1658             (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
1659 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1660       RETVALUE(ret1);
1661    }
1662
1663    if (cmUnpkPjUdxUeInfo(ueInfo, mBuf) != ROK) {
1664       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1665       PJ_FREE_BUF(mBuf);
1666 #if (ERRCLASS & ERRCLS_ADD_RES)
1667       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1668          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1669          (ErrVal)ECPJ089, (ErrVal)0, "Packing failed");
1670 #endif
1671       RETVALUE(RFAILED);
1672    }
1673    if (cmUnpkCmStatus(&status, mBuf) != ROK) {
1674       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, ueInfo, sizeof(UdxUeInfo));
1675       PJ_FREE_BUF(mBuf);
1676 #if (ERRCLASS & ERRCLS_ADD_RES)
1677       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1678          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1679          (ErrVal)ECPJ090, (ErrVal)0, "Packing failed");
1680 #endif
1681       RETVALUE(RFAILED);
1682    }
1683    PJ_FREE_BUF(mBuf);
1684    RETVALUE((*func)(pst, suId, transId, ueInfo, status));
1685 }
1686
1687 #ifdef ANSI
1688 PUBLIC S16 cmPkPjUdxCountReq
1689 (
1690 Pst * pst,
1691 SpId spId,
1692 UdxCountReqInfo * countReq
1693 )
1694 #else
1695 PUBLIC S16 cmPkPjUdxCountReq(pst, spId, countReq)
1696 Pst * pst;
1697 SpId spId;
1698 UdxCountReqInfo * countReq;
1699 #endif
1700 {
1701    Buffer *mBuf = NULLP;
1702    TRC3(cmPkPjUdxCountReq)
1703
1704    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1705 #if (ERRCLASS & ERRCLS_ADD_RES)
1706       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1707          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1708          (ErrVal)EUDX091, (ErrVal)0, "Packing failed");
1709 #endif
1710       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countReq, sizeof(UdxCountReqInfo));
1711       RETVALUE(RFAILED);
1712    }
1713
1714    switch(pst->selector)
1715    {
1716 #ifdef LCUDX
1717            case UDX_SEL_LC:
1718                    {
1719
1720                            if (cmPkPjUdxCountReqInfo(countReq, mBuf) != ROK) {
1721 #if (ERRCLASS & ERRCLS_ADD_RES)
1722                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1723                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1724                                                    (ErrVal)EUDX092, (ErrVal)0, "Packing failed");
1725 #endif
1726                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countReq, sizeof(UdxCountReqInfo));
1727                                    PJ_FREE_BUF(mBuf);
1728                                    RETVALUE(RFAILED);
1729                            }
1730                            /* Free Request Structure after packing */
1731                            PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countReq, sizeof(UdxCountReqInfo));
1732                            break;
1733                    }
1734            case UDX_SEL_LWLC:
1735                    {
1736                            CMCHKPKLOG(cmPkPtr,(PTR)countReq,mBuf,EUDXXXX,pst);
1737                            break;
1738                    }
1739 #endif /* LCUDX */
1740    }
1741
1742    if (SPkS16(spId, mBuf) != ROK) {
1743 #if (ERRCLASS & ERRCLS_ADD_RES)
1744       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1745          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1746          (ErrVal)EUDX094, (ErrVal)0, "Packing failed");
1747 #endif
1748       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countReq, sizeof(UdxCountReqInfo));
1749       PJ_FREE_BUF(mBuf);
1750       RETVALUE(RFAILED);
1751    }
1752
1753    pst->event = (Event) EVTUDXCOUNTREQ;
1754    RETVALUE(SPstTsk(pst,mBuf));
1755 }
1756
1757 #ifdef ANSI
1758 PUBLIC S16 cmUnpkPjUdxCountReq
1759 (
1760 UdxCountReq func,
1761 Pst *pst,
1762 Buffer *mBuf
1763 )
1764 #else
1765 PUBLIC S16 cmUnpkPjUdxCountReq(func, pst, mBuf)
1766 UdxCountReq func;
1767 Pst *pst;
1768 Buffer *mBuf;
1769 #endif
1770 {
1771    S16   ret1;
1772    SpId spId;
1773    UdxCountReqInfo *countReq;
1774
1775    TRC3(cmUnpkPjUdxCountReq)
1776
1777    if (SUnpkS16(&spId, mBuf) != ROK) {
1778       PJ_FREE_BUF(mBuf);
1779 #if (ERRCLASS & ERRCLS_ADD_RES)
1780       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1781          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1782          (ErrVal)EUDX096, (ErrVal)0, "Packing failed");
1783 #endif
1784       RETVALUE(RFAILED);
1785    }
1786    switch(pst->selector)
1787    {
1788 #ifdef LCUDX
1789            case UDX_SEL_LC:
1790                    {
1791
1792                            if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&countReq,\
1793                                                            sizeof(UdxCountReqInfo))) != ROK)
1794                            {
1795 #if (ERRCLASS & ERRCLS_ADD_RES)
1796                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1797                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1798                                                    (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
1799 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1800                                    RETVALUE(ret1);
1801                            }
1802
1803                            if (cmUnpkPjUdxCountReqInfo(countReq, mBuf) != ROK) {
1804                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countReq, sizeof(UdxCountReqInfo));
1805                                    PJ_FREE_BUF(mBuf);
1806 #if (ERRCLASS & ERRCLS_ADD_RES)
1807                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1808                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1809                                                    (ErrVal)EUDX098, (ErrVal)0, "Packing failed");
1810 #endif
1811                                    RETVALUE(RFAILED);
1812                            }
1813                            break;
1814                    }
1815            case UDX_SEL_LWLC:
1816                    {
1817                            CMCHKUNPK(cmUnpkPtr,(PTR *) &countReq,mBuf);
1818                            break;
1819                    }
1820 #endif /* LCUDX */
1821 }
1822
1823 PJ_FREE_BUF(mBuf);
1824    RETVALUE((*func)(pst, spId, countReq));
1825 }
1826
1827
1828 #ifdef ANSI
1829 PUBLIC S16 cmPkPjUdxCountCfm
1830 (
1831 Pst * pst,
1832 SuId suId,
1833 UdxCountCfmInfo * countCfm
1834 )
1835 #else
1836 PUBLIC S16 cmPkPjUdxCountCfm(pst, suId, countCfm)
1837 Pst * pst;
1838 SuId suId;
1839 UdxCountCfmInfo * countCfm;
1840 #endif
1841 {
1842    Buffer *mBuf = NULLP;
1843    TRC3(cmPkPjUdxCountCfm)
1844
1845    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1846 #if (ERRCLASS & ERRCLS_ADD_RES)
1847       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1848          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1849          (ErrVal)ECPJ099, (ErrVal)0, "Packing failed");
1850 #endif
1851       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countCfm, sizeof(UdxCountCfmInfo));
1852       RETVALUE(RFAILED);
1853    }
1854    switch(pst->selector)
1855    {
1856 #ifdef LCUDX
1857            case UDX_SEL_LC:
1858                    {
1859
1860    if (cmPkPjUdxCountCfmInfo(countCfm, mBuf) != ROK) {
1861 #if (ERRCLASS & ERRCLS_ADD_RES)
1862          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1863             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1864             (ErrVal)ECPJ100, (ErrVal)0, "Packing failed");
1865 #endif
1866          PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countCfm, sizeof(UdxCountCfmInfo));
1867          PJ_FREE_BUF(mBuf);
1868          RETVALUE(RFAILED);
1869     }
1870    /* Free Confirm Structure after packing */
1871    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countCfm, sizeof(UdxCountCfmInfo));
1872
1873    break;
1874   }
1875   case UDX_SEL_LWLC:
1876                    {
1877                            CMCHKPKLOG(cmPkPtr,(PTR)countCfm,mBuf,EUDXXXX,pst);
1878                            break;
1879                    }
1880 #endif /* LCUDX */
1881    }
1882
1883    if (SPkS16(suId, mBuf) != ROK) {
1884 #if (ERRCLASS & ERRCLS_ADD_RES)
1885       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1886          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1887          (ErrVal)ECPJ102, (ErrVal)0, "Packing failed");
1888 #endif
1889       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countCfm, sizeof(UdxCountCfmInfo));
1890       PJ_FREE_BUF(mBuf);
1891       RETVALUE(RFAILED);
1892    }
1893
1894    pst->event = (Event) EVTCPJCOUNTCFM;
1895    RETVALUE(SPstTsk(pst,mBuf));
1896 }
1897
1898 #ifdef ANSI
1899 PUBLIC S16 cmUnpkPjUdxCountCfm
1900 (
1901 UdxCountCfm func,
1902 Pst *pst,
1903 Buffer *mBuf
1904 )
1905 #else
1906 PUBLIC S16 cmUnpkPjUdxCountCfm(func, pst, mBuf)
1907 UdxCountCfm func;
1908 Pst *pst;
1909 Buffer *mBuf;
1910 #endif
1911 {
1912    S16   ret1;
1913    SuId suId;
1914    UdxCountCfmInfo *countCfm = NULLP;
1915
1916    TRC3(cmUnpkPjUdxCountCfm)
1917
1918    if (SUnpkS16(&suId, mBuf) != ROK) {
1919       PJ_FREE_BUF(mBuf);
1920 #if (ERRCLASS & ERRCLS_ADD_RES)
1921       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1922          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1923          (ErrVal)ECPJ104, (ErrVal)0, "Packing failed");
1924 #endif
1925       RETVALUE(RFAILED);
1926    }
1927
1928    switch(pst->selector)
1929    {
1930 #ifdef LCUDX
1931            case UDX_SEL_LC:
1932                    {
1933
1934
1935    if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&countCfm,\
1936                sizeof(UdxCountCfmInfo))) != ROK)
1937    {
1938 #if (ERRCLASS & ERRCLS_ADD_RES)
1939       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1940             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1941             (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
1942 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1943       RETVALUE(ret1);
1944    }
1945
1946    if (cmUnpkPjUdxCountCfmInfo(countCfm, mBuf) != ROK) {
1947       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, countCfm, sizeof(UdxCountCfmInfo));
1948       PJ_FREE_BUF(mBuf);
1949 #if (ERRCLASS & ERRCLS_ADD_RES)
1950       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1951          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1952          (ErrVal)ECPJ106, (ErrVal)0, "Packing failed");
1953 #endif
1954       RETVALUE(RFAILED);
1955    }
1956          break;
1957                    }
1958            case UDX_SEL_LWLC:
1959                    {
1960                            CMCHKUNPK(cmUnpkPtr,(PTR *) &countCfm,mBuf);
1961                            break;
1962                    }
1963 #endif /* LCUDX */
1964 }
1965
1966 PJ_FREE_BUF(mBuf);
1967    RETVALUE((*func)(pst, suId, countCfm));
1968 }
1969
1970
1971 #ifdef ANSI
1972 PUBLIC S16 cmPkPjUdxSduStaReq
1973 (
1974 Pst * pst,
1975 SpId spId,
1976 UdxSduStaReqInfo * staReq
1977 )
1978 #else
1979 PUBLIC S16 cmPkPjUdxSduStaReq(pst, spId, staReq)
1980 Pst * pst;
1981 SpId spId;
1982 UdxSduStaReqInfo * staReq;
1983 #endif
1984 {
1985    Buffer *mBuf = NULLP;
1986    TRC3(cmPkPjUdxSduStaReq)
1987
1988    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1989 #if (ERRCLASS & ERRCLS_ADD_RES)
1990       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1991          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1992          (ErrVal)EUDX107, (ErrVal)0, "Packing failed");
1993 #endif
1994       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staReq, sizeof(UdxSduStaReqInfo));
1995       RETVALUE(RFAILED);
1996    }
1997
1998    switch(pst->selector)
1999    {
2000 #ifdef LCUDX
2001            case UDX_SEL_LC:
2002                    {
2003
2004                            if (cmPkPjUdxSduStaReqInfo(staReq, mBuf) != ROK) {
2005 #if (ERRCLASS & ERRCLS_ADD_RES)
2006                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2007                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2008                                                    (ErrVal)EUDX108, (ErrVal)0, "Packing failed");
2009 #endif
2010                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staReq, sizeof(UdxSduStaReqInfo));
2011                                    PJ_FREE_BUF(mBuf);
2012                                    RETVALUE(RFAILED);
2013                            }
2014                            /* Free Request Structure after packing */
2015                            PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staReq, sizeof(UdxSduStaReqInfo));
2016
2017
2018                            break;
2019                    }
2020            case UDX_SEL_LWLC:
2021                    {
2022                            CMCHKPKLOG(cmPkPtr,(PTR)staReq,mBuf,EUDXXXX,pst);
2023                            break;
2024                    }
2025 #endif /* LCUDX */
2026 }
2027    if (SPkS16(spId, mBuf) != ROK) {
2028 #if (ERRCLASS & ERRCLS_ADD_RES)
2029       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2030          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2031          (ErrVal)EUDX110, (ErrVal)0, "Packing failed");
2032 #endif
2033       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staReq, sizeof(UdxSduStaReqInfo));
2034       PJ_FREE_BUF(mBuf);
2035       RETVALUE(RFAILED);
2036    }
2037
2038    pst->event = (Event) EVTUDXSDUSTAREQ;
2039    RETVALUE(SPstTsk(pst,mBuf));
2040 }
2041
2042 #ifdef ANSI
2043 PUBLIC S16 cmUnpkPjUdxSduStaReq
2044 (
2045 UdxSduStaReq func,
2046 Pst *pst,
2047 Buffer *mBuf
2048 )
2049 #else
2050 PUBLIC S16 cmUnpkPjUdxSduStaReq(func, pst, mBuf)
2051 UdxSduStaReq func;
2052 Pst *pst;
2053 Buffer *mBuf;
2054 #endif
2055 {
2056    S16   ret1;
2057    SpId spId;
2058    UdxSduStaReqInfo *staReq;
2059
2060    TRC3(cmUnpkPjUdxSduStaReq)
2061
2062    if (SUnpkS16(&spId, mBuf) != ROK) {
2063       PJ_FREE_BUF(mBuf);
2064 #if (ERRCLASS & ERRCLS_ADD_RES)
2065       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2066          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2067          (ErrVal)EUDX112, (ErrVal)0, "Packing failed");
2068 #endif
2069       RETVALUE(RFAILED);
2070    }
2071    switch(pst->selector)
2072    {
2073 #ifdef LCUDX
2074            case UDX_SEL_LC:
2075                    {
2076
2077                            if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&staReq,\
2078                                                            sizeof(UdxSduStaReqInfo))) != ROK)
2079                            {
2080 #if (ERRCLASS & ERRCLS_ADD_RES)
2081                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2082                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2083                                                    (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
2084 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2085                                    RETVALUE(ret1);
2086                            }
2087
2088                            if (cmUnpkPjUdxSduStaReqInfo(staReq, mBuf) != ROK) {
2089                                    PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staReq, sizeof(UdxSduStaReqInfo));
2090                                    PJ_FREE_BUF(mBuf);
2091 #if (ERRCLASS & ERRCLS_ADD_RES)
2092                                    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2093                                                    __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2094                                                    (ErrVal)EUDX114, (ErrVal)0, "Packing failed");
2095 #endif
2096                                    RETVALUE(RFAILED);
2097                            }
2098                            break;
2099                    }
2100            case UDX_SEL_LWLC:
2101                    {
2102                            CMCHKUNPK(cmUnpkPtr,(PTR *) &staReq,mBuf);
2103                            break;
2104                    }
2105 #endif /* LCUDX */
2106 }
2107 PJ_FREE_BUF(mBuf);
2108    RETVALUE((*func)(pst, spId, staReq));
2109 }
2110
2111
2112 #ifdef ANSI
2113 PUBLIC S16 cmPkPjUdxSduStaCfm
2114 (
2115  Pst * pst,
2116  SuId suId,
2117  UdxSduStaCfmInfo * staCfm
2118  )
2119 #else
2120 PUBLIC S16 cmPkPjUdxSduStaCfm(pst, suId, staCfm)
2121         Pst * pst;
2122         SuId suId;
2123         UdxSduStaCfmInfo * staCfm;
2124 #endif
2125 {
2126         Buffer *mBuf = NULLP;
2127         TRC3(cmPkPjUdxSduStaCfm)
2128
2129                 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2130 #if (ERRCLASS & ERRCLS_ADD_RES)
2131                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2132                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2133                                         (ErrVal)ECPJ115, (ErrVal)0, "Packing failed");
2134 #endif
2135                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staCfm, sizeof(UdxSduStaCfmInfo));
2136                         RETVALUE(RFAILED);
2137                 }
2138         switch(pst->selector)
2139         {
2140 #ifdef LCUDX
2141                 case UDX_SEL_LC:
2142                         {
2143
2144
2145                                 if (cmPkPjUdxSduStaCfmInfo(pst, staCfm, mBuf) != ROK) {
2146 #if (ERRCLASS & ERRCLS_ADD_RES)
2147                                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2148                                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2149                                                         (ErrVal)ECPJ116, (ErrVal)0, "Packing failed");
2150 #endif
2151                                         PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staCfm, sizeof(UdxSduStaCfmInfo));
2152                                         PJ_FREE_BUF(mBuf);
2153                                         RETVALUE(RFAILED);
2154                                 }
2155                                 break;
2156                         }
2157                 case UDX_SEL_LWLC:
2158                         {
2159                                 CMCHKPKLOG(cmPkPtr,(PTR)staCfm,mBuf,EUDXXXX,pst);
2160                                 break;
2161                         }
2162 #endif /* LCUDX */
2163         }
2164
2165         if (SPkS16(suId, mBuf) != ROK) {
2166 #if (ERRCLASS & ERRCLS_ADD_RES)
2167                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2168                                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2169                                 (ErrVal)ECPJ118, (ErrVal)0, "Packing failed");
2170 #endif
2171                 PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staCfm, sizeof(UdxSduStaCfmInfo));
2172                 PJ_FREE_BUF(mBuf);
2173                 RETVALUE(RFAILED);
2174         }
2175
2176         /* Free Confirm Structure after packing */
2177         /*SPutSBuf(pst->region, pst->pool, (Data *)staCfm, sizeof(UdxSduStaCfmInfo));*/
2178
2179         pst->event = (Event) EVTUDXSDUSTACFM;
2180         RETVALUE(SPstTsk(pst,mBuf));
2181 }
2182
2183 #ifdef ANSI
2184 PUBLIC S16 cmUnpkPjUdxSduStaCfm
2185 (
2186  UdxSduStaCfm func,
2187  Pst *pst,
2188  Buffer *mBuf
2189  )
2190 #else
2191 PUBLIC S16 cmUnpkPjUdxSduStaCfm(func, pst, mBuf)
2192         UdxSduStaCfm func;
2193         Pst *pst;
2194         Buffer *mBuf;
2195 #endif
2196 {
2197         S16   ret1;
2198         SuId suId;
2199         UdxSduStaCfmInfo *staCfm;
2200
2201         TRC3(cmUnpkPjUdxSduStaCfm)
2202
2203                 if (SUnpkS16(&suId, mBuf) != ROK) {
2204                    PJ_FREE_BUF(mBuf);
2205 #if (ERRCLASS & ERRCLS_ADD_RES)
2206                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2207                                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2208                                         (ErrVal)ECPJ120, (ErrVal)0, "Packing failed");
2209 #endif
2210                         RETVALUE(RFAILED);
2211                 }
2212         switch(pst->selector)
2213         {
2214 #ifdef LCUDX
2215                 case UDX_SEL_LC:
2216                 {
2217                     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&staCfm,\
2218                                         sizeof(UdxSduStaCfmInfo))) != ROK)
2219                     {
2220 #if (ERRCLASS & ERRCLS_ADD_RES)
2221                         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2222                                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2223                                  (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
2224 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2225                         RETVALUE(ret1);
2226                     }
2227
2228                     if (cmUnpkPjUdxSduStaCfmInfo(pst, staCfm, mBuf) != ROK) {
2229                             PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staCfm, sizeof(UdxSduStaCfmInfo));
2230                             PJ_FREE_BUF(mBuf);
2231 #if (ERRCLASS & ERRCLS_ADD_RES)
2232                             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2233                                             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2234                                             (ErrVal)ECPJ122, (ErrVal)0, "Packing failed");
2235 #endif
2236                             RETVALUE(RFAILED);
2237                     }
2238                 }
2239                 break;
2240
2241                 case UDX_SEL_LWLC:
2242                 {
2243                         CMCHKUNPK(cmUnpkPtr,(PTR *) &staCfm,mBuf);
2244                 }
2245                 break;
2246         }
2247 #endif /* LCUDX */
2248
2249
2250         PJ_FREE_BUF(mBuf);
2251         RETVALUE((*func)(pst, suId, staCfm));
2252 }
2253
2254 #ifdef ANSI
2255 PUBLIC S16 cmPkPjUdxDatResumeCfm
2256 (
2257  Pst * pst,
2258  SuId suId,
2259  UdxDatResumeCfmInfo * datResumeCfm
2260  )
2261 #else
2262 PUBLIC S16 cmPkPjUdxDatResumeCfm(pst, suId, datResumeCfm)
2263    Pst * pst;
2264    SuId suId;
2265    UdxDatResumeCfmInfo * datResumeCfm;
2266 #endif
2267 {
2268    Buffer *mBuf = NULLP;
2269    TRC3(cmPkPjUdxDatResumeCfm)
2270
2271    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2272 #if (ERRCLASS & ERRCLS_ADD_RES)
2273       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2274             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2275             (ErrVal)ECPJ115, (ErrVal)0, "Packing failed");
2276 #endif
2277       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datResumeCfm, sizeof(UdxDatResumeCfmInfo));
2278       RETVALUE(RFAILED);
2279    }
2280    switch(pst->selector)
2281    {
2282 #ifdef LCUDX
2283       case UDX_SEL_LC:
2284          {
2285             if (cmPkPjUdxDatResumeCfmInfo(pst, datResumeCfm, mBuf) != ROK) {
2286 #if (ERRCLASS & ERRCLS_ADD_RES)
2287                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2288                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2289                      (ErrVal)ECPJ116, (ErrVal)0, "Packing failed");
2290 #endif
2291                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datResumeCfm, sizeof(UdxDatResumeCfmInfo));
2292                PJ_FREE_BUF(mBuf);
2293                RETVALUE(RFAILED);
2294             }
2295             break;
2296          }
2297       case UDX_SEL_LWLC:
2298          {
2299             CMCHKPKLOG(cmPkPtr,(PTR)datResumeCfm,mBuf,EUDXXXX,pst);
2300             break;
2301          }
2302 #endif /* LCUDX */
2303    }
2304
2305    if (SPkS16(suId, mBuf) != ROK) {
2306 #if (ERRCLASS & ERRCLS_ADD_RES)
2307       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2308             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2309             (ErrVal)ECPJ118, (ErrVal)0, "Packing failed");
2310 #endif
2311       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datResumeCfm, sizeof(UdxDatResumeCfmInfo));
2312       PJ_FREE_BUF(mBuf);
2313       RETVALUE(RFAILED);
2314    }
2315
2316    /* Free Confirm Structure after packing */
2317    /*SPutSBuf(pst->region, pst->pool, (Data *)datResumeCfm, sizeof(UdxSduStaCfmInfo));*/
2318
2319    pst->event = (Event) EVTUDXDATRESUMECFM;
2320    RETVALUE(SPstTsk(pst,mBuf));
2321 }
2322
2323 /*
2324 *
2325 *    Fun:    cmPkPjUdxDatForwardCfm
2326 *
2327 *    Ret:    ROK  -ok
2328 *
2329 *    Notes:  None
2330 *
2331 *
2332 */
2333 #ifdef ANSI
2334 PUBLIC S16 cmPkPjUdxDatForwardCfm
2335 (
2336  Pst * pst,
2337  SuId suId,
2338  UdxDatFwdCfmInfo  * datFwdCfm
2339  )
2340 #else
2341 PUBLIC S16 cmPkPjUdxDatForwardCfm(pst, suId, datFwdCfm)
2342    Pst * pst;
2343    SuId suId;
2344    UdxDatFwdCfmInfo  * datFwdCfm;
2345 #endif
2346 {
2347
2348    Buffer *mBuf = NULLP;
2349    TRC3(cmPkPjUdxDatForwardCfm)
2350
2351    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2352 #if (ERRCLASS & ERRCLS_ADD_RES)
2353       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2354             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2355             (ErrVal)ECPJ115, (ErrVal)0, "Packing failed");
2356 #endif
2357       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datFwdCfm, sizeof(UdxDatFwdCfmInfo));
2358       RETVALUE(RFAILED);
2359    }
2360
2361    switch(pst->selector)
2362    {
2363 #ifdef LCUDX
2364       case UDX_SEL_LC:
2365          {
2366             if (cmPkPjUdxDatForwardCfmInfo(pst, datFwdCfm, mBuf) != ROK) {
2367 #if (ERRCLASS & ERRCLS_ADD_RES)
2368                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2369                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2370                      (ErrVal)ECPJ116, (ErrVal)0, "Packing failed");
2371 #endif
2372                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datFwdCfm, sizeof(UdxDatFwdCfmInfo));
2373                PJ_FREE_BUF(mBuf);
2374                RETVALUE(RFAILED);
2375             }
2376             break;
2377          }
2378       case UDX_SEL_LWLC:
2379          {
2380             CMCHKPKLOG(cmPkPtr,(PTR)datFwdCfm,mBuf,EUDXXXX,pst);
2381             break;
2382          }
2383 #endif /* LCUDX */
2384    }
2385
2386    if (SPkS16(suId, mBuf) != ROK) {
2387 #if (ERRCLASS & ERRCLS_ADD_RES)
2388       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2389             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2390             (ErrVal)ECPJ118, (ErrVal)0, "Packing failed");
2391 #endif
2392       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datFwdCfm, sizeof(UdxDatFwdCfmInfo));
2393       PJ_FREE_BUF(mBuf);
2394       RETVALUE(RFAILED);
2395    }
2396
2397    /* Free Confirm Structure after packing */
2398    /*SPutSBuf(pst->region, pst->pool, (Data *)datFwdCfm, sizeof(UdxDatFwdCfmInfo));*/
2399
2400    pst->event = (Event) EVTUDXDATFRWDCFM;
2401    RETVALUE(SPstTsk(pst,mBuf));
2402 }
2403
2404 #ifdef ANSI
2405 PUBLIC S16 cmUnpkPjUdxDatResumeCfm
2406 (
2407  UdxDatResumeCfm func,
2408  Pst *pst,
2409  Buffer *mBuf
2410  )
2411 #else
2412 PUBLIC S16 cmUnpkPjUdxDatResumeCfm(func, pst, mBuf)
2413    UdxDatResumeCfm func;
2414    Pst *pst;
2415    Buffer *mBuf;
2416 #endif
2417 {
2418    S16   ret1;
2419    SuId suId;
2420    UdxDatResumeCfmInfo *datResumeCfm = NULLP;
2421
2422    TRC3(cmUnpkPjUdxDatResumeCfm)
2423
2424    RLOG0(L_DEBUG," Unpacking UdxDatResumeCfm");
2425    if (SUnpkS16(&suId, mBuf) != ROK) {
2426       PJ_FREE_BUF(mBuf);
2427 #if (ERRCLASS & ERRCLS_ADD_RES)
2428       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2429             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2430             (ErrVal)ECPJ120, (ErrVal)0, "Packing failed");
2431 #endif
2432       RETVALUE(RFAILED);
2433    }
2434    switch(pst->selector)
2435    {
2436 #ifdef LCUDX
2437       case UDX_SEL_LC:
2438          {
2439             if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&datResumeCfm,\
2440                         sizeof(UdxDatResumeCfmInfo))) != ROK)
2441             {
2442 #if (ERRCLASS & ERRCLS_ADD_RES)
2443                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2444                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2445                      (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
2446 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2447                RETVALUE(ret1);
2448             }
2449
2450             if (cmUnpkPjUdxDatResumeCfmInfo(pst, datResumeCfm, mBuf) != ROK) {
2451                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datResumeCfm, sizeof(UdxDatResumeCfmInfo));
2452                PJ_FREE_BUF(mBuf);
2453 #if (ERRCLASS & ERRCLS_ADD_RES)
2454                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2455                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2456                      (ErrVal)ECPJ122, (ErrVal)0, "Packing failed");
2457 #endif
2458                RETVALUE(RFAILED);
2459             }
2460          }
2461          break;
2462
2463       case UDX_SEL_LWLC:
2464          {
2465             CMCHKUNPK(cmUnpkPtr,(PTR *) &datResumeCfm,mBuf);
2466          }
2467          break;
2468    }
2469 #endif /* LCUDX */
2470
2471
2472    PJ_FREE_BUF(mBuf);
2473    RETVALUE((*func)(pst, suId, datResumeCfm));
2474 }
2475
2476 #ifdef ANSI
2477 PUBLIC S16 cmUnpkPjUdxDatForwardCfm
2478 (
2479  UdxDatForwardCfm func,
2480  Pst *pst,
2481  Buffer *mBuf
2482  )
2483 #else
2484 PUBLIC S16 cmUnpkPjUdxDatForwardCfm(func, pst, mBuf)
2485    UdxDatForwardCfm func;
2486    Pst *pst;
2487    Buffer *mBuf;
2488 #endif
2489 {
2490    S16   ret1;
2491    SuId suId;
2492    UdxDatFwdCfmInfo *datFwdCfm;
2493
2494    TRC3(cmUnpkPjUdxDatForwardCfm)
2495
2496    if (SUnpkS16(&suId, mBuf) != ROK) {
2497       PJ_FREE_BUF(mBuf);
2498 #if (ERRCLASS & ERRCLS_ADD_RES)
2499       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2500             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2501             (ErrVal)ECPJ120, (ErrVal)0, "Packing failed");
2502 #endif
2503       RETVALUE(RFAILED);
2504    }
2505    switch(pst->selector)
2506    {
2507 #ifdef LCUDX
2508       case UDX_SEL_LC:
2509          {
2510             if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&datFwdCfm,\
2511                         sizeof(UdxDatFwdCfmInfo))) != ROK)
2512             {
2513 #if (ERRCLASS & ERRCLS_ADD_RES)
2514                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2515                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2516                      (ErrVal)ECPJ040, (ErrVal)0, "SGetMsg() failed");
2517 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2518                RETVALUE(ret1);
2519             }
2520
2521             if (cmUnpkPjUdxDatForwardCfmInfo(pst, datFwdCfm, mBuf) != ROK) {
2522                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, datFwdCfm, sizeof(UdxDatFwdCfmInfo));
2523                PJ_FREE_BUF(mBuf);
2524 #if (ERRCLASS & ERRCLS_ADD_RES)
2525                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2526                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2527                      (ErrVal)ECPJ122, (ErrVal)0, "Packing failed");
2528 #endif
2529                RETVALUE(RFAILED);
2530             }
2531          }
2532          break;
2533
2534       case UDX_SEL_LWLC:
2535          {
2536             CMCHKUNPK(cmUnpkPtr,(PTR *) &datFwdCfm,mBuf);
2537          }
2538          break;
2539    }
2540 #endif /* LCUDX */
2541
2542    PJ_FREE_BUF(mBuf);
2543    RETVALUE((*func)(pst, suId, datFwdCfm));
2544 }
2545
2546
2547 \f
2548 /***********************************************************
2549 *
2550 *     Func : cmPkPjUdxRlcAm
2551 *
2552 *
2553 *     Desc :  * RLC parameter information in AM mode.
2554 *
2555 *
2556 *     Ret  : S16
2557 *
2558 *     Notes:
2559 *
2560 *     File  :
2561 *
2562 **********************************************************/
2563 #ifdef ANSI
2564 PUBLIC S16 cmPkPjUdxRlcAm
2565 (
2566 UdxRlcAm *param,
2567 Buffer *mBuf
2568 )
2569 #else
2570 PUBLIC S16 cmPkPjUdxRlcAm(param, mBuf)
2571 UdxRlcAm *param;
2572 Buffer *mBuf;
2573 #endif
2574 {
2575
2576    TRC3(cmPkPjUdxRlcAm)
2577
2578    CMCHKPK(SPkU8, param->statusRepReqd, mBuf);
2579    RETVALUE(ROK);
2580 }
2581
2582
2583 \f
2584 /***********************************************************
2585 *
2586 *     Func : cmUnpkPjUdxRlcAm
2587 *
2588 *
2589 *     Desc :  * RLC parameter information in AM mode.
2590 *
2591 *
2592 *     Ret  : S16
2593 *
2594 *     Notes:
2595 *
2596 *     File  :
2597 *
2598 **********************************************************/
2599 #ifdef ANSI
2600 PUBLIC S16 cmUnpkPjUdxRlcAm
2601 (
2602 UdxRlcAm *param,
2603 Buffer *mBuf
2604 )
2605 #else
2606 PUBLIC S16 cmUnpkPjUdxRlcAm(param, mBuf)
2607 UdxRlcAm *param;
2608 Buffer *mBuf;
2609 #endif
2610 {
2611
2612    TRC3(cmUnpkPjUdxRlcAm)
2613
2614    CMCHKUNPK(SUnpkU8, &param->statusRepReqd, mBuf);
2615    RETVALUE(ROK);
2616 }
2617
2618
2619 \f
2620 /***********************************************************
2621 *
2622 *     Func : cmPkPjUdxRlcUm
2623 *
2624 *
2625 *     Desc : * RLC parameter information in UM mode.
2626 *
2627 *
2628 *     Ret  : S16
2629 *
2630 *     Notes:
2631 *
2632 *     File  :
2633 *
2634 **********************************************************/
2635 #ifdef ANSI
2636 PUBLIC S16 cmPkPjUdxRlcUm
2637 (
2638 UdxRlcUm *param,
2639 Buffer *mBuf
2640 )
2641 #else
2642 PUBLIC S16 cmPkPjUdxRlcUm(param, mBuf)
2643 UdxRlcUm *param;
2644 Buffer *mBuf;
2645 #endif
2646 {
2647
2648    TRC3(cmPkPjUdxRlcUm)
2649
2650    CMCHKPK(SPkU8, param->pdcpSNSize, mBuf);
2651    RETVALUE(ROK);
2652 }
2653
2654
2655 \f
2656 /***********************************************************
2657 *
2658 *     Func : cmUnpkPjUdxRlcUm
2659 *
2660 *
2661 *     Desc : * RLC parameter information in UM mode.
2662 *
2663 *
2664 *     Ret  : S16
2665 *
2666 *     Notes:
2667 *
2668 *     File  :
2669 *
2670 **********************************************************/
2671 #ifdef ANSI
2672 PUBLIC S16 cmUnpkPjUdxRlcUm
2673 (
2674 UdxRlcUm *param,
2675 Buffer *mBuf
2676 )
2677 #else
2678 PUBLIC S16 cmUnpkPjUdxRlcUm(param, mBuf)
2679 UdxRlcUm *param;
2680 Buffer *mBuf;
2681 #endif
2682 {
2683
2684    TRC3(cmUnpkPjUdxRlcUm)
2685
2686    CMCHKUNPK(SUnpkU8, &param->pdcpSNSize, mBuf);
2687    RETVALUE(ROK);
2688 }
2689
2690
2691 \f
2692 /***********************************************************
2693 *
2694 *     Func : cmPkPjUdxRlcInfo
2695 *
2696 *
2697 *     Desc : * Mapped RLC entity information in RLC for the PDCP entity
2698 *
2699 *
2700 *     Ret  : S16
2701 *
2702 *     Notes:
2703 *
2704 *     File  :
2705 *
2706 **********************************************************/
2707 #ifdef ANSI
2708 PUBLIC S16 cmPkPjUdxRlcInfo
2709 (
2710 UdxRlcInfo *param,
2711 Buffer *mBuf
2712 )
2713 #else
2714 PUBLIC S16 cmPkPjUdxRlcInfo(param, mBuf)
2715 UdxRlcInfo *param;
2716 Buffer *mBuf;
2717 #endif
2718 {
2719
2720    TRC3(cmPkPjUdxRlcInfo)
2721
2722       switch(param->mode) {
2723          case CM_LTE_MODE_UM:
2724             CMCHKPK(cmPkPjUdxRlcUm, &param->m.rlcUm, mBuf);
2725             break;
2726          case CM_LTE_MODE_AM:
2727             CMCHKPK(cmPkPjUdxRlcAm, &param->m.rlcAm, mBuf);
2728             break;
2729          default :
2730             RETVALUE(RFAILED);
2731       }
2732    CMCHKPK(SPkU8, param->mode, mBuf);
2733    CMCHKPK(SPkU8, param->dir, mBuf);
2734    RETVALUE(ROK);
2735 }
2736
2737
2738 \f
2739 /***********************************************************
2740 *
2741 *     Func : cmUnpkPjUdxRlcInfo
2742 *
2743 *
2744 *     Desc : * Mapped RLC entity information in RLC for the PDCP entity
2745 *
2746 *
2747 *     Ret  : S16
2748 *
2749 *     Notes:
2750 *
2751 *     File  :
2752 *
2753 **********************************************************/
2754 #ifdef ANSI
2755 PUBLIC S16 cmUnpkPjUdxRlcInfo
2756 (
2757 UdxRlcInfo *param,
2758 Buffer *mBuf
2759 )
2760 #else
2761 PUBLIC S16 cmUnpkPjUdxRlcInfo(param, mBuf)
2762 UdxRlcInfo *param;
2763 Buffer *mBuf;
2764 #endif
2765 {
2766
2767    TRC3(cmUnpkPjUdxRlcInfo)
2768
2769    CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
2770    CMCHKUNPK(SUnpkU8, &param->mode, mBuf);
2771       switch(param->mode) {
2772          case CM_LTE_MODE_AM:
2773             CMCHKUNPK(cmUnpkPjUdxRlcAm, &param->m.rlcAm, mBuf);
2774             break;
2775          case CM_LTE_MODE_UM:
2776             CMCHKUNPK(cmUnpkPjUdxRlcUm, &param->m.rlcUm, mBuf);
2777             break;
2778          default :
2779             RETVALUE(RFAILED);
2780       }
2781    RETVALUE(ROK);
2782 }
2783
2784
2785 \f
2786 /***********************************************************
2787 *
2788 *     Func : cmPkPjUdxCipherInfo
2789 *
2790 *
2791 *     Desc : * Ciphering information to be configured per UE in PDCP.
2792 *
2793 *
2794 *     Ret  : S16
2795 *
2796 *     Notes:
2797 *
2798 *     File  :
2799 *
2800 **********************************************************/
2801 #ifdef ANSI
2802 PUBLIC S16 cmPkPjUdxCipherInfo
2803 (
2804 UdxCipherInfo *param,
2805 Buffer *mBuf
2806 )
2807 #else
2808 PUBLIC S16 cmPkPjUdxCipherInfo(param, mBuf)
2809 UdxCipherInfo *param;
2810 Buffer *mBuf;
2811 #endif
2812 {
2813
2814    S32 i;
2815    TRC3(cmPkPjUdxCipherInfo)
2816
2817    CMCHKPK(SPkU8, param->algoType, mBuf);
2818    for (i=UDX_CIPHER_KEY_LEN-1; i >= 0; i--) {
2819       CMCHKPK(SPkU8, param->usrplnKey[i], mBuf);
2820    }
2821    for (i=UDX_CIPHER_KEY_LEN-1; i >= 0; i--) {
2822       CMCHKPK(SPkU8, param->ctrlplnKey[i], mBuf);
2823    }
2824    RETVALUE(ROK);
2825 }
2826
2827
2828 \f
2829 /***********************************************************
2830 *
2831 *     Func : cmUnpkPjUdxCipherInfo
2832 *
2833 *
2834 *     Desc : * Ciphering information to be configured per UE in PDCP.
2835 *
2836 *
2837 *     Ret  : S16
2838 *
2839 *     Notes:
2840 *
2841 *     File  :
2842 *
2843 **********************************************************/
2844 #ifdef ANSI
2845 PUBLIC S16 cmUnpkPjUdxCipherInfo
2846 (
2847 UdxCipherInfo *param,
2848 Buffer *mBuf
2849 )
2850 #else
2851 PUBLIC S16 cmUnpkPjUdxCipherInfo(param, mBuf)
2852 UdxCipherInfo *param;
2853 Buffer *mBuf;
2854 #endif
2855 {
2856
2857    S32 i;
2858    TRC3(cmUnpkPjUdxCipherInfo)
2859
2860    for (i=0; i<UDX_CIPHER_KEY_LEN; i++) {
2861       CMCHKUNPK(SUnpkU8, &param->ctrlplnKey[i], mBuf);
2862    }
2863    for (i=0; i<UDX_CIPHER_KEY_LEN; i++) {
2864       CMCHKUNPK(SUnpkU8, &param->usrplnKey[i], mBuf);
2865    }
2866    CMCHKUNPK(SUnpkU8, &param->algoType, mBuf);
2867    RETVALUE(ROK);
2868 }
2869
2870
2871 \f
2872 /***********************************************************
2873 *
2874 *     Func : cmPkPjUdxIntegInfo
2875 *
2876 *
2877 *     Desc : * Integrity protection paramater information.
2878 *
2879 *
2880 *     Ret  : S16
2881 *
2882 *     Notes:
2883 *
2884 *     File  :
2885 *
2886 **********************************************************/
2887 #ifdef ANSI
2888 PUBLIC S16 cmPkPjUdxIntegInfo
2889 (
2890 UdxIntegInfo *param,
2891 Buffer *mBuf
2892 )
2893 #else
2894 PUBLIC S16 cmPkPjUdxIntegInfo(param, mBuf)
2895 UdxIntegInfo *param;
2896 Buffer *mBuf;
2897 #endif
2898 {
2899
2900    S32 i;
2901    TRC3(cmPkPjUdxIntegInfo)
2902
2903    for (i=UDX_INTG_KEY_LEN-1; i >= 0; i--) {
2904       CMCHKPK(SPkU8, param->intKey[i], mBuf);
2905    }
2906    CMCHKPK(SPkU8, param->algoType, mBuf);
2907    RETVALUE(ROK);
2908 }
2909
2910
2911 \f
2912 /***********************************************************
2913 *
2914 *     Func : cmUnpkPjUdxIntegInfo
2915 *
2916 *
2917 *     Desc : * Integrity protection paramater information.
2918 *
2919 *
2920 *     Ret  : S16
2921 *
2922 *     Notes:
2923 *
2924 *     File  :
2925 *
2926 **********************************************************/
2927 #ifdef ANSI
2928 PUBLIC S16 cmUnpkPjUdxIntegInfo
2929 (
2930 UdxIntegInfo *param,
2931 Buffer *mBuf
2932 )
2933 #else
2934 PUBLIC S16 cmUnpkPjUdxIntegInfo(param, mBuf)
2935 UdxIntegInfo *param;
2936 Buffer *mBuf;
2937 #endif
2938 {
2939
2940    S32 i;
2941    TRC3(cmUnpkPjUdxIntegInfo)
2942
2943    CMCHKUNPK(SUnpkU8, &param->algoType, mBuf);
2944    for (i=0; i<UDX_INTG_KEY_LEN; i++) {
2945       CMCHKUNPK(SUnpkU8, &param->intKey[i], mBuf);
2946    }
2947    RETVALUE(ROK);
2948 }
2949
2950 \f
2951 /***********************************************************
2952 *
2953 *     Func : cmPkPjUdxSecCfg
2954 *
2955 *
2956 *     Desc : * PDCP Security configuration parameter.
2957 *
2958 *
2959 *     Ret  : S16
2960 *
2961 *     Notes:
2962 *
2963 *     File  :
2964 *
2965 **********************************************************/
2966 #ifdef ANSI
2967 PUBLIC S16 cmPkPjUdxSecCfg
2968 (
2969 UdxSecCfg *param,
2970 Buffer *mBuf
2971 )
2972 #else
2973 PUBLIC S16 cmPkPjUdxSecCfg(param, mBuf)
2974 UdxSecCfg *param;
2975 Buffer *mBuf;
2976 #endif
2977 {
2978
2979    TRC3(cmPkPjUdxSecCfg)
2980
2981    CMCHKPK(cmPkPjUdxCipherInfo, &param->cipherInfo, mBuf);
2982    CMCHKPK(cmPkPjUdxIntegInfo, &param->integInfo, mBuf);
2983    CMCHKPK(SPkU8, param->selSecAct, mBuf);
2984    CMCHKPK(SPkU8, param->isHo, mBuf);
2985    RETVALUE(ROK);
2986 }
2987
2988
2989 \f
2990 /***********************************************************
2991 *
2992 *     Func : cmUnpkPjUdxSecCfg
2993 *
2994 *
2995 *     Desc : * PDCP Security configuration parameter.
2996 *
2997 *
2998 *     Ret  : S16
2999 *
3000 *     Notes:
3001 *
3002 *     File  :
3003 *
3004 **********************************************************/
3005 #ifdef ANSI
3006 PUBLIC S16 cmUnpkPjUdxSecCfg
3007 (
3008 UdxSecCfg *param,
3009 Buffer *mBuf
3010 )
3011 #else
3012 PUBLIC S16 cmUnpkPjUdxSecCfg(param, mBuf)
3013 UdxSecCfg *param;
3014 Buffer *mBuf;
3015 #endif
3016 {
3017
3018    TRC3(cmUnpkPjUdxSecCfg)
3019
3020    CMCHKUNPK(SUnpkU8, &param->isHo, mBuf);
3021    CMCHKUNPK(SUnpkU8, &param->selSecAct, mBuf);
3022    CMCHKUNPK(cmUnpkPjUdxIntegInfo, &param->integInfo, mBuf);
3023    CMCHKUNPK(cmUnpkPjUdxCipherInfo, &param->cipherInfo, mBuf);
3024    RETVALUE(ROK);
3025 }
3026
3027 \f
3028 /***********************************************************
3029 *
3030 *     Func : cmPkPjUdxRohcInfo
3031 *
3032 *
3033 *     Desc : * ROHC compression protocol information structure.
3034 *
3035 *
3036 *     Ret  : S16
3037 *
3038 *     Notes:
3039 *
3040 *     File  :
3041 *
3042 **********************************************************/
3043 #ifdef ANSI
3044 PUBLIC S16 cmPkPjUdxRohcInfo
3045 (
3046 UdxRohcInfo *param,
3047 Buffer *mBuf
3048 )
3049 #else
3050 PUBLIC S16 cmPkPjUdxRohcInfo(param, mBuf)
3051 UdxRohcInfo *param;
3052 Buffer *mBuf;
3053 #endif
3054 {
3055
3056    S32 i;
3057    TRC3(cmPkPjUdxRohcInfo)
3058
3059    for (i=UDX_MAX_ROHC_PROF_LIST-1; i >= 0; i--) {
3060       CMCHKPK(SPkU8, param->profLst[i], mBuf);
3061    }
3062    CMCHKPK(SPkU16, param->maxCid, mBuf);
3063    RETVALUE(ROK);
3064 }
3065
3066
3067 \f
3068 /***********************************************************
3069 *
3070 *     Func : cmUnpkPjUdxRohcInfo
3071 *
3072 *
3073 *     Desc : * ROHC compression protocol information structure.
3074 *
3075 *
3076 *     Ret  : S16
3077 *
3078 *     Notes:
3079 *
3080 *     File  :
3081 *
3082 **********************************************************/
3083 #ifdef ANSI
3084 PUBLIC S16 cmUnpkPjUdxRohcInfo
3085 (
3086 UdxRohcInfo *param,
3087 Buffer *mBuf
3088 )
3089 #else
3090 PUBLIC S16 cmUnpkPjUdxRohcInfo(param, mBuf)
3091 UdxRohcInfo *param;
3092 Buffer *mBuf;
3093 #endif
3094 {
3095
3096    S32 i;
3097    TRC3(cmUnpkPjUdxRohcInfo)
3098
3099    CMCHKUNPK(SUnpkU16, &param->maxCid, mBuf);
3100    for (i=0; i<UDX_MAX_ROHC_PROF_LIST; i++) {
3101       CMCHKUNPK(SUnpkU8, &param->profLst[i], mBuf);
3102    }
3103    RETVALUE(ROK);
3104 }
3105
3106
3107 \f
3108 /***********************************************************
3109 *
3110 *     Func : cmPkPjUdxHdrCompCfg
3111 *
3112 *
3113 *     Desc : * ROHC configuration information for PDCP entity.
3114 *
3115 *
3116 *     Ret  : S16
3117 *
3118 *     Notes:
3119 *
3120 *     File  :
3121 *
3122 **********************************************************/
3123 #ifdef ANSI
3124 PUBLIC S16 cmPkPjUdxHdrCompCfg
3125 (
3126 UdxHdrCompCfg *param,
3127 Buffer *mBuf
3128 )
3129 #else
3130 PUBLIC S16 cmPkPjUdxHdrCompCfg(param, mBuf)
3131 UdxHdrCompCfg *param;
3132 Buffer *mBuf;
3133 #endif
3134 {
3135
3136    TRC3(cmPkPjUdxHdrCompCfg)
3137
3138    CMCHKPK(cmPkPjUdxRohcInfo, &param->rohcInfo, mBuf);
3139    CMCHKPK(SPkU8, param->hdrCompUsed, mBuf);
3140    RETVALUE(ROK);
3141 }
3142
3143
3144 \f
3145 /***********************************************************
3146 *
3147 *     Func : cmUnpkPjUdxHdrCompCfg
3148 *
3149 *
3150 *     Desc : * ROHC configuration information for PDCP entity.
3151 *
3152 *
3153 *     Ret  : S16
3154 *
3155 *     Notes:
3156 *
3157 *     File  :
3158 *
3159 **********************************************************/
3160 #ifdef ANSI
3161 PUBLIC S16 cmUnpkPjUdxHdrCompCfg
3162 (
3163 UdxHdrCompCfg *param,
3164 Buffer *mBuf
3165 )
3166 #else
3167 PUBLIC S16 cmUnpkPjUdxHdrCompCfg(param, mBuf)
3168 UdxHdrCompCfg *param;
3169 Buffer *mBuf;
3170 #endif
3171 {
3172
3173    TRC3(cmUnpkPjUdxHdrCompCfg)
3174
3175    CMCHKUNPK(SUnpkU8, &param->hdrCompUsed, mBuf);
3176    CMCHKUNPK(cmUnpkPjUdxRohcInfo, &param->rohcInfo, mBuf);
3177    RETVALUE(ROK);
3178 }
3179
3180
3181 \f
3182 /***********************************************************
3183 *
3184 *     Func : cmPkPjUdxHoInfo
3185 *
3186 *
3187 *     Desc : * Handover Information for RB.
3188 *
3189 *
3190 *     Ret  : S16
3191 *
3192 *     Notes:
3193 *
3194 *     File  :
3195 *
3196 **********************************************************/
3197 #ifdef ANSI
3198 PUBLIC S16 cmPkPjUdxHoInfo
3199 (
3200 Pst *pst,
3201 UdxHoInfo *param,
3202 Buffer *mBuf
3203 )
3204 #else
3205 PUBLIC S16 cmPkPjUdxHoInfo(pst, param, mBuf)
3206 Pst *pst;
3207 UdxHoInfo *param;
3208 Buffer *mBuf;
3209 #endif
3210 {
3211    S16   cnt, idx;
3212
3213    TRC3(cmPkPjUdxHoInfo)
3214
3215    if (param->numBits % 8 == 0)
3216       cnt = param->numBits/8;
3217    else
3218       cnt = param->numBits/8 + 1;
3219
3220    for (idx = cnt-1; idx >= 0; idx--)
3221    {
3222       CMCHKPK(SPkU8, param->ulBitMap[idx], mBuf);
3223    }
3224
3225    /* Free ulBitMap after packing */
3226    if (cnt)
3227       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, param->ulBitMap, cnt * sizeof(U8));
3228
3229    CMCHKPK(SPkU16, param->numBits, mBuf);
3230    CMCHKPK(SPkU32, param->ulCount, mBuf);
3231    CMCHKPK(SPkU32, param->dlCount, mBuf);
3232    CMCHKPK(SPkU8, param->isHoPres, mBuf);
3233    RETVALUE(ROK);
3234 }
3235
3236
3237 \f
3238 /***********************************************************
3239 *
3240 *     Func : cmUnpkPjUdxHoInfo
3241 *
3242 *
3243 *     Desc : * Handover Information for RB.
3244 *
3245 *
3246 *     Ret  : S16
3247 *
3248 *     Notes:
3249 *
3250 *     File  :
3251 *
3252 **********************************************************/
3253 #ifdef ANSI
3254 PUBLIC S16 cmUnpkPjUdxHoInfo
3255 (
3256 Pst *pst,
3257 UdxHoInfo *param,
3258 Buffer *mBuf
3259 )
3260 #else
3261 PUBLIC S16 cmUnpkPjUdxHoInfo(pst, param, mBuf)
3262 Pst *pst;
3263 UdxHoInfo *param;
3264 Buffer *mBuf;
3265 #endif
3266 {
3267    S16   cnt, idx;
3268    S16   ret1 = ROK;
3269
3270    TRC3(cmUnpkPjUdxHoInfo)
3271
3272    CMCHKUNPK(SUnpkU8, &param->isHoPres, mBuf);
3273    CMCHKUNPK(SUnpkU32, &param->dlCount, mBuf);
3274    CMCHKUNPK(SUnpkU32, &param->ulCount, mBuf);
3275    CMCHKUNPK(SUnpkU16, &param->numBits, mBuf);
3276
3277    if (param->numBits % 8 == 0)
3278       cnt = param->numBits/8;
3279    else
3280       cnt = param->numBits/8 + 1;
3281
3282    if(cnt && (ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&param->ulBitMap,\
3283                cnt * sizeof(U8), 0)) != ROK)
3284    {
3285 #if (ERRCLASS & ERRCLS_ADD_RES)
3286       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3287             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3288             (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
3289 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
3290       RETVALUE(ret1);
3291    }
3292
3293    if (cnt == 0)
3294       param->ulBitMap = NULLP;
3295
3296    for (idx = 0; idx < cnt; idx++)
3297    {
3298       CMCHKUNPK(SUnpkU8, &param->ulBitMap[idx], mBuf);
3299    }
3300
3301    RETVALUE(ROK);
3302 }
3303
3304
3305 \f
3306 /***********************************************************
3307 *
3308 *     Func : cmPkPjUdxCfgEnt
3309 *
3310 *
3311 *     Desc : * Configuration structure for PDCP entity.
3312 *
3313 *
3314 *     Ret  : S16
3315 *
3316 *     Notes:
3317 *
3318 *     File  :
3319 *
3320 **********************************************************/
3321 #ifdef ANSI
3322 PUBLIC S16 cmPkPjUdxCfgEnt
3323 (
3324 Pst *pst,
3325 UdxCfgEnt *param,
3326 Buffer *mBuf
3327 )
3328 #else
3329 PUBLIC S16 cmPkPjUdxCfgEnt(pst, param, mBuf)
3330 Pst *pst;
3331 UdxCfgEnt *param;
3332 Buffer *mBuf;
3333 #endif
3334 {
3335    TRC3(cmPkPjUdxCfgEnt)
3336
3337       switch(param->cfgType) {
3338          case UDX_CFG_MODIFY:
3339             if (cmPkPjUdxModCfgEnt(pst, &param->m.modCfg, mBuf) != ROK)
3340                RETVALUE(RFAILED);
3341             break;
3342          case UDX_CFG_ADD:
3343             CMCHKPK(cmPkPjUdxAddCfgEnt, &param->m.addCfg, mBuf);
3344             break;
3345       }
3346    CMCHKPK(SPkU8, param->cfgType, mBuf);
3347    CMCHKPK(SPkU8, param->rbType, mBuf);
3348    CMCHKPK(SPkU8, param->rbId, mBuf);
3349    RETVALUE(ROK);
3350 }
3351
3352
3353 \f
3354 /***********************************************************
3355 *
3356 *     Func : cmUnpkPjUdxCfgEnt
3357 *
3358 *
3359 *     Desc : * Configuration structure for PDCP entity.
3360 *
3361 *
3362 *     Ret  : S16
3363 *
3364 *     Notes:
3365 *
3366 *     File  :
3367 *
3368 **********************************************************/
3369 #ifdef ANSI
3370 PUBLIC S16 cmUnpkPjUdxCfgEnt
3371 (
3372 Pst *pst,
3373 UdxCfgEnt *param,
3374 Buffer *mBuf
3375 )
3376 #else
3377 PUBLIC S16 cmUnpkPjUdxCfgEnt(pst, param, mBuf)
3378 Pst *pst;
3379 UdxCfgEnt *param;
3380 Buffer *mBuf;
3381 #endif
3382 {
3383    TRC3(cmUnpkPjUdxCfgEnt)
3384
3385    CMCHKUNPK(SUnpkU8, &param->rbId, mBuf);
3386    CMCHKUNPK(SUnpkU8, &param->rbType, mBuf);
3387    CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
3388       switch(param->cfgType) {
3389          case UDX_CFG_ADD:
3390             CMCHKUNPK(cmUnpkPjUdxAddCfgEnt, &param->m.addCfg, mBuf);
3391             break;
3392          case UDX_CFG_MODIFY:
3393             if (cmUnpkPjUdxModCfgEnt(pst, &param->m.modCfg, mBuf) != ROK)
3394                RETVALUE(RFAILED);
3395             break;
3396       }
3397    RETVALUE(ROK);
3398 }
3399
3400
3401 #ifdef ANSI
3402 PUBLIC S16 cmPkPjUdxAddCfgEnt
3403 (
3404 UdxAddCfgEnt *param,
3405 Buffer *mBuf
3406 )
3407 #else
3408 PUBLIC S16 cmPkPjUdxAddCfgEnt(param, mBuf)
3409 UdxAddCfgEnt *param;
3410 Buffer *mBuf;
3411 #endif
3412 {
3413
3414    TRC3(cmPkPjUdxAddCfgEnt)
3415
3416    CMCHKPK(cmPkPjUdxHdrCompCfg, &param->hdrCompCfg, mBuf);
3417    CMCHKPK(SPkS16, param->discardTmr, mBuf);
3418    CMCHKPK(cmPkPjUdxRlcInfo, &param->rlcInfo, mBuf);
3419    /* cpj_c_001.main_4 added support for L2 Measurement */
3420 #ifdef LTE_L2_MEAS
3421    CMCHKPK(SPkU8, param->qci, mBuf);
3422 #endif /* LTE_L2_MEAS */
3423    CMCHKPK(SPkU8, param->cfmReqd, mBuf);
3424    CMCHKPK(SPkU8, param->discReqd, mBuf);
3425    RETVALUE(ROK);
3426 }
3427
3428
3429 #ifdef ANSI
3430 PUBLIC S16 cmUnpkPjUdxAddCfgEnt
3431 (
3432 UdxAddCfgEnt *param,
3433 Buffer *mBuf
3434 )
3435 #else
3436 PUBLIC S16 cmUnpkPjUdxAddCfgEnt(param, mBuf)
3437 UdxAddCfgEnt *param;
3438 Buffer *mBuf;
3439 #endif
3440 {
3441
3442    TRC3(cmUnpkPjUdxAddCfgEnt)
3443
3444    CMCHKUNPK(SUnpkU8, &param->discReqd, mBuf);
3445    CMCHKUNPK(SUnpkU8, &param->cfmReqd, mBuf);
3446    /* cpj_c_001.main_4 added support for L2 Measurement */
3447 #ifdef LTE_L2_MEAS
3448    CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
3449 #endif /* LTE_L2_MEAS */
3450    CMCHKUNPK(cmUnpkPjUdxRlcInfo, &param->rlcInfo, mBuf);
3451    CMCHKUNPK(SUnpkS16, &param->discardTmr, mBuf);
3452    CMCHKUNPK(cmUnpkPjUdxHdrCompCfg, &param->hdrCompCfg, mBuf);
3453    RETVALUE(ROK);
3454 }
3455
3456
3457 #ifdef ANSI
3458 PUBLIC S16 cmPkPjUdxModCfgEnt
3459 (
3460 Pst *pst,
3461 UdxModCfgEnt *param,
3462 Buffer *mBuf
3463 )
3464 #else
3465 PUBLIC S16 cmPkPjUdxModCfgEnt(pst, param, mBuf)
3466 Pst *pst;
3467 UdxModCfgEnt *param;
3468 Buffer *mBuf;
3469 #endif
3470 {
3471    TRC3(cmPkPjUdxModCfgEnt)
3472
3473    if (cmPkPjUdxHoInfo(pst, &param->hoInfo, mBuf) != ROK)
3474       RETVALUE(RFAILED);
3475    CMCHKPK(cmPkPjUdxHdrCompCfg, &param->hdrCompCfg, mBuf);
3476    CMCHKPK(SPkU8, param->cfmReqd, mBuf);
3477    CMCHKPK(SPkU8, param->discReqd, mBuf);
3478    CMCHKPK(SPkU8, param->bitFlag, mBuf);
3479    RETVALUE(ROK);
3480 }
3481
3482
3483 #ifdef ANSI
3484 PUBLIC S16 cmUnpkPjUdxModCfgEnt
3485 (
3486 Pst *pst,
3487 UdxModCfgEnt *param,
3488 Buffer *mBuf
3489 )
3490 #else
3491 PUBLIC S16 cmUnpkPjUdxModCfgEnt(pst, param, mBuf)
3492 Pst *pst;
3493 UdxModCfgEnt *param;
3494 Buffer *mBuf;
3495 #endif
3496 {
3497    TRC3(cmUnpkPjUdxModCfgEnt)
3498
3499    CMCHKUNPK(SUnpkU8, &param->bitFlag, mBuf);
3500    CMCHKUNPK(SUnpkU8, &param->discReqd, mBuf);
3501    CMCHKUNPK(SUnpkU8, &param->cfmReqd, mBuf);
3502    CMCHKUNPK(cmUnpkPjUdxHdrCompCfg, &param->hdrCompCfg, mBuf);
3503    if (cmUnpkPjUdxHoInfo(pst, &param->hoInfo, mBuf) != ROK)
3504       RETVALUE(RFAILED);
3505    RETVALUE(ROK);
3506 }
3507
3508 \f
3509 /***********************************************************
3510 *
3511 *     Func : cmPkPjUdxCfgReqInfo
3512 *
3513 *
3514 *     Desc : * PDCP Configuration structure. Parameters are filled by RRC
3515    layer while configuring the PDCP layer.
3516 *
3517 *
3518 *     Ret  : S16
3519 *
3520 *     Notes:
3521 *
3522 *     File  :
3523 *
3524 **********************************************************/
3525 #ifdef ANSI
3526 PUBLIC S16 cmPkPjUdxCfgReqInfo
3527 (
3528 Pst *pst,
3529 UdxCfgReqInfo *param,
3530 Buffer *mBuf
3531 )
3532 #else
3533 PUBLIC S16 cmPkPjUdxCfgReqInfo(pst, param, mBuf)
3534 Pst *pst;
3535 UdxCfgReqInfo *param;
3536 Buffer *mBuf;
3537 #endif
3538 {
3539    S32 i;
3540
3541    TRC3(cmPkPjUdxCfgReqInfo)
3542
3543    for (i=param->numEnt-1; i >= 0; i--) {
3544       if (cmPkPjUdxCfgEnt(pst, &param->cfgEnt[i], mBuf) != ROK)
3545          RETVALUE(RFAILED);
3546    }
3547 #ifdef TENB_MULT_CELL_SUPPRT
3548    CMCHKPK(SPkS16, param->rlcDlSapId, mBuf);
3549    CMCHKPK(SPkS16, param->rlcUlSapId, mBuf);
3550 #endif
3551
3552    CMCHKPK(SPkU8, param->numEnt, mBuf);
3553    CMCHKPK(SPkU32, param->transId, mBuf);
3554    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
3555    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
3556    RETVALUE(ROK);
3557 }
3558
3559 /*
3560 *
3561 *    Fun:    cmPkPjUdxUlStaRepInfo
3562 *
3563 *    Desc:    pack the structure UdxUlStaRepInfo
3564 *
3565 *    Ret:    ROK  -ok
3566 *
3567 *    Notes:    None
3568 *
3569 *    File:     pj_udx.c
3570 *
3571 */
3572 #ifdef ANSI
3573 PUBLIC S16 cmPkPjUdxUlStaRepInfo
3574 (
3575 UdxUlStaRepInfo  *param,
3576 Pst            *pst,
3577 Buffer         *mBuf
3578 )
3579 #else
3580 PUBLIC S16 cmPkPjUdxUlStaRepInfo(param, pst, mBuf)
3581 UdxUlStaRepInfo  *param;
3582 Pst            *pst;
3583 Buffer         *mBuf;
3584 #endif
3585 {
3586    S16 msgLen;
3587    TRC3(cmPkPjUdxUlStaRepInfo)
3588
3589    CMCHKPK(SPkU8, param->pdcpId.rbType, mBuf);
3590    CMCHKPK(cmPkLteRbId, param->pdcpId.rbId, mBuf);
3591    CMCHKPK(cmPkLteRnti, param->pdcpId.ueId, mBuf);
3592    CMCHKPK(cmPkLteCellId, param->pdcpId.cellId, mBuf);
3593
3594    if (SFndLenMsg(param->sta, &msgLen) != ROK)
3595       RETVALUE(RFAILED);
3596    if (SCatMsg(mBuf, param->sta, M1M2) != ROK)
3597       RETVALUE(RFAILED);
3598    PJ_FREE_BUF(mBuf);
3599    CMCHKPK(SPkS16, msgLen, mBuf);
3600
3601    RETVALUE(ROK);
3602 } /* cmPkPjUdxUlStaRepInfo */
3603
3604 #ifdef ANSI
3605 PUBLIC S16 cmUnpkPjUdxUlStaRepInfo
3606 (
3607 Pst *pst,
3608 UdxUlStaRepInfo *param,
3609 Buffer *mBuf
3610 )
3611 #else
3612 PUBLIC S16 cmUnpkPjUdxUlStaRepInfo(pst, param, mBuf)
3613 Pst *pst;
3614 UdxUlStaRepInfo *param;
3615 Buffer *mBuf;
3616 #endif
3617 {
3618    MsgLen msgLen=0;
3619    MsgLen totalMsgLen;
3620
3621    TRC3(cmUnpkPjUdxUlStaRepInfo);
3622
3623    CMCHKUNPK(SUnpkU8, &param->pdcpId.rbType, mBuf);
3624    CMCHKUNPK(cmUnpkLteRbId, &param->pdcpId.rbId, mBuf);
3625    CMCHKUNPK(cmUnpkLteRnti, &param->pdcpId.ueId, mBuf);
3626    CMCHKUNPK(cmUnpkLteCellId, &param->pdcpId.cellId, mBuf);
3627
3628    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
3629       RETVALUE(RFAILED);
3630
3631    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->sta) != ROK)
3632       RETVALUE(RFAILED);
3633
3634    RETVALUE(ROK);
3635 }
3636
3637 #ifdef ANSI
3638 PUBLIC S16 cmUnpkPjUdxUlFdbkPktInfo
3639 (
3640 Pst *pst,
3641 UdxUlFdbkPktInfo *param,
3642 Buffer *mBuf
3643 )
3644 #else
3645 PUBLIC S16 cmUnpkPjUdxUlFdbkPktInfo(pst, param, mBuf)
3646 Pst *pst;
3647 UdxUlFdbkPktInfo *param;
3648 Buffer *mBuf;
3649 #endif
3650 {
3651    MsgLen msgLen=0;
3652    MsgLen totalMsgLen;
3653
3654    TRC3(cmUnpkPjUdxUlFdbkPktInfo);
3655
3656    CMCHKUNPK(SUnpkU8, &param->pdcpId.rbType, mBuf);
3657    CMCHKUNPK(cmUnpkLteRbId, &param->pdcpId.rbId, mBuf);
3658    CMCHKUNPK(cmUnpkLteRnti, &param->pdcpId.ueId, mBuf);
3659    CMCHKUNPK(cmUnpkLteCellId, &param->pdcpId.cellId, mBuf);
3660
3661    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
3662       RETVALUE(RFAILED);
3663
3664    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->fbPkt) != ROK)
3665       RETVALUE(RFAILED);
3666
3667    RETVALUE(ROK);
3668 }
3669
3670 #ifdef ANSI
3671 PUBLIC S16 cmUnpkPjUdxDlFdbkPktInfo
3672 (
3673 Pst *pst,
3674 UdxDlFdbkPktInfo *param,
3675 Buffer *mBuf
3676 )
3677 #else
3678 PUBLIC S16 cmUnpkPjUdxDlFdbkPktInfo(pst, param, mBuf)
3679 Pst *pst;
3680 UdxDlFdbkPktInfo *param;
3681 Buffer *mBuf;
3682 #endif
3683 {
3684    MsgLen msgLen=0;
3685    MsgLen totalMsgLen;
3686
3687    TRC3(cmUnpkPjUdxDlFdbkPktInfo);
3688
3689    CMCHKUNPK(SUnpkU8, &param->pdcpId.rbType, mBuf);
3690    CMCHKUNPK(cmUnpkLteRbId, &param->pdcpId.rbId, mBuf);
3691    CMCHKUNPK(cmUnpkLteRnti, &param->pdcpId.ueId, mBuf);
3692    CMCHKUNPK(cmUnpkLteCellId, &param->pdcpId.cellId, mBuf);
3693
3694    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
3695       RETVALUE(RFAILED);
3696
3697    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->fbPkt) != ROK)
3698       RETVALUE(RFAILED);
3699
3700    RETVALUE(ROK);
3701 }
3702
3703 /*
3704 *
3705 *    Fun:    cmPkPjUdxDlStaRepInfo
3706 *
3707 *    Desc:    pack the structure UdxDlStaRepInfo
3708 *
3709 *    Ret:    ROK  -ok
3710 *
3711 *    Notes:    None
3712 *
3713 *    File:     pj_udx.c
3714 *
3715 */
3716 #ifdef ANSI
3717 PUBLIC S16 cmPkPjUdxDlStaRepInfo
3718 (
3719 UdxDlStaRepInfo  *param,
3720 Pst            *pst,
3721 Buffer         *mBuf
3722 )
3723 #else
3724 PUBLIC S16 cmPkPjUdxDlStaRepInfo(param, pst, mBuf)
3725 UdxDlStaRepInfo  *param;
3726 Pst            *pst;
3727 Buffer         *mBuf;
3728 #endif
3729 {
3730    S16 msgLen;
3731    TRC3(cmPkPjUdxDlStaRepInfo)
3732
3733    CMCHKPK(SPkU8, param->pdcpId.rbType, mBuf);
3734    CMCHKPK(cmPkLteRbId, param->pdcpId.rbId, mBuf);
3735    CMCHKPK(cmPkLteRnti, param->pdcpId.ueId, mBuf);
3736    CMCHKPK(cmPkLteCellId, param->pdcpId.cellId, mBuf);
3737    CMCHKPK(SPkU32, param->fmc, mBuf);
3738
3739    if (SFndLenMsg(param->staPdu, &msgLen) != ROK)
3740       RETVALUE(RFAILED);
3741    if (SCatMsg(mBuf, param->staPdu, M1M2) != ROK)
3742       RETVALUE(RFAILED);
3743    PJ_FREE_BUF(mBuf);
3744    CMCHKPK(SPkS16, msgLen, mBuf);
3745
3746    RETVALUE(ROK);
3747 } /* cmPkPjUdxUlStaRepInfo */
3748
3749 #ifdef ANSI
3750 PUBLIC S16 cmUnpkPjUdxDlStaRepInfo
3751 (
3752 Pst *pst,
3753 UdxDlStaRepInfo *param,
3754 Buffer *mBuf
3755 )
3756 #else
3757 PUBLIC S16 cmUnpkPjUdxDlStaRepInfo(pst, param, mBuf)
3758 Pst *pst;
3759 UdxDlStaRepInfo *param;
3760 Buffer *mBuf;
3761 #endif
3762 {
3763    MsgLen msgLen=0;
3764    MsgLen totalMsgLen;
3765
3766    TRC3(cmUnpkPjUdxDlStaRepInfo);
3767
3768    CMCHKUNPK(SUnpkU8, &param->pdcpId.rbType, mBuf);
3769    CMCHKUNPK(cmUnpkLteRbId, &param->pdcpId.rbId, mBuf);
3770    CMCHKUNPK(cmUnpkLteRnti, &param->pdcpId.ueId, mBuf);
3771    CMCHKUNPK(cmUnpkLteCellId, &param->pdcpId.cellId, mBuf);
3772    CMCHKUNPK(SUnpkU32, &param->fmc, mBuf);
3773
3774    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
3775       RETVALUE(RFAILED);
3776
3777    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->staPdu) != ROK)
3778       RETVALUE(RFAILED);
3779
3780    RETVALUE(ROK);
3781 }
3782
3783
3784 \f
3785 /***********************************************************
3786 *
3787 *     Func : cmUnpkPjUdxCfgReqInfo
3788 *
3789 *
3790 *     Desc : * PDCP Configuration structure. Parameters are filled by RRC
3791    layer while configuring the PDCP layer.
3792 *
3793 *
3794 *     Ret  : S16
3795 *
3796 *     Notes:
3797 *
3798 *     File  :
3799 *
3800 **********************************************************/
3801 #ifdef ANSI
3802 PUBLIC S16 cmUnpkPjUdxCfgReqInfo
3803 (
3804 Pst *pst,
3805 UdxCfgReqInfo *param,
3806 Buffer *mBuf
3807 )
3808 #else
3809 PUBLIC S16 cmUnpkPjUdxCfgReqInfo(pst, param, mBuf)
3810 Pst *pst;
3811 UdxCfgReqInfo *param;
3812 Buffer *mBuf;
3813 #endif
3814 {
3815    S32 i;
3816
3817    TRC3(cmUnpkPjUdxCfgReqInfo)
3818
3819    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
3820    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
3821    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
3822    CMCHKUNPK(SUnpkU8, &param->numEnt, mBuf);
3823 #ifdef TENB_MULT_CELL_SUPPRT
3824    CMCHKUNPK(SUnpkS16, &param->rlcUlSapId, mBuf);
3825    CMCHKUNPK(SUnpkS16, &param->rlcDlSapId, mBuf);
3826 #endif
3827    for (i=0; i<param->numEnt; i++) {
3828       if (cmUnpkPjUdxCfgEnt(pst, &param->cfgEnt[i], mBuf) != ROK)
3829          RETVALUE(RFAILED);
3830    }
3831    RETVALUE(ROK);
3832 }
3833
3834 \f
3835 /***********************************************************
3836 *
3837 *     Func : cmPkPjUdxCfmEnt
3838 *
3839 *
3840 *     Desc : * PDCP confirm parameter structure for PDCP entity.
3841 *
3842 *
3843 *     Ret  : S16
3844 *
3845 *     Notes:
3846 *
3847 *     File  :
3848 *
3849 **********************************************************/
3850 #ifdef ANSI
3851 PUBLIC S16 cmPkPjUdxCfmEnt
3852 (
3853 UdxCfmEnt *param,
3854 Buffer *mBuf
3855 )
3856 #else
3857 PUBLIC S16 cmPkPjUdxCfmEnt(param, mBuf)
3858 UdxCfmEnt *param;
3859 Buffer *mBuf;
3860 #endif
3861 {
3862
3863    TRC3(cmPkPjUdxCfmEnt)
3864
3865    CMCHKPK(SPkS16, param->reason, mBuf);
3866    CMCHKPK(SPkS16, param->status, mBuf);
3867    CMCHKPK(SPkU8, param->rbType, mBuf);
3868    CMCHKPK(SPkU8, param->rbId, mBuf);
3869    RETVALUE(ROK);
3870 }
3871
3872
3873 \f
3874 /***********************************************************
3875 *
3876 *     Func : cmUnpkPjUdxCfmEnt
3877 *
3878 *
3879 *     Desc : * PDCP confirm parameter structure for PDCP entity.
3880 *
3881 *
3882 *     Ret  : S16
3883 *
3884 *     Notes:
3885 *
3886 *     File  :
3887 *
3888 **********************************************************/
3889 #ifdef ANSI
3890 PUBLIC S16 cmUnpkPjUdxCfmEnt
3891 (
3892 UdxCfmEnt *param,
3893 Buffer *mBuf
3894 )
3895 #else
3896 PUBLIC S16 cmUnpkPjUdxCfmEnt(param, mBuf)
3897 UdxCfmEnt *param;
3898 Buffer *mBuf;
3899 #endif
3900 {
3901
3902    TRC3(cmUnpkPjUdxCfmEnt)
3903
3904    CMCHKUNPK(SUnpkU8, &param->rbId, mBuf);
3905    CMCHKUNPK(SUnpkU8, &param->rbType, mBuf);
3906    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
3907    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
3908    RETVALUE(ROK);
3909 }
3910
3911
3912 \f
3913 /***********************************************************
3914 *
3915 *     Func : cmPkPjUdxCfgCfmInfo
3916 *
3917 *
3918 *     Desc : * PDCP configuration confirm structure.
3919 *
3920 *
3921 *     Ret  : S16
3922 *
3923 *     Notes:
3924 *
3925 *     File  :
3926 *
3927 **********************************************************/
3928 #ifdef ANSI
3929 PUBLIC S16 cmPkPjUdxCfgCfmInfo
3930 (
3931 UdxCfgCfmInfo *param,
3932 Buffer *mBuf
3933 )
3934 #else
3935 PUBLIC S16 cmPkPjUdxCfgCfmInfo(param, mBuf)
3936 UdxCfgCfmInfo *param;
3937 Buffer *mBuf;
3938 #endif
3939 {
3940
3941    S32 i;
3942    TRC3(cmPkPjUdxCfgCfmInfo)
3943
3944    for (i=param->numEnt-1; i >= 0; i--) {
3945       CMCHKPK(cmPkPjUdxCfmEnt, &param->cfmEnt[i], mBuf);
3946    }
3947    CMCHKPK(SPkU8, param->numEnt, mBuf);
3948    CMCHKPK(SPkU32, param->transId, mBuf);
3949    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
3950    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
3951    RETVALUE(ROK);
3952 }
3953
3954
3955 \f
3956 /***********************************************************
3957 *
3958 *     Func : cmUnpkPjUdxCfgCfmInfo
3959 *
3960 *
3961 *     Desc : * PDCP configuration confirm structure.
3962 *
3963 *
3964 *     Ret  : S16
3965 *
3966 *     Notes:
3967 *
3968 *     File  :
3969 *
3970 **********************************************************/
3971 #ifdef ANSI
3972 PUBLIC S16 cmUnpkPjUdxCfgCfmInfo
3973 (
3974 UdxCfgCfmInfo *param,
3975 Buffer *mBuf
3976 )
3977 #else
3978 PUBLIC S16 cmUnpkPjUdxCfgCfmInfo(param, mBuf)
3979 UdxCfgCfmInfo *param;
3980 Buffer *mBuf;
3981 #endif
3982 {
3983
3984    S32 i;
3985    TRC3(cmUnpkPjUdxCfgCfmInfo)
3986
3987    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
3988    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
3989    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
3990    CMCHKUNPK(SUnpkU8, &param->numEnt, mBuf);
3991    for (i=0; i<param->numEnt; i++) {
3992       CMCHKUNPK(cmUnpkPjUdxCfmEnt, &param->cfmEnt[i], mBuf);
3993    }
3994    RETVALUE(ROK);
3995 }
3996
3997 \f
3998 /***********************************************************
3999 *
4000 *     Func : cmPkPjUdxReEstReqInfo
4001 *
4002 *
4003 *     Desc : * Reestabishment request structure for SRB1 of an UE.
4004 *
4005 *
4006 *     Ret  : S16
4007 *
4008 *     Notes:
4009 *
4010 *     File  :
4011 *
4012 **********************************************************/
4013 #ifdef ANSI
4014 PUBLIC S16 cmPkPjUdxReEstReqInfo
4015 (
4016 UdxReEstReqInfo *param,
4017 Buffer *mBuf
4018 )
4019 #else
4020 PUBLIC S16 cmPkPjUdxReEstReqInfo(param, mBuf)
4021 UdxReEstReqInfo *param;
4022 Buffer *mBuf;
4023 #endif
4024 {
4025
4026    S32 i;
4027    TRC3(cmPkPjUdxReEstReqInfo)
4028
4029    for (i=UDX_CIPHER_KEY_LEN-1; i >= 0; i--) {
4030       CMCHKPK(SPkU8, param->usrplnKey[i], mBuf);
4031    }
4032    for (i=UDX_CIPHER_KEY_LEN-1; i >= 0; i--) {
4033       CMCHKPK(SPkU8, param->ctrlplnKey[i], mBuf);
4034    }
4035    for (i=UDX_INTG_KEY_LEN-1; i >= 0; i--) {
4036       CMCHKPK(SPkU8, param->intKey[i], mBuf);
4037    }
4038    CMCHKPK(SPkU32, param->transId, mBuf);
4039
4040    CMCHKPK(cmPkLtePdcpId, &param->pdcpId, mBuf);
4041    RETVALUE(ROK);
4042 }
4043
4044
4045 \f
4046 /***********************************************************
4047 *
4048 *     Func : cmUnpkPjUdxReEstReqInfo
4049 *
4050 *
4051 *     Desc : * Reestabishment request structure for SRB1 of an UE.
4052 *
4053 *
4054 *     Ret  : S16
4055 *
4056 *     Notes:
4057 *
4058 *     File  :
4059 *
4060 **********************************************************/
4061 #ifdef ANSI
4062 PUBLIC S16 cmUnpkPjUdxReEstReqInfo
4063 (
4064 UdxReEstReqInfo *param,
4065 Buffer *mBuf
4066 )
4067 #else
4068 PUBLIC S16 cmUnpkPjUdxReEstReqInfo(param, mBuf)
4069 UdxReEstReqInfo *param;
4070 Buffer *mBuf;
4071 #endif
4072 {
4073
4074    S32 i;
4075    TRC3(cmUnpkPjUdxReEstReqInfo)
4076
4077    CMCHKUNPK(cmUnpkLtePdcpId, &param->pdcpId, mBuf);
4078    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4079    for (i=0; i<UDX_INTG_KEY_LEN; i++) {
4080       CMCHKUNPK(SUnpkU8, &param->intKey[i], mBuf);
4081    }
4082    for (i=0; i<UDX_CIPHER_KEY_LEN; i++) {
4083       CMCHKUNPK(SUnpkU8, &param->ctrlplnKey[i], mBuf);
4084    }
4085    for (i=0; i<UDX_CIPHER_KEY_LEN; i++) {
4086       CMCHKUNPK(SUnpkU8, &param->usrplnKey[i], mBuf);
4087    }
4088    RETVALUE(ROK);
4089 }
4090
4091 \f
4092 /***********************************************************
4093 *
4094 *     Func : cmPkPjUdxReEstCfmInfo
4095 *
4096 *
4097 *     Desc : * Reestablishment confirmation structure for an UE.
4098 *
4099 *
4100 *     Ret  : S16
4101 *
4102 *     Notes:
4103 *
4104 *     File  :
4105 *
4106 **********************************************************/
4107 #ifdef ANSI
4108 PUBLIC S16 cmPkPjUdxReEstCfmInfo
4109 (
4110 UdxReEstCfmInfo *param,
4111 Buffer *mBuf
4112 )
4113 #else
4114 PUBLIC S16 cmPkPjUdxReEstCfmInfo(param, mBuf)
4115 UdxReEstCfmInfo *param;
4116 Buffer *mBuf;
4117 #endif
4118 {
4119
4120    TRC3(cmPkPjUdxReEstCfmInfo)
4121
4122    CMCHKPK(SPkS16, param->status, mBuf);
4123    CMCHKPK(SPkU32, param->transId, mBuf);
4124    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4125    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4126    RETVALUE(ROK);
4127 }
4128
4129
4130 \f
4131 /***********************************************************
4132 *
4133 *     Func : cmUnpkPjUdxReEstCfmInfo
4134 *
4135 *
4136 *     Desc : * Reestablishment confirmation structure for an UE.
4137 *
4138 *
4139 *     Ret  : S16
4140 *
4141 *     Notes:
4142 *
4143 *     File  :
4144 *
4145 **********************************************************/
4146 #ifdef ANSI
4147 PUBLIC S16 cmUnpkPjUdxReEstCfmInfo
4148 (
4149 UdxReEstCfmInfo *param,
4150 Buffer *mBuf
4151 )
4152 #else
4153 PUBLIC S16 cmUnpkPjUdxReEstCfmInfo(param, mBuf)
4154 UdxReEstCfmInfo *param;
4155 Buffer *mBuf;
4156 #endif
4157 {
4158
4159    TRC3(cmUnpkPjUdxReEstCfmInfo)
4160
4161    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4162    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4163    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4164    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
4165    RETVALUE(ROK);
4166 }
4167
4168 \f
4169 /***********************************************************
4170 *
4171 *     Func : cmPkPjUdxSecCfgReqInfo
4172 *
4173 *
4174 *     Desc : * PDCP Security Configuration structure. Parameters are filled by RRC
4175  * while configuring the security parameters.
4176 *
4177 *
4178 *     Ret  : S16
4179 *
4180 *     Notes:
4181 *
4182 *     File  :
4183 *
4184 **********************************************************/
4185 #ifdef ANSI
4186 PUBLIC S16 cmPkPjUdxSecCfgReqInfo
4187 (
4188 UdxSecCfgReqInfo *param,
4189 Buffer *mBuf
4190 )
4191 #else
4192 PUBLIC S16 cmPkPjUdxSecCfgReqInfo(param, mBuf)
4193 UdxSecCfgReqInfo *param;
4194 Buffer *mBuf;
4195 #endif
4196 {
4197
4198    TRC3(cmPkPjUdxSecCfgReqInfo)
4199
4200    CMCHKPK(cmPkPjUdxSecCfg, &param->secCfg, mBuf);
4201    CMCHKPK(SPkU32, param->transId, mBuf);
4202    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4203    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4204    RETVALUE(ROK);
4205 }
4206
4207
4208 \f
4209 /***********************************************************
4210 *
4211 *     Func : cmUnpkPjUdxSecCfgReqInfo
4212 *
4213 *
4214 *     Desc : * PDCP Security Configuration structure. Parameters are filled by RRC
4215  * while configuring the security parameters.
4216 *
4217 *
4218 *     Ret  : S16
4219 *
4220 *     Notes:
4221 *
4222 *     File  :
4223 *
4224 **********************************************************/
4225 #ifdef ANSI
4226 PUBLIC S16 cmUnpkPjUdxSecCfgReqInfo
4227 (
4228 UdxSecCfgReqInfo *param,
4229 Buffer *mBuf
4230 )
4231 #else
4232 PUBLIC S16 cmUnpkPjUdxSecCfgReqInfo(param, mBuf)
4233 UdxSecCfgReqInfo *param;
4234 Buffer *mBuf;
4235 #endif
4236 {
4237
4238    TRC3(cmUnpkPjUdxSecCfgReqInfo)
4239
4240    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4241    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4242    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4243    CMCHKUNPK(cmUnpkPjUdxSecCfg, &param->secCfg, mBuf);
4244    RETVALUE(ROK);
4245 }
4246
4247 \f
4248 /***********************************************************
4249 *
4250 *     Func : cmPkPjUdxSecCfgCfmInfo
4251 *
4252 *
4253 *     Desc : * PDCP Security configuration confirm structure.
4254 *
4255 *
4256 *     Ret  : S16
4257 *
4258 *     Notes:
4259 *
4260 *     File  :
4261 *
4262 **********************************************************/
4263 #ifdef ANSI
4264 PUBLIC S16 cmPkPjUdxSecCfgCfmInfo
4265 (
4266 UdxSecCfgCfmInfo *param,
4267 Buffer *mBuf
4268 )
4269 #else
4270 PUBLIC S16 cmPkPjUdxSecCfgCfmInfo(param, mBuf)
4271 UdxSecCfgCfmInfo *param;
4272 Buffer *mBuf;
4273 #endif
4274 {
4275
4276    TRC3(cmPkPjUdxSecCfgCfmInfo)
4277
4278    CMCHKPK(SPkS16, param->reason, mBuf);
4279    CMCHKPK(SPkS16, param->status, mBuf);
4280    CMCHKPK(SPkU32, param->transId, mBuf);
4281    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4282    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4283    RETVALUE(ROK);
4284 }
4285
4286
4287 \f
4288 /***********************************************************
4289 *
4290 *     Func : cmUnpkPjUdxSecCfgCfmInfo
4291 *
4292 *
4293 *     Desc : * PDCP Security configuration confirm structure.
4294 *
4295 *
4296 *     Ret  : S16
4297 *
4298 *     Notes:
4299 *
4300 *     File  :
4301 *
4302 **********************************************************/
4303 #ifdef ANSI
4304 PUBLIC S16 cmUnpkPjUdxSecCfgCfmInfo
4305 (
4306 UdxSecCfgCfmInfo *param,
4307 Buffer *mBuf
4308 )
4309 #else
4310 PUBLIC S16 cmUnpkPjUdxSecCfgCfmInfo(param, mBuf)
4311 UdxSecCfgCfmInfo *param;
4312 Buffer *mBuf;
4313 #endif
4314 {
4315
4316    TRC3(cmUnpkPjUdxSecCfgCfmInfo)
4317
4318    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4319    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4320    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4321    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
4322    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
4323    RETVALUE(ROK);
4324 }
4325
4326 \f
4327 /***********************************************************
4328 *
4329 *     Func : cmPkPjUdxUeInfo
4330 *
4331 *
4332 *     Desc : *  UE ID information
4333 *
4334 *
4335 *     Ret  : S16
4336 *
4337 *     Notes:
4338 *
4339 *     File  :
4340 *
4341 **********************************************************/
4342 #ifdef ANSI
4343 PUBLIC S16 cmPkPjUdxUeInfo
4344 (
4345 UdxUeInfo *param,
4346 Buffer *mBuf
4347 )
4348 #else
4349 PUBLIC S16 cmPkPjUdxUeInfo(param, mBuf)
4350 UdxUeInfo *param;
4351 Buffer *mBuf;
4352 #endif
4353 {
4354
4355    TRC3(cmPkPjUdxUeInfo)
4356
4357    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4358    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4359    RETVALUE(ROK);
4360 }
4361
4362
4363 \f
4364 /***********************************************************
4365 *
4366 *     Func : cmUnpkPjUdxUeInfo
4367 *
4368 *
4369 *     Desc : *  UE ID information
4370 *
4371 *
4372 *     Ret  : S16
4373 *
4374 *     Notes:
4375 *
4376 *     File  :
4377 *
4378 **********************************************************/
4379 #ifdef ANSI
4380 PUBLIC S16 cmUnpkPjUdxUeInfo
4381 (
4382 UdxUeInfo *param,
4383 Buffer *mBuf
4384 )
4385 #else
4386 PUBLIC S16 cmUnpkPjUdxUeInfo(param, mBuf)
4387 UdxUeInfo *param;
4388 Buffer *mBuf;
4389 #endif
4390 {
4391
4392    TRC3(cmUnpkPjUdxUeInfo)
4393
4394    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4395    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4396    RETVALUE(ROK);
4397 }
4398
4399
4400 \f
4401 /***********************************************************
4402 *
4403 *     Func : cmPkPjUdxCountReqInfo
4404 *
4405 *
4406 *     Desc : *  PDCP Count Request Information from RRC.
4407 *
4408 *
4409 *     Ret  : S16
4410 *
4411 *     Notes:
4412 *
4413 *     File  :
4414 *
4415 **********************************************************/
4416 #ifdef ANSI
4417 PUBLIC S16 cmPkPjUdxCountReqInfo
4418 (
4419 UdxCountReqInfo *param,
4420 Buffer *mBuf
4421 )
4422 #else
4423 PUBLIC S16 cmPkPjUdxCountReqInfo(param, mBuf)
4424 UdxCountReqInfo *param;
4425 Buffer *mBuf;
4426 #endif
4427 {
4428
4429    TRC3(cmPkPjUdxCountReqInfo)
4430
4431    CMCHKPK(SPkU32, param->transId, mBuf);
4432    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4433    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4434    RETVALUE(ROK);
4435 }
4436
4437
4438 \f
4439 /***********************************************************
4440 *
4441 *     Func : cmUnpkPjUdxCountReqInfo
4442 *
4443 *
4444 *     Desc : *  PDCP Count Request Information from RRC.
4445 *
4446 *
4447 *     Ret  : S16
4448 *
4449 *     Notes:
4450 *
4451 *     File  :
4452 *
4453 **********************************************************/
4454 #ifdef ANSI
4455 PUBLIC S16 cmUnpkPjUdxCountReqInfo
4456 (
4457 UdxCountReqInfo *param,
4458 Buffer *mBuf
4459 )
4460 #else
4461 PUBLIC S16 cmUnpkPjUdxCountReqInfo(param, mBuf)
4462 UdxCountReqInfo *param;
4463 Buffer *mBuf;
4464 #endif
4465 {
4466
4467    TRC3(cmUnpkPjUdxCountReqInfo)
4468
4469    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4470    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4471    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4472    RETVALUE(ROK);
4473 }
4474
4475 \f
4476 /***********************************************************
4477 *
4478 *     Func : cmPkPjUdxCountInfo
4479 *
4480 *
4481 *     Desc : *  PDCP Count Information for a DRB.
4482 *
4483 *
4484 *     Ret  : S16
4485 *
4486 *     Notes:
4487 *
4488 *     File  :
4489 *
4490 **********************************************************/
4491 #ifdef ANSI
4492 PUBLIC S16 cmPkPjUdxCountInfo
4493 (
4494 UdxCountInfo *param,
4495 Buffer *mBuf
4496 )
4497 #else
4498 PUBLIC S16 cmPkPjUdxCountInfo(param, mBuf)
4499 UdxCountInfo *param;
4500 Buffer *mBuf;
4501 #endif
4502 {
4503
4504    TRC3(cmPkPjUdxCountInfo)
4505
4506    CMCHKPK(SPkU32, param->dlCount, mBuf);
4507    CMCHKPK(SPkU32, param->ulCount, mBuf);
4508    CMCHKPK(SPkU8, param->dir, mBuf);
4509    CMCHKPK(SPkU8, param->rbId, mBuf);
4510    RETVALUE(ROK);
4511 }
4512
4513
4514 \f
4515 /***********************************************************
4516 *
4517 *     Func : cmUnpkPjUdxCountInfo
4518 *
4519 *
4520 *     Desc : *  PDCP Count Information for a DRB.
4521 *
4522 *
4523 *     Ret  : S16
4524 *
4525 *     Notes:
4526 *
4527 *     File  :
4528 *
4529 **********************************************************/
4530 #ifdef ANSI
4531 PUBLIC S16 cmUnpkPjUdxCountInfo
4532 (
4533 UdxCountInfo *param,
4534 Buffer *mBuf
4535 )
4536 #else
4537 PUBLIC S16 cmUnpkPjUdxCountInfo(param, mBuf)
4538 UdxCountInfo *param;
4539 Buffer *mBuf;
4540 #endif
4541 {
4542
4543    TRC3(cmUnpkPjUdxCountInfo)
4544
4545    CMCHKUNPK(SUnpkU8, &param->rbId, mBuf);
4546    CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
4547    CMCHKUNPK(SUnpkU32, &param->ulCount, mBuf);
4548    CMCHKUNPK(SUnpkU32, &param->dlCount, mBuf);
4549    RETVALUE(ROK);
4550 }
4551
4552
4553 \f
4554 /***********************************************************
4555 *
4556 *     Func : cmPkPjUdxCountCfmInfo
4557 *
4558 *
4559 *     Desc : *  PDCP Count Request Confirmation to RRC.
4560 *
4561 *
4562 *     Ret  : S16
4563 *
4564 *     Notes:
4565 *
4566 *     File  :
4567 *
4568 **********************************************************/
4569 #ifdef ANSI
4570 PUBLIC S16 cmPkPjUdxCountCfmInfo
4571 (
4572 UdxCountCfmInfo *param,
4573 Buffer *mBuf
4574 )
4575 #else
4576 PUBLIC S16 cmPkPjUdxCountCfmInfo(param, mBuf)
4577 UdxCountCfmInfo *param;
4578 Buffer *mBuf;
4579 #endif
4580 {
4581
4582    S32 i;
4583    TRC3(cmPkPjUdxCountCfmInfo)
4584
4585    CMCHKPK(SPkS16, param->reason, mBuf);
4586    CMCHKPK(SPkS16, param->status, mBuf);
4587    for (i=param->numRb-1; i >= 0; i--) {
4588       CMCHKPK(cmPkPjUdxCountInfo, &param->countInfo[i], mBuf);
4589    }
4590    CMCHKPK(SPkU8, param->numRb, mBuf);
4591    CMCHKPK(SPkU32, param->transId, mBuf);
4592    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4593    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4594    RETVALUE(ROK);
4595 }
4596
4597
4598 \f
4599 /***********************************************************
4600 *
4601 *     Func : cmUnpkPjUdxCountCfmInfo
4602 *
4603 *
4604 *     Desc : *  PDCP Count Request Confirmation to RRC.
4605 *
4606 *
4607 *     Ret  : S16
4608 *
4609 *     Notes:
4610 *
4611 *     File  :
4612 *
4613 **********************************************************/
4614 #ifdef ANSI
4615 PUBLIC S16 cmUnpkPjUdxCountCfmInfo
4616 (
4617 UdxCountCfmInfo *param,
4618 Buffer *mBuf
4619 )
4620 #else
4621 PUBLIC S16 cmUnpkPjUdxCountCfmInfo(param, mBuf)
4622 UdxCountCfmInfo *param;
4623 Buffer *mBuf;
4624 #endif
4625 {
4626
4627    S32 i;
4628    TRC3(cmUnpkPjUdxCountCfmInfo)
4629
4630    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4631    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4632    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4633    CMCHKUNPK(SUnpkU8, &param->numRb, mBuf);
4634    for (i=0; i<param->numRb; i++) {
4635       CMCHKUNPK(cmUnpkPjUdxCountInfo, &param->countInfo[i], mBuf);
4636    }
4637    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
4638    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
4639    RETVALUE(ROK);
4640 }
4641
4642 \f
4643 /***********************************************************
4644 *
4645 *     Func : cmPkPjUdxSduStaReqInfo
4646 *
4647 *
4648 *     Desc : *  PDCP SDU Status Request Information from RRC - Used for reestablishment
4649  *  during handover.
4650 *
4651 *
4652 *     Ret  : S16
4653 *
4654 *     Notes:
4655 *
4656 *     File  :
4657 *
4658 **********************************************************/
4659 #ifdef ANSI
4660 PUBLIC S16 cmPkPjUdxSduStaReqInfo
4661 (
4662 UdxSduStaReqInfo *param,
4663 Buffer *mBuf
4664 )
4665 #else
4666 PUBLIC S16 cmPkPjUdxSduStaReqInfo(param, mBuf)
4667 UdxSduStaReqInfo *param;
4668 Buffer *mBuf;
4669 #endif
4670 {
4671
4672    TRC3(cmPkPjUdxSduStaReqInfo)
4673
4674    CMCHKPK(SPkU32, param->transId, mBuf);
4675    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4676    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4677    RETVALUE(ROK);
4678 }
4679
4680
4681 \f
4682 /***********************************************************
4683 *
4684 *     Func : cmUnpkPjUdxSduStaReqInfo
4685 *
4686 *
4687 *     Desc : *  PDCP SDU Status Request Information from RRC - Used for reestablishment
4688  *  during handover.
4689 *
4690 *
4691 *     Ret  : S16
4692 *
4693 *     Notes:
4694 *
4695 *     File  :
4696 *
4697 **********************************************************/
4698 #ifdef ANSI
4699 PUBLIC S16 cmUnpkPjUdxSduStaReqInfo
4700 (
4701 UdxSduStaReqInfo *param,
4702 Buffer *mBuf
4703 )
4704 #else
4705 PUBLIC S16 cmUnpkPjUdxSduStaReqInfo(param, mBuf)
4706 UdxSduStaReqInfo *param;
4707 Buffer *mBuf;
4708 #endif
4709 {
4710
4711    TRC3(cmUnpkPjUdxSduStaReqInfo)
4712
4713    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4714    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4715    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
4716    RETVALUE(ROK);
4717 }
4718
4719 \f
4720 /***********************************************************
4721 *
4722 *     Func : cmPkPjUdxDlSduStaInfo
4723 *
4724 *
4725 *     Desc : *  PDCP DL SDU Status Information for a DRB mapped to RLC AM.
4726 *
4727 *
4728 *     Ret  : S16
4729 *
4730 *     Notes:
4731 *
4732 *     File  :
4733 *
4734 **********************************************************/
4735 #ifdef ANSI
4736 PUBLIC S16 cmPkPjUdxDlSduStaInfo
4737 (
4738 UdxDlSduStaInfo *param,
4739 Buffer *mBuf
4740 )
4741 #else
4742 PUBLIC S16 cmPkPjUdxDlSduStaInfo(param, mBuf)
4743 UdxDlSduStaInfo *param;
4744 Buffer *mBuf;
4745 #endif
4746 {
4747
4748    TRC3(cmPkPjUdxDlSduStaInfo)
4749
4750    CMCHKPK(cmPkBool, param->hoPres, mBuf);
4751    CMCHKPK(SPkU32, param->count, mBuf);
4752    RETVALUE(ROK);
4753 }
4754
4755
4756 \f
4757 /***********************************************************
4758 *
4759 *     Func : cmUnpkPjUdxDlSduStaInfo
4760 *
4761 *
4762 *     Desc : *  PDCP DL SDU Status Information for a DRB mapped to RLC AM.
4763 *
4764 *
4765 *     Ret  : S16
4766 *
4767 *     Notes:
4768 *
4769 *     File  :
4770 *
4771 **********************************************************/
4772 #ifdef ANSI
4773 PUBLIC S16 cmUnpkPjUdxDlSduStaInfo
4774 (
4775 UdxDlSduStaInfo *param,
4776 Buffer *mBuf
4777 )
4778 #else
4779 PUBLIC S16 cmUnpkPjUdxDlSduStaInfo(param, mBuf)
4780 UdxDlSduStaInfo *param;
4781 Buffer *mBuf;
4782 #endif
4783 {
4784
4785    TRC3(cmUnpkPjUdxDlSduStaInfo)
4786
4787    CMCHKUNPK(cmUnpkBool, &param->hoPres, mBuf);
4788    CMCHKUNPK(SUnpkU32, &param->count, mBuf);
4789    RETVALUE(ROK);
4790 }
4791
4792
4793 \f
4794 /***********************************************************
4795 *
4796 *     Func : cmPkPjUdxSduStaInfo
4797 *
4798 *
4799 *     Desc : *  PDCP SDU Status Information for a DRB mapped to RLC AM.
4800 *
4801 *
4802 *     Ret  : S16
4803 *
4804 *     Notes:
4805 *
4806 *     File  :
4807 *
4808 **********************************************************/
4809 #ifdef ANSI
4810 PUBLIC S16 cmPkPjUdxSduStaInfo
4811 (
4812 Pst *pst,
4813 UdxSduStaInfo *param,
4814 Buffer *mBuf
4815 )
4816 #else
4817 PUBLIC S16 cmPkPjUdxSduStaInfo(pst, param, mBuf)
4818 Pst *pst;
4819 UdxSduStaInfo *param;
4820 Buffer *mBuf;
4821 #endif
4822 {
4823    TRC3(cmPkPjUdxSduStaInfo)
4824
4825    CMCHKPK(cmPkPjUdxDlSduStaInfo, &param->dlSduStaInfo, mBuf);
4826    CMCHKPK(SPkU8, param->dir, mBuf);
4827    CMCHKPK(SPkU8, param->rbId, mBuf);
4828    RETVALUE(ROK);
4829 }
4830
4831
4832 \f
4833 /***********************************************************
4834 *
4835 *     Func : cmUnpkPjUdxSduStaInfo
4836 *
4837 *
4838 *     Desc : *  PDCP SDU Status Information for a DRB mapped to RLC AM.
4839 *
4840 *
4841 *     Ret  : S16
4842 *
4843 *     Notes:
4844 *
4845 *     File  :
4846 *
4847 **********************************************************/
4848 #ifdef ANSI
4849 PUBLIC S16 cmUnpkPjUdxSduStaInfo
4850 (
4851 Pst *pst,
4852 UdxSduStaInfo *param,
4853 Buffer *mBuf
4854 )
4855 #else
4856 PUBLIC S16 cmUnpkPjUdxSduStaInfo(pst, param, mBuf)
4857 Pst *pst;
4858 UdxSduStaInfo *param;
4859 Buffer *mBuf;
4860 #endif
4861 {
4862    TRC3(cmUnpkPjUdxSduStaInfo)
4863
4864    CMCHKUNPK(SUnpkU8, &param->rbId, mBuf);
4865    CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
4866
4867    CMCHKUNPK(cmUnpkPjUdxDlSduStaInfo, &param->dlSduStaInfo, mBuf);
4868    RETVALUE(ROK);
4869 }
4870
4871
4872 \f
4873 /***********************************************************
4874 *
4875 *     Func : cmPkPjUdxSduStaCfmInfo
4876 *
4877 *
4878 *     Desc : *  PDCP SDU Status Request Confirmation for an UE.
4879 *
4880 *
4881 *     Ret  : S16
4882 *
4883 *     Notes:
4884 *
4885 *     File  :
4886 *
4887 **********************************************************/
4888 #ifdef ANSI
4889 PUBLIC S16 cmPkPjUdxSduStaCfmInfo
4890 (
4891 Pst *pst,
4892 UdxSduStaCfmInfo *param,
4893 Buffer *mBuf
4894 )
4895 #else
4896 PUBLIC S16 cmPkPjUdxSduStaCfmInfo(pst, param, mBuf)
4897 Pst *pst;
4898 UdxSduStaCfmInfo *param;
4899 Buffer *mBuf;
4900 #endif
4901 {
4902    S32 i;
4903
4904    TRC3(cmPkPjUdxSduStaCfmInfo)
4905
4906    CMCHKPK(SPkS16, param->reason, mBuf);
4907    CMCHKPK(SPkS16, param->status, mBuf);
4908    for (i=param->numRb-1; i >= 0; i--) {
4909       if (cmPkPjUdxSduStaInfo(pst, &param->sduStaInfo[i], mBuf) != ROK)
4910          RETVALUE(RFAILED);
4911    }
4912    CMCHKPK(SPkU8, param->numRb, mBuf);
4913    CMCHKPK(SPkU32, param->transId, mBuf);
4914    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4915    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4916    RETVALUE(ROK);
4917 }
4918
4919 \f
4920 /***********************************************************
4921 *
4922 *     Func : cmPkPjUdxDatResumeCfmInfo
4923 *
4924 *
4925 *     Desc : *  PDCP SDU Status Request Confirmation for an UE.
4926 *
4927 *
4928 *     Ret  : S16
4929 *
4930 *     Notes:
4931 *
4932 *     File  :
4933 *
4934 **********************************************************/
4935 #ifdef ANSI
4936 PUBLIC S16 cmPkPjUdxDatResumeCfmInfo
4937 (
4938 Pst *pst,
4939 UdxDatResumeCfmInfo *param,
4940 Buffer *mBuf
4941 )
4942 #else
4943 PUBLIC S16 cmPkPjUdxDatResumeCfmInfo(pst, param, mBuf)
4944 Pst *pst;
4945 UdxDatResumeCfmInfo *param;
4946 Buffer *mBuf;
4947 #endif
4948 {
4949
4950    TRC3(cmPkPjUdxDatResumeCfmInfo)
4951
4952    CMCHKPK(SPkS16, param->reason, mBuf);
4953    CMCHKPK(SPkS16, param->status, mBuf);
4954    CMCHKPK(SPkU32, param->transId, mBuf);
4955    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4956    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4957    RETVALUE(ROK);
4958 }
4959
4960 #ifdef ANSI
4961 PUBLIC S16 cmPkPjUdxDatForwardCfmInfo
4962 (
4963 Pst *pst,
4964 UdxDatFwdCfmInfo *param,
4965 Buffer *mBuf
4966  )
4967 #else
4968 PUBLIC S16 cmPkPjUdxDatForwardCfmInfo(pst, param, mBuf)
4969 Pst *pst;
4970 UdxDatFwdCfmInfo *param;
4971 Buffer *mBuf;
4972 #endif
4973 {
4974    TRC3(cmPkPjUdxDatForwardCfmInfo)
4975
4976    CMCHKPK(SPkS16, param->reason, mBuf);
4977    CMCHKPK(SPkS16, param->status, mBuf);
4978    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4979    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4980    RETVALUE(ROK);
4981 }
4982 /*
4983 *
4984 *    Fun:    cmPkPjUdxDlFdbkPktInfo
4985 *
4986 *    Desc:    pack the structure UdxDlFdbPktInfo
4987 *
4988 *    Ret:    ROK  -ok
4989 *
4990 *    Notes:    None
4991 *
4992 *    File:     pj_udx.c
4993 *
4994 */
4995 #ifdef ANSI
4996 PUBLIC S16 cmPkPjUdxDlFdbkPktInfo
4997 (
4998 UdxDlFdbkPktInfo  *param,
4999 Pst            *pst,
5000 Buffer         *mBuf
5001 )
5002 #else
5003 PUBLIC S16 cmPkPjUdxDlFdbkPktInfo(param, pst, mBuf)
5004 UdxDlFdbkPktInfo  *param;
5005 Pst            *pst;
5006 Buffer         *mBuf;
5007 #endif
5008 {
5009    S16 msgLen;
5010    TRC3(cmPkPjUdxDlFdbkPktInfo)
5011
5012    CMCHKPK(SPkU8, param->pdcpId.rbType, mBuf);
5013    CMCHKPK(cmPkLteRbId, param->pdcpId.rbId, mBuf);
5014    CMCHKPK(cmPkLteRnti, param->pdcpId.ueId, mBuf);
5015    CMCHKPK(cmPkLteCellId, param->pdcpId.cellId, mBuf);
5016
5017    if (SFndLenMsg(param->fbPkt, &msgLen) != ROK)
5018       RETVALUE(RFAILED);
5019    if (SCatMsg(mBuf, param->fbPkt, M1M2) != ROK)
5020       RETVALUE(RFAILED);
5021    PJ_FREE_BUF(mBuf);
5022    CMCHKPK(SPkS16, msgLen, mBuf);
5023
5024    RETVALUE(ROK);
5025 } /* cmPkPjUdxDlFdbkPktInfo */
5026
5027 \f
5028 /***********************************************************
5029 *
5030 *     Func : cmUnpkPjUdxSduStaCfmInfo
5031 *
5032 *
5033 *     Desc : *  PDCP SDU Status Request Confirmation for an UE.
5034 *
5035 *
5036 *     Ret  : S16
5037 *
5038 *     Notes:
5039 *
5040 *     File  :
5041 *
5042 **********************************************************/
5043 #ifdef ANSI
5044 PUBLIC S16 cmUnpkPjUdxSduStaCfmInfo
5045 (
5046 Pst *pst,
5047 UdxSduStaCfmInfo *param,
5048 Buffer *mBuf
5049 )
5050 #else
5051 PUBLIC S16 cmUnpkPjUdxSduStaCfmInfo(pst, param, mBuf)
5052 Pst *pst;
5053 UdxSduStaCfmInfo *param;
5054 Buffer *mBuf;
5055 #endif
5056 {
5057
5058    S32 i;
5059    TRC3(cmUnpkPjUdxSduStaCfmInfo)
5060
5061    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
5062    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5063    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
5064    CMCHKUNPK(SUnpkU8, &param->numRb, mBuf);
5065    for (i=0; i<param->numRb; i++) {
5066       if (cmUnpkPjUdxSduStaInfo(pst, &param->sduStaInfo[i], mBuf) != ROK)
5067          RETVALUE(RFAILED);
5068    }
5069    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
5070    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
5071    RETVALUE(ROK);
5072 }
5073
5074 \f
5075 /***********************************************************
5076 *
5077 *     Func : cmUnpkPjUdxDatResumeCfmInfo
5078 *
5079 *
5080 *     Desc : *  PDCP SDU Status Request Confirmation for an UE.
5081 *
5082 *
5083 *     Ret  : S16
5084 *
5085 *     Notes:
5086 *
5087 *     File  :
5088 *
5089 **********************************************************/
5090 #ifdef ANSI
5091 PUBLIC S16 cmUnpkPjUdxDatResumeCfmInfo
5092 (
5093 Pst *pst,
5094 UdxDatResumeCfmInfo *param,
5095 Buffer *mBuf
5096 )
5097 #else
5098 PUBLIC S16 cmUnpkPjUdxDatResumeCfmInfo(pst, param, mBuf)
5099 Pst *pst;
5100 UdxDatResumeCfmInfo *param;
5101 Buffer *mBuf;
5102 #endif
5103 {
5104
5105    TRC3(cmUnpkPjUdxDatResumeCfmInfo)
5106
5107    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
5108    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5109    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
5110    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
5111    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
5112    RETVALUE(ROK);
5113 }
5114 /***********************************************************
5115 *
5116 *     Func : cmUnpkPjUdxDatForwardCfm
5117 *
5118 *
5119 *     Desc : *  PDCP Data Forward Confirmation for an UE.
5120 *
5121 *
5122 *     Ret  : S16
5123 *
5124 *     Notes:
5125 *
5126 *     File  :
5127 *
5128 **********************************************************/
5129 #ifdef ANSI
5130 PUBLIC S16 cmUnpkPjUdxDatForwardCfmInfo
5131 (
5132 Pst *pst,
5133 UdxDatFwdCfmInfo *param,
5134 Buffer *mBuf
5135 )
5136 #else
5137 PUBLIC S16 cmUnpkPjUdxDatForwardCfmInfo(pst, param, mBuf)
5138 Pst *pst;
5139 UdxDatFwdCfmInfo *param;
5140 Buffer *mBuf;
5141 #endif
5142 {
5143
5144    TRC3(cmUnpkPjUdxDatForwardCfmInfo)
5145
5146    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
5147    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5148    CMCHKUNPK(SUnpkS16, &param->status, mBuf);
5149    CMCHKUNPK(SUnpkS16, &param->reason, mBuf);
5150    RETVALUE(ROK);
5151 }
5152
5153
5154 #ifdef ANSI
5155 PUBLIC S16 cmPkPjUdxUlFdbkPkt
5156 (
5157 Pst * pst,
5158 SpId spId,
5159 UdxUlFdbkPktInfo *fdbkPktInfo
5160 )
5161 #else
5162 PUBLIC S16 cmPkPjUdxUlFdbkPkt(pst, spId, fdbkPktInfo)
5163 Pst * pst;
5164 SpId spId;
5165 UdxUlFdbkPktInfo *fdbkPktInfo;
5166 #endif
5167 {
5168    S16 ret;
5169    Buffer *mBuf;
5170    mBuf = NULLP;
5171
5172    TRC3(cmPkPjUdxUlFdbkPkt)
5173
5174    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
5175 #if (ERRCLASS & ERRCLS_ADD_RES)
5176       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5177          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5178          (ErrVal)EUDX016, (ErrVal)0, "Packing failed");
5179 #endif
5180       PJ_FREE_BUF(mBuf);
5181       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPktInfo, sizeof(UdxUlFdbkPktInfo));
5182
5183       RETVALUE(RFAILED);
5184    }
5185
5186    switch(pst->selector)
5187    {
5188 #ifdef LCUDX
5189       case UDX_SEL_LC:
5190          {
5191             ret = cmPkPjUdxUlFdbkPktInfo( (fdbkPktInfo), pst, mBuf);
5192 #if (ERRCLASS & ERRCLS_ADD_RES)
5193             if(ret != ROK)
5194             {
5195                PJ_FREE_BUF(mBuf);
5196                PJ_FREE_BUF(fdbkPktInfo->fbPkt);
5197                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPktInfo, sizeof(UdxUlFdbkPktInfo));
5198
5199                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5200                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5201                      (ErrVal)EUDXXXX, (ErrVal)ret, "Packing failure");
5202                RETVALUE( ret );
5203             }
5204 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5205             PJ_FREE_BUF(fdbkPktInfo->fbPkt);
5206 #ifndef XEON_SPECIFIC_CHANGES
5207             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)fdbkPktInfo,
5208                      sizeof(UdxUlFdbkPktInfo), 0) != ROK)
5209 #else
5210             if (SPutSBuf(pst->region, pst->pool, (Data *)fdbkPktInfo,
5211                      sizeof(UdxUlFdbkPktInfo)) != ROK)
5212 #endif
5213             {
5214                PJ_FREE_BUF(mBuf);
5215                RETVALUE(RFAILED);
5216             }
5217
5218             break;
5219          }
5220        case UDX_SEL_LWLC:
5221          {
5222             CMCHKPKLOG(cmPkPtr,(PTR)fdbkPktInfo,mBuf,EUDXXXX,pst);
5223             break;
5224          }
5225 #endif /* LCUDX */
5226    }
5227
5228    CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
5229    pst->event = (Event) EVTUDXULROHCFDB;
5230
5231    RETVALUE(SPstTsk(pst,mBuf));
5232 }
5233
5234 #ifdef ANSI
5235 PUBLIC S16 cmPkPjUdxDlFdbkPkt
5236 (
5237 Pst * pst,
5238 SpId spId,
5239 UdxDlFdbkPktInfo *fdbkPktInfo
5240 )
5241 #else
5242 PUBLIC S16 cmPkPjUdxDlFdbkPkt(pst, spId, fdbkPktInfo)
5243 Pst * pst;
5244 SpId spId;
5245 UdxDlFdbkPktInfo *fdbkPktInfo;
5246 #endif
5247 {
5248    S16 ret;
5249    Buffer *mBuf;
5250    mBuf = NULLP;
5251
5252    TRC3(cmPkPjUdxDlFdbkPkt)
5253
5254    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
5255 #if (ERRCLASS & ERRCLS_ADD_RES)
5256       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5257          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5258          (ErrVal)EUDX016, (ErrVal)0, "Packing failed");
5259 #endif
5260       PJ_FREE_BUF(mBuf);
5261       PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPktInfo, sizeof(UdxUlFdbkPktInfo));
5262
5263       RETVALUE(RFAILED);
5264    }
5265
5266    switch(pst->selector)
5267    {
5268 #ifdef LCUDX
5269       case UDX_SEL_LC:
5270          {
5271             ret = cmPkPjUdxDlFdbkPktInfo( (fdbkPktInfo), pst, mBuf);
5272 #if (ERRCLASS & ERRCLS_ADD_RES)
5273             if(ret != ROK)
5274             {
5275                PJ_FREE_BUF(mBuf);
5276                PJ_FREE_BUF(fdbkPktInfo->fbPkt);
5277                PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPktInfo, sizeof(UdxUlFdbkPktInfo));
5278
5279                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5280                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5281                      (ErrVal)EUDXXXX, (ErrVal)ret, "Packing failure");
5282                RETVALUE( ret );
5283             }
5284 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5285             PJ_FREE_BUF(fdbkPktInfo->fbPkt);
5286 #ifndef XEON_SPECIFIC_CHANGES
5287             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)fdbkPktInfo,
5288                      sizeof(UdxDlFdbkPktInfo), 0) != ROK)
5289 #else
5290             if (SPutSBuf(pst->region, pst->pool, (Data *)fdbkPktInfo,
5291                      sizeof(UdxDlFdbkPktInfo)) != ROK)
5292 #endif
5293             {
5294                PJ_FREE_BUF(mBuf);
5295                RETVALUE(RFAILED);
5296             }
5297
5298             break;
5299          }
5300        case UDX_SEL_LWLC:
5301          {
5302             CMCHKPKLOG(cmPkPtr,(PTR)fdbkPktInfo,mBuf,EUDXXXX,pst);
5303             break;
5304          }
5305 #endif /* LCUDX */
5306    }
5307
5308    CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
5309    pst->event = (Event) EVTUDXDLROHCFDB;
5310
5311    RETVALUE(SPstTsk(pst,mBuf));
5312 }
5313
5314 /*
5315 *
5316 *    Fun:    cmPkPjUdxUlFdbkPktInfo
5317 *
5318 *    Desc:    pack the structure UdxUlFdbPktInfo
5319 *
5320 *    Ret:    ROK  -ok
5321 *
5322 *    Notes:    None
5323 *
5324 *    File:     pj_udx.c
5325 *
5326 */
5327 #ifdef ANSI
5328 PUBLIC S16 cmPkPjUdxUlFdbkPktInfo
5329 (
5330 UdxUlFdbkPktInfo  *param,
5331 Pst            *pst,
5332 Buffer         *mBuf
5333 )
5334 #else
5335 PUBLIC S16 cmPkPjUdxUlFdbkPktInfo(param, pst, mBuf)
5336 UdxUlFdbkPktInfo  *param;
5337 Pst            *pst;
5338 Buffer         *mBuf;
5339 #endif
5340 {
5341    S16 msgLen;
5342    TRC3(cmPkPjUdxUlFdbkPktInfo)
5343
5344    CMCHKPK(SPkU8, param->pdcpId.rbType, mBuf);
5345    CMCHKPK(cmPkLteRbId, param->pdcpId.rbId, mBuf);
5346    CMCHKPK(cmPkLteRnti, param->pdcpId.ueId, mBuf);
5347    CMCHKPK(cmPkLteCellId, param->pdcpId.cellId, mBuf);
5348
5349    if (SFndLenMsg(param->fbPkt, &msgLen) != ROK)
5350       RETVALUE(RFAILED);
5351    if (SCatMsg(mBuf, param->fbPkt, M1M2) != ROK)
5352       RETVALUE(RFAILED);
5353    PJ_FREE_BUF(param->fbPkt);
5354    CMCHKPK(SPkS16, msgLen, mBuf);
5355
5356    RETVALUE(ROK);
5357 } /* cmPkPjUdxUlFdbkPktInfo */
5358
5359
5360 #ifdef ANSI
5361 PUBLIC S16 cmUnpkPjUdxDlFdbkPkt
5362 (
5363 UdxDlFdbkPkt func,
5364 Pst *pst,
5365 Buffer *mBuf
5366 )
5367 #else
5368 PUBLIC S16 cmUnpkPjUdxDlFdbkPkt(func, pst, mBuf)
5369 UdxDlFdbkPkt func;
5370 Pst *pst;
5371 Buffer *mBuf;
5372 #endif
5373 {
5374    S16   ret1;
5375    SpId  spId;
5376    UdxDlFdbkPktInfo *fdbkPkt;
5377
5378    TRC3(cmUnpkPjUdxDlFdbkPkt)
5379
5380    if (SUnpkS16(&spId, mBuf) != ROK) {
5381       PJ_FREE_BUF(mBuf);
5382 #if (ERRCLASS & ERRCLS_ADD_RES)
5383       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5384          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5385          (ErrVal)EUDX021, (ErrVal)0, "Unpacking failed");
5386 #endif
5387       RETVALUE(RFAILED);
5388    }
5389
5390    switch(pst->selector)
5391    {
5392 #ifdef LCUDX
5393        case UDX_SEL_LC:
5394        {
5395           if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&fdbkPkt,\
5396                       sizeof(UdxDlFdbkPktInfo))) != ROK)
5397           {
5398 #if (ERRCLASS & ERRCLS_ADD_RES)
5399               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5400                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5401                     (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
5402 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5403
5404               PJ_FREE_BUF(mBuf);
5405              RETVALUE(ret1);
5406           }
5407
5408           if (cmUnpkPjUdxDlFdbkPktInfo(pst, fdbkPkt, mBuf) != ROK)
5409           {
5410              PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPkt, sizeof(UdxDlFdbkPktInfo));
5411              PJ_FREE_BUF(mBuf);
5412 #if (ERRCLASS & ERRCLS_ADD_RES)
5413              SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5414                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5415                 (ErrVal)EUDX023, (ErrVal)0, "Unpacking failed");
5416 #endif
5417              RETVALUE(RFAILED);
5418           }
5419
5420           break;
5421        }
5422
5423        case UDX_SEL_LWLC:
5424        {
5425           CMCHKUNPK(cmUnpkPtr,(PTR *) &fdbkPkt, mBuf);
5426           break;
5427        }
5428 #endif /* LCUDX */
5429    }
5430
5431    PJ_FREE_BUF(mBuf);
5432
5433    RETVALUE((*func)(pst, spId, fdbkPkt));
5434 }
5435
5436
5437 #ifdef ANSI
5438 PUBLIC S16 cmUnpkPjUdxDlFdbPktInfo
5439 (
5440 Pst *pst,
5441 UdxDlFdbkPktInfo *param,
5442 Buffer *mBuf
5443 )
5444 #else
5445 PUBLIC S16 cmUnpkPjUdxDlFdbPktInfo(pst, param, mBuf)
5446 Pst *pst;
5447 UdxDlFdbkPktInfo *param;
5448 Buffer *mBuf;
5449 #endif
5450 {
5451    MsgLen msgLen=0;
5452    MsgLen totalMsgLen;
5453
5454    TRC3(cmUnpkPjUdxDlFdbPktInfo);
5455
5456    CMCHKUNPK(SUnpkU8, &param->pdcpId.rbType, mBuf);
5457    CMCHKUNPK(cmUnpkLteRbId, &param->pdcpId.rbId, mBuf);
5458    CMCHKUNPK(cmUnpkLteRnti, &param->pdcpId.ueId, mBuf);
5459    CMCHKUNPK(cmUnpkLteCellId, &param->pdcpId.cellId, mBuf);
5460
5461    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
5462       RETVALUE(RFAILED);
5463
5464    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->fbPkt) != ROK)
5465       RETVALUE(RFAILED);
5466
5467    RETVALUE(ROK);
5468 }
5469
5470
5471 #ifdef ANSI
5472 PUBLIC S16 cmUnpkPjUdxUlStaRep
5473 (
5474 UdxUlStaRep func,
5475 Pst *pst,
5476 Buffer *mBuf
5477 )
5478 #else
5479 PUBLIC S16 cmUnpkPjUdxUlStaRep(func, pst, mBuf)
5480 UdxUlStaRep func;
5481 Pst *pst;
5482 Buffer *mBuf;
5483 #endif
5484 {
5485    S16   ret1;
5486    SpId  spId;
5487    UdxUlStaRepInfo *staRep;
5488
5489    TRC3(cmUnpkPjUdxUlStaRep)
5490
5491    if (SUnpkS16(&spId, mBuf) != ROK) {
5492       PJ_FREE_BUF(mBuf);
5493 #if (ERRCLASS & ERRCLS_ADD_RES)
5494       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5495          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5496          (ErrVal)EUDX021, (ErrVal)0, "Unpacking failed");
5497 #endif
5498       RETVALUE(RFAILED);
5499    }
5500
5501     switch(pst->selector)
5502     {
5503 #ifdef LCUDX
5504        case UDX_SEL_LC:
5505        {
5506           if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&staRep,\
5507                       sizeof(UdxUlStaRepInfo))) != ROK)
5508           {
5509 #if (ERRCLASS & ERRCLS_ADD_RES)
5510               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5511                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5512                     (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
5513 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5514
5515               PJ_FREE_BUF(mBuf);
5516              RETVALUE(ret1);
5517           }
5518
5519           if (cmUnpkPjUdxUlStaRepInfo(pst, staRep, mBuf) != ROK)
5520           {
5521              PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staRep, sizeof(UdxUlStaRepInfo));
5522              PJ_FREE_BUF(mBuf);
5523 #if (ERRCLASS & ERRCLS_ADD_RES)
5524              SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5525                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5526                 (ErrVal)EUDX023, (ErrVal)0, "Unpacking failed");
5527 #endif
5528              RETVALUE(RFAILED);
5529           }
5530
5531           break;
5532        }
5533
5534        case UDX_SEL_LWLC:
5535        {
5536           CMCHKUNPK(cmUnpkPtr,(PTR *) &staRep, mBuf);
5537           break;
5538        }
5539 #endif /* LCUDX */
5540    }
5541
5542     PJ_FREE_BUF(mBuf);
5543
5544    RETVALUE((*func)(pst, spId, staRep));
5545 }
5546
5547 #ifdef ANSI
5548 PUBLIC S16 cmUnpkPjUdxDlStaRep
5549 (
5550 UdxDlStaRep func,
5551 Pst *pst,
5552 Buffer *mBuf
5553 )
5554 #else
5555 PUBLIC S16 cmUnpkPjUdxDlStaRep(func, pst, mBuf)
5556 UdxDlStaRep func;
5557 Pst *pst;
5558 Buffer *mBuf;
5559 #endif
5560 {
5561    S16   ret1;
5562    SpId  spId;
5563    UdxDlStaRepInfo *staRep;
5564
5565    TRC3(cmUnpkPjUdxDlStaRep)
5566
5567    if (SUnpkS16(&spId, mBuf) != ROK) {
5568       PJ_FREE_BUF(mBuf);
5569 #if (ERRCLASS & ERRCLS_ADD_RES)
5570       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5571          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5572          (ErrVal)EUDX021, (ErrVal)0, "Unpacking failed");
5573 #endif
5574       RETVALUE(RFAILED);
5575    }
5576
5577     switch(pst->selector)
5578     {
5579 #ifdef LCUDX
5580        case UDX_SEL_LC:
5581        {
5582           if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&staRep,\
5583                       sizeof(UdxDlStaRepInfo))) != ROK)
5584           {
5585 #if (ERRCLASS & ERRCLS_ADD_RES)
5586               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5587                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5588                     (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
5589 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5590
5591               PJ_FREE_BUF(mBuf);
5592              RETVALUE(ret1);
5593           }
5594
5595           if (cmUnpkPjUdxDlStaRepInfo(pst, staRep, mBuf) != ROK)
5596           {
5597              PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, staRep, sizeof(UdxDlStaRepInfo));
5598              PJ_FREE_BUF(mBuf);
5599 #if (ERRCLASS & ERRCLS_ADD_RES)
5600              SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5601                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5602                 (ErrVal)EUDX023, (ErrVal)0, "Unpacking failed");
5603 #endif
5604              RETVALUE(RFAILED);
5605           }
5606
5607           break;
5608        }
5609
5610        case UDX_SEL_LWLC:
5611        {
5612           CMCHKUNPK(cmUnpkPtr,(PTR *) &staRep, mBuf);
5613           break;
5614        }
5615 #endif /* LCUDX */
5616    }
5617
5618     PJ_FREE_BUF(mBuf);
5619
5620    RETVALUE((*func)(pst, spId, staRep));
5621 }
5622
5623 #ifdef ANSI
5624 PUBLIC S16 cmUnpkPjUdxUlFdbkPkt
5625 (
5626 UdxUlFdbkPkt func,
5627 Pst *pst,
5628 Buffer *mBuf
5629 )
5630 #else
5631 PUBLIC S16 cmUnpkPjUdxUlFdbkPkt(func, pst, mBuf)
5632 UdxUlFdbkPkt func;
5633 Pst *pst;
5634 Buffer *mBuf;
5635 #endif
5636 {
5637    S16   ret1;
5638    SpId  spId;
5639    UdxUlFdbkPktInfo *fdbkPkt;
5640
5641    TRC3(cmUnpkPjUdxUlFdbkPkt)
5642
5643    if (SUnpkS16(&spId, mBuf) != ROK) {
5644       PJ_FREE_BUF(mBuf);
5645 #if (ERRCLASS & ERRCLS_ADD_RES)
5646       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5647          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5648          (ErrVal)EUDX021, (ErrVal)0, "Unpacking failed");
5649 #endif
5650       RETVALUE(RFAILED);
5651    }
5652
5653    switch(pst->selector)
5654    {
5655 #ifdef LCUDX
5656        case UDX_SEL_LC:
5657        {
5658           if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&fdbkPkt,\
5659                       sizeof(UdxUlFdbkPktInfo))) != ROK)
5660           {
5661 #if (ERRCLASS & ERRCLS_ADD_RES)
5662               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5663                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5664                     (ErrVal)EUDX040, (ErrVal)0, "SGetMsg() failed");
5665 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5666
5667               PJ_FREE_BUF(mBuf);
5668              RETVALUE(ret1);
5669           }
5670
5671           if (cmUnpkPjUdxUlFdbkPktInfo(pst, fdbkPkt, mBuf) != ROK)
5672           {
5673              PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, fdbkPkt, sizeof(UdxUlFdbkPktInfo));
5674              PJ_FREE_BUF(mBuf);
5675 #if (ERRCLASS & ERRCLS_ADD_RES)
5676              SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5677                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5678                 (ErrVal)EUDX023, (ErrVal)0, "Unpacking failed");
5679 #endif
5680              RETVALUE(RFAILED);
5681           }
5682
5683           break;
5684        }
5685
5686        case UDX_SEL_LWLC:
5687        {
5688           CMCHKUNPK(cmUnpkPtr,(PTR *) &fdbkPkt, mBuf);
5689           break;
5690        }
5691 #endif /* LCUDX */
5692    }
5693
5694    PJ_FREE_BUF(mBuf);
5695
5696    RETVALUE((*func)(pst, spId, fdbkPkt));
5697 }
5698
5699 #ifdef LTE_L2_MEAS
5700 /*
5701 *
5702 *    Fun:    cmPkPjUdxL2MeasReq
5703 *
5704 *    Ret:    ROK  -ok
5705 *
5706 *    Notes:  None
5707 *
5708 *
5709 */
5710 #ifdef ANSI
5711 PUBLIC S16 cmPkPjUdxL2MeasReq
5712 (
5713 Pst               *pst,
5714 PjL2MeasReqEvt    *measReqEvt
5715 )
5716 #else
5717 PUBLIC S16 cmPkPjUdxL2MeasReq(pst, measReqEvt)
5718 Pst               *pst;
5719 PjL2MeasReqEvt    *measReqEvt;
5720 #endif
5721 {
5722     S16    ret1;
5723     Buffer *mBuf = NULLP;
5724
5725     TRC3(cmPkPjUdxL2MeasReq)
5726
5727     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
5728     {
5729 #if (ERRCLASS & ERRCLS_ADD_RES)
5730        if(ret1 != ROK)
5731        {
5732           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5733                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5734                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
5735        }
5736 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5737
5738        RETVALUE(ret1);
5739     }
5740
5741     switch (pst->selector)
5742     {
5743        case UDX_SEL_LC:
5744        {
5745        }
5746        case UDX_SEL_LWLC:
5747        {
5748          CMCHKPK(cmPkPtr,(PTR) measReqEvt, mBuf);
5749          break;
5750        }
5751     }
5752     pst->event = (Event) PJ_UDX_EVT_L2MEAS_REQ;
5753
5754     RETVALUE(SPstTsk(pst, mBuf));
5755
5756 } /* cmPkPjUdxStaUpdReq */
5757
5758 /*
5759 *
5760 *    Fun:    cmPkPjUdxL2MeasSendReq
5761 *
5762 *    Ret:    ROK  -ok
5763 *
5764 *    Notes:  None
5765 *
5766 *
5767 */
5768 #ifdef ANSI
5769 PUBLIC S16 cmPkPjUdxL2MeasSendReq
5770 (
5771 Pst              *pst,
5772 U8               measType
5773 )
5774 #else
5775 PUBLIC S16 cmPkPjUdxL2MeasSendReq(pst, measReqEvt)
5776 Pst               *pst;
5777 U8                measType
5778 #endif
5779 {
5780     S16    ret1;
5781     Buffer *mBuf = NULLP;
5782
5783     TRC3(cmPkPjUdxL2MeasSendReq)
5784
5785     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
5786     {
5787 #if (ERRCLASS & ERRCLS_ADD_RES)
5788        if(ret1 != ROK)
5789        {
5790           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5791                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5792                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
5793        }
5794 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5795
5796        RETVALUE(ret1);
5797     }
5798
5799     switch (pst->selector)
5800     {
5801        case UDX_SEL_LC:
5802        {
5803        }
5804        case UDX_SEL_LWLC:
5805        {
5806           CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
5807           break;
5808        }
5809     }
5810     pst->event = (Event) PJ_UDX_EVT_L2MEAS_SEND_REQ;
5811
5812     RETVALUE(SPstTsk(pst, mBuf));
5813
5814 }
5815
5816 /*
5817 *
5818 *    Fun:    cmPkPjUdxL2MeasStopReq
5819 *
5820 *    Ret:    ROK  -ok
5821 *
5822 *    Notes:  None
5823 *
5824 *
5825 */
5826 #ifdef ANSI
5827 PUBLIC S16 cmPkPjUdxL2MeasStopReq
5828 (
5829 Pst              *pst,
5830 U8               measType
5831 )
5832 #else
5833 PUBLIC S16 cmPkPjUdxL2MeasStopReq(pst, measType)
5834 Pst               *pst;
5835 U8                measType
5836 #endif
5837 {
5838     S16    ret1;
5839     Buffer *mBuf = NULLP;
5840
5841     TRC3(cmPkPjUdxL2MeasStopReq)
5842
5843     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
5844     {
5845 #if (ERRCLASS & ERRCLS_ADD_RES)
5846        if(ret1 != ROK)
5847        {
5848           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5849                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5850                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
5851        }
5852 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
5853
5854        RETVALUE(ret1);
5855     }
5856
5857     switch (pst->selector)
5858     {
5859        case UDX_SEL_LC:
5860        {
5861        }
5862        case UDX_SEL_LWLC:
5863        {
5864           CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
5865           break;
5866        }
5867     }
5868     pst->event = (Event) PJ_UDX_EVT_L2MEAS_STOP_REQ;
5869
5870     RETVALUE(SPstTsk(pst, mBuf));
5871
5872 }
5873
5874 /*
5875
5876
5877 *    Fun:    cmUnpkPjUdxL2MeasReq
5878 *
5879 *    Ret:    ROK  -ok
5880 *
5881 *    Notes:  None
5882 *
5883 *
5884 */
5885 #ifdef ANSI
5886 PUBLIC S16 cmUnpkPjUdxL2MeasReq
5887 (
5888 UdxL2MeasReq     func,
5889 Pst              *pst,
5890 Buffer           *mBuf
5891 )
5892 #else
5893 PUBLIC S16 cmUnpkPjUdxL2MeasReq(func, pst, mBuf)
5894 UdxL2MeasReq     func;
5895 Pst              *pst;
5896 Buffer           *mBuf;
5897 #endif
5898 {
5899    // S16    ret1;
5900     PjL2MeasReqEvt    *measReqEvt;
5901
5902     TRC3(cmUnpkPjUdxL2MeasReq)
5903
5904     switch (pst->selector)
5905     {
5906        case UDX_SEL_LC:
5907        {
5908        }
5909        case UDX_SEL_LWLC:
5910        {
5911          CMCHKUNPK(cmUnpkPtr, (PTR *)&measReqEvt,mBuf);
5912          break;
5913        }
5914     }
5915
5916     SPutMsg(mBuf);
5917
5918     RETVALUE((*func)(pst, measReqEvt));
5919 } /* cmUnpkPjUdxL2MeasReq */
5920
5921 /*
5922 *
5923 *    Fun:    cmUnpkPjUdxL2MeasSendReq
5924 *
5925 *    Ret:    ROK  -ok
5926 *
5927 *    Notes:  None
5928 *
5929 *
5930 */
5931 #ifdef ANSI
5932 PUBLIC S16 cmUnpkPjUdxL2MeasSendReq
5933 (
5934 UdxL2MeasSendReq     func,
5935 Pst                  *pst,
5936 Buffer               *mBuf
5937 )
5938 #else
5939 PUBLIC S16 cmUnpkPjUdxL2MeasSendReq(func, pst, mBuf)
5940 UdxL2MeasSendReq     func;
5941 Pst                  *pst;
5942 Buffer               *mBuf;
5943 #endif
5944 {
5945     //S16    ret1;
5946     U8     measType;
5947
5948     TRC3(cmUnpkPjUdxL2MeasSendReq)
5949
5950     switch (pst->selector)
5951     {
5952        case UDX_SEL_LC:
5953        {
5954        }
5955        case UDX_SEL_LWLC:
5956        {
5957           CMCHKUNPK(SUnpkU8, &measType, mBuf);
5958          break;
5959        }
5960     }
5961
5962     SPutMsg(mBuf);
5963
5964     RETVALUE((*func)(pst, measType));
5965 } /* cmUnpkPjUdxL2MeasReq */
5966
5967 /*
5968 *
5969 *    Fun:    cmUnpkPjUdxL2MeasStopReq
5970 *
5971 *    Ret:    ROK  -ok
5972 *
5973 *    Notes:  None
5974 *
5975 *
5976 */
5977 #ifdef ANSI
5978 PUBLIC S16 cmUnpkPjUdxL2MeasStopReq
5979 (
5980 UdxL2MeasStopReq     func,
5981 Pst                  *pst,
5982 Buffer               *mBuf
5983 )
5984 #else
5985 PUBLIC S16 cmUnpkPjUdxL2MeasStopReq(func, pst, mBuf)
5986 UdxL2MeasStopReq     func;
5987 Pst                  *pst;
5988 Buffer               *mBuf;
5989 #endif
5990 {
5991     U8     measType;
5992
5993     TRC3(cmUnpkPjUdxL2MeasStopReq)
5994
5995     switch (pst->selector)
5996     {
5997        case UDX_SEL_LC:
5998        {
5999        }
6000        case UDX_SEL_LWLC:
6001        {
6002           CMCHKUNPK(SUnpkU8, &measType, mBuf);
6003          break;
6004        }
6005     }
6006
6007     SPutMsg(mBuf);
6008
6009     RETVALUE((*func)(pst, measType));
6010 } /* cmUnpkPjUdxL2MeasStopReq */
6011 #endif
6012
6013 /*
6014 *
6015 *    Fun:    cmPkPjUdxDatResumeReq
6016 *
6017 *    Ret:    ROK  -ok
6018 *
6019 *    Notes:  None
6020 *
6021 *
6022 */
6023 #ifdef ANSI
6024 PUBLIC S16 cmPkPjUdxDatResumeReq
6025 (
6026 Pst           *pst,
6027 UdxDatResumeInfo  *udxDatResumeInfo
6028 )
6029 #else
6030 PUBLIC S16 cmPkPjUdxDatResumeReq(pst, cellId, ueId)
6031 Pst           *pst;
6032 UdxDatResumeInfo  *udxDatResumeInfo;
6033 #endif
6034 {
6035     S16    ret1;
6036     Buffer *mBuf = NULLP;
6037
6038     TRC3(cmPkPjUdxDatResume)
6039
6040     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
6041     {
6042 #if (ERRCLASS & ERRCLS_ADD_RES)
6043        if(ret1 != ROK)
6044        {
6045           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
6046                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
6047                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
6048        }
6049 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
6050        PJ_FREE_SHRABL_BUF_PST(pst->region, pst->pool, (Data *)udxDatResumeInfo,sizeof(UdxDatResumeInfo));
6051        RETVALUE(ret1);
6052     }
6053
6054     switch (pst->selector)
6055     {
6056        case UDX_SEL_LC:
6057        {
6058        }
6059        case UDX_SEL_LWLC:
6060        {
6061           CMCHKPKLOG(cmPkPtr,(PTR)udxDatResumeInfo,mBuf,EUDXXXX,pst);
6062           break;
6063        }
6064     }
6065    pst->event = (Event) EVTUDXDATRESUME;
6066
6067     RETVALUE(SPstTsk(pst, mBuf));
6068
6069 } /* cmPkPjUdxDatResumeReq */
6070
6071 /*
6072 *
6073 *    Fun:    cmUnpkPjUdxDatResumeReq
6074 *
6075 *    Ret:    ROK  -ok
6076 *
6077 *    Notes:  None
6078 *
6079 *
6080 */
6081 #ifdef ANSI
6082 PUBLIC S16 cmUnpkPjUdxDatResumeReq
6083 (
6084 UdxDatResumeReq  func,
6085 Pst              *pst,
6086 Buffer           *mBuf
6087 )
6088 #else
6089 PUBLIC S16 cmUnpkPjUdxDatResumeReq(func, pst, mBuf)
6090 UdxDatResumeReq  func;
6091 Pst              *pst;
6092 Buffer           *mBuf;
6093 #endif
6094 {
6095    UdxDatResumeInfo  *datResumeInfo;
6096
6097     TRC3(cmUnpkPjUdxDatResumeReq)
6098
6099     switch (pst->selector)
6100     {
6101        case UDX_SEL_LC:
6102        {
6103        }
6104        case UDX_SEL_LWLC:
6105        {
6106           CMCHKUNPK(cmUnpkPtr,(PTR *) &datResumeInfo, mBuf);
6107          break;
6108        }
6109     }
6110
6111     SPutMsg(mBuf);
6112
6113     RETVALUE((*func)(pst, datResumeInfo));
6114 } /* cmUnpkPjUdxDatResumeReq */
6115
6116 /*
6117 *
6118 *    Fun:    cmPkPjUdxDatForwardReq
6119 *
6120 *    Ret:    ROK  -ok
6121 *
6122 *    Notes:  None
6123 *
6124 *
6125 */
6126 #ifdef ANSI
6127 PUBLIC S16 cmPkPjUdxDatForwardReq
6128 (
6129 Pst           *pst,
6130 UdxDatForwardInfo   *datFwdInfo
6131 )
6132 #else
6133 PUBLIC S16 cmPkPjUdxDatForwardReq(pst, datFwdInfo)
6134 Pst           *pst;
6135 UdxDatForwardInfo   *datFwdInfo;
6136 #endif
6137 {
6138     S16    ret1;
6139     Buffer *mBuf = NULLP;
6140
6141     TRC3(cmPkPjUdxDatForwardReq)
6142
6143     RLOG0(L_DEBUG,"Packing UdxDatForwadReq");
6144     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
6145     {
6146 #if (ERRCLASS & ERRCLS_ADD_RES)
6147        if(ret1 != ROK)
6148        {
6149           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
6150                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
6151                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
6152        }
6153 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
6154
6155        RETVALUE(ret1);
6156     }
6157
6158     switch (pst->selector)
6159     {
6160        case UDX_SEL_LC:
6161        {
6162        }
6163        case UDX_SEL_LWLC:
6164        {
6165           CMCHKPKLOG(cmPkPtr,(PTR)datFwdInfo,mBuf,EUDXXXX,pst);
6166           break;
6167        }
6168     }
6169    pst->event = (Event) EVTUDXDATFRWD;
6170
6171     RETVALUE(SPstTsk(pst, mBuf));
6172
6173 } /* cmPkPjUdxDatForwardReq */
6174
6175 /*
6176 *
6177 *    Fun:    cmUnpkPjUdxDatForwardReq
6178 *
6179 *    Ret:    ROK  -ok
6180 *
6181 *    Notes:  None
6182 *
6183 *
6184 */
6185 #ifdef ANSI
6186 PUBLIC S16 cmUnpkPjUdxDatForwardReq
6187 (
6188 UdxDatForwardReq  func,
6189 Pst              *pst,
6190 Buffer           *mBuf
6191 )
6192 #else
6193 PUBLIC S16 cmUnpkPjUdxDatForwardReq(func, pst, mBuf)
6194 UdxDatForwardReq  func;
6195 Pst              *pst;
6196 Buffer           *mBuf;
6197 #endif
6198 {
6199    UdxDatForwardInfo   *datFwdInfo;
6200
6201     TRC3(cmUnpkPjUdxDatForwardReq)
6202
6203     RLOG0(L_DEBUG,"Unpacking UdxDatForwadReq");
6204     switch (pst->selector)
6205     {
6206        case UDX_SEL_LC:
6207        {
6208        }
6209        case UDX_SEL_LWLC:
6210        {
6211           CMCHKUNPK(cmUnpkPtr,(PTR *) &datFwdInfo, mBuf);
6212          break;
6213        }
6214     }
6215
6216     SPutMsg(mBuf);
6217
6218     RETVALUE((*func)(pst, datFwdInfo));
6219 } /* cmUnpkPjUdxDatForwardReq */
6220 #endif /* end of #if(defined(LCUDX) || defined(LWLCUDX)) */
6221
6222 /********************************************************************30**
6223
6224          End of file
6225 **********************************************************************/