* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchUeDelInd
+S16 cmPkMacSchUeDelInd
(
Pst* pst,
RgInfUeDelInd* ueDelInd
)
#else
-PUBLIC S16 cmPkMacSchUeDelInd(pst, ueDelInd)
+S16 cmPkMacSchUeDelInd(pst, ueDelInd)
Pst* pst;
RgInfUeDelInd* ueDelInd;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchUeDelInd)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchUeDelInd
+S16 cmUnpkMacSchUeDelInd
(
UeDelInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchUeDelInd(func, pst, mBuf)
+S16 cmUnpkMacSchUeDelInd(func, pst, mBuf)
UeDelInd func;
Pst *pst;
Buffer *mBuf;
{
RgInfUeDelInd ueDelInd;
- TRC2(cmUnpkMacSchUeDelInd)
-
if(SRemPreMsgMult((Data *)&ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchDedBoUpdtReq
+S16 cmPkMacSchDedBoUpdtReq
(
Pst* pst,
RgInfDedBoRpt* boRpt
)
#else
-PUBLIC S16 cmPkMacSchDedBoUpdtReq(pst, boRpt)
+S16 cmPkMacSchDedBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfDedBoRpt* boRpt;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchDedBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchDedBoUpdtReq
+S16 cmUnpkMacSchDedBoUpdtReq
(
DedBoUpdtReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchDedBoUpdtReq(func, pst, mBuf)
+S16 cmUnpkMacSchDedBoUpdtReq(func, pst, mBuf)
DedBoUpdtReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfDedBoRpt boRpt;
- TRC2(cmUnpkMacSchDedBoUpdtReq)
-
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchCmnBoUpdtReq
+S16 cmPkMacSchCmnBoUpdtReq
(
Pst* pst,
RgInfCmnBoRpt* boRpt
)
#else
-PUBLIC S16 cmPkMacSchCmnBoUpdtReq(pst, boRpt)
+S16 cmPkMacSchCmnBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfCmnBoRpt* boRpt;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchCmnBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq
+S16 cmUnpkMacSchCmnBoUpdtReq
(
CmnBoUpdtReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq(func, pst, mBuf)
+S16 cmUnpkMacSchCmnBoUpdtReq(func, pst, mBuf)
CmnBoUpdtReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfCmnBoRpt boRpt;
- TRC2(cmUnpkMacSchCmnBoUpdtReq)
-
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchSfRecpInd
+S16 cmPkMacSchSfRecpInd
(
Pst* pst,
RgInfSfDatInd* datInd
)
#else
-PUBLIC S16 cmPkMacSchSfRecpInd(pst, datInd)
+S16 cmPkMacSchSfRecpInd(pst, datInd)
Pst* pst;
RgInfSfDatInd* datInd;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchSfRecpInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchSfRecpInd
+S16 cmUnpkMacSchSfRecpInd
(
SfRecpInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchSfRecpInd(func, pst, mBuf)
+S16 cmUnpkMacSchSfRecpInd(func, pst, mBuf)
SfRecpInd func;
Pst *pst;
Buffer *mBuf;
{
RgInfSfDatInd* datInd;
- TRC2(cmUnpkMacSchCmnBoUpdtReq)
-
if(oduUnpackPointer((PTR *)&datInd, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchSpsRelInd
+S16 cmPkMacSchSpsRelInd
(
Pst* pst,
RgInfSpsRelInfo* relInfo
)
#else
-PUBLIC S16 cmPkMacSchSpsRelInd(pst, relInfo)
+S16 cmPkMacSchSpsRelInd(pst, relInfo)
Pst* pst;
RgInfSpsRelInfo* relInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchSpsRelInd)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchSpsRelInd
+S16 cmUnpkMacSchSpsRelInd
(
SpsRelInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchSpsRelInd(func, pst, mBuf)
+S16 cmUnpkMacSchSpsRelInd(func, pst, mBuf)
SpsRelInd func;
Pst *pst;
Buffer *mBuf;
{
RgInfSpsRelInfo *relInfo;
- TRC2(cmUnpkMacSchSpsRelInd)
-
if(oduUnpackPointer((PTR *)&relInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSfAllocReq
+S16 cmPkSchMacSfAllocReq
(
Pst* pst,
RgInfSfAlloc* resAllocReq
)
#else
-PUBLIC S16 cmPkSchMacSfAllocReq(pst, resAllocReq)
+S16 cmPkSchMacSfAllocReq(pst, resAllocReq)
Pst* pst;
RgInfSfAlloc* resAllocReq;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSfAllocReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSfAllocReq
+S16 cmUnpkSchMacSfAllocReq
(
SfAllocReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSfAllocReq(func, pst, mBuf)
+S16 cmUnpkSchMacSfAllocReq(func, pst, mBuf)
SfAllocReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfSfAlloc* resAllocReq;
- TRC2(cmUnpkSchMacSfAllocReq)
-
if(oduUnpackPointer((PTR *)&resAllocReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRstHqEntReq
+S16 cmPkSchMacRstHqEntReq
(
Pst* pst,
RgInfResetHqEnt* hqEntInfo
)
#else
-PUBLIC S16 cmPkSchMacRstHqEntReq(pst, sfHqInfo)
+S16 cmPkSchMacRstHqEntReq(pst, sfHqInfo)
Pst* pst,
RgInfResetHqEnt* hqEntInfo
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRstHqEntReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRstHqEntReq
+S16 cmUnpkSchMacRstHqEntReq
(
RstHqEntReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRstHqEntReq(func, pst, mBuf)
+S16 cmUnpkSchMacRstHqEntReq(func, pst, mBuf)
RstHqEntReq func,
Pst *pst,
Buffer *mBuf
{
RgInfResetHqEnt* hqEntRstInfo;
- TRC2(cmUnpkSchMacRstHqEntReq)
-
if(oduUnpackPointer((PTR *)&hqEntRstInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRlsHqReq
+S16 cmPkSchMacRlsHqReq
(
Pst* pst,
RgInfRlsHqInfo* sfHqInfo
)
#else
-PUBLIC S16 cmPkSchMacRlsHqReq(pst, sfHqInfo)
+S16 cmPkSchMacRlsHqReq(pst, sfHqInfo)
Pst* pst;
RgInfRlsHqInfo* sfHqInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRlsHqReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRlsHqReq
+S16 cmUnpkSchMacRlsHqReq
(
RlsHqReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRlsHqReq(func, pst, mBuf)
+S16 cmUnpkSchMacRlsHqReq(func, pst, mBuf)
RlsHqReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfRlsHqInfo* sfHqInfo;
- TRC2(cmUnpkSchMacRlsHqReq)
-
if(oduUnpackPointer((PTR *)&sfHqInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRlsRntiReq
+S16 cmPkSchMacRlsRntiReq
(
Pst* pst,
RgInfRlsRnti* rlsRnti
)
#else
-PUBLIC S16 cmPkSchMacRlsRntiReq(pst, rlsRnti)
+S16 cmPkSchMacRlsRntiReq(pst, rlsRnti)
Pst* pst;
RgInfRlsRnti* rlsRnti;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRlsRntiReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRlsRntiReq
+S16 cmUnpkSchMacRlsRntiReq
(
RlsRntiReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRlsRntiReq(func, pst, mBuf)
+S16 cmUnpkSchMacRlsRntiReq(func, pst, mBuf)
RlsRntiReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfRlsRnti rlsRnti;
- TRC2(cmUnpkSchMacRlsRntiReq)
-
if(SRemPreMsgMult((Data *)&rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacCellRegReq
+S16 cmPkSchMacCellRegReq
(
Pst* pst,
RgInfCellReg* regReq
)
#else
-PUBLIC S16 cmPkSchMacCellRegReq(pst, regReq)
+S16 cmPkSchMacCellRegReq(pst, regReq)
Pst* pst;
RgInfCellReg* regReq;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacCellRegReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacCellRegReq
+S16 cmUnpkSchMacCellRegReq
(
CellRegReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacCellRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacCellRegReq(func, pst, mBuf)
CellRegReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfCellReg regReq;
- TRC2(cmUnpkSchMacCellRegReq)
-
if(SRemPreMsgMult((Data *)®Req, sizeof(RgInfCellReg), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacLcgRegReq
+S16 cmPkSchMacLcgRegReq
(
Pst* pst,
RgInfLcgRegReq *lcgRegReq
)
#else
-PUBLIC S16 cmPkSchMacLcgRegReq(pst, lcgRegReq)
+S16 cmPkSchMacLcgRegReq(pst, lcgRegReq)
Pst* pst;
RgInfLcgRegReq *lcgRegReq;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacLcgRegReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacLcgRegReq
+S16 cmUnpkSchMacLcgRegReq
(
LcgReg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacLcgRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacLcgRegReq(func, pst, mBuf)
LcgReg func;
Pst *pst;
Buffer *mBuf;
{
RgInfLcgRegReq *lcgRegReq;
- TRC2(cmUnpkSchMacLcgRegReq)
-
if(oduUnpackPointer((PTR *)&lcgRegReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSpsLcRegReq
+S16 cmPkSchMacSpsLcRegReq
(
Pst* pst,
RgInfSpsLcInfo *lcInfo
)
#else
-PUBLIC S16 cmPkSchMacSpsLcRegReq(pst, lcInfo)
+S16 cmPkSchMacSpsLcRegReq(pst, lcInfo)
Pst* pst;
RgInfSpsLcInfo *lcInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSpsLcRegReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacUlSpsResetReq
+S16 cmPkSchMacUlSpsResetReq
(
Pst* pst,
RgInfUlSpsReset *ulSpsResetInfo
)
#else
-PUBLIC S16 cmPkSchMacUlSpsResetReq(pst, ulSpsResetInfo)
+S16 cmPkSchMacUlSpsResetReq(pst, ulSpsResetInfo)
Pst* pst;
RgInfUlSpsReset *ulSpsResetInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacUlSpsResetReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSpsLcRegReq
+S16 cmUnpkSchMacSpsLcRegReq
(
SpsLcReg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSpsLcRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacSpsLcRegReq(func, pst, mBuf)
SpsLcReg func;
Pst *pst;
Buffer *mBuf;
{
RgInfSpsLcInfo *lcInfo;
- TRC2(cmUnpkSchMacSpsLcRegReq)
-
if(oduUnpackPointer((PTR *)&lcInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacUlSpsResetReq
+S16 cmUnpkSchMacUlSpsResetReq
(
UlSpsReset func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacUlSpsResetReq(func, pst, mBuf)
+S16 cmUnpkSchMacUlSpsResetReq(func, pst, mBuf)
UlSpsReset func;
Pst *pst;
Buffer *mBuf;
{
RgInfUlSpsReset *ulSpsResetInfo;
- TRC2(cmUnpkSchMacUlSpsResetReq)
-
if(oduUnpackPointer((PTR *)&ulSpsResetInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSpsLcDeregReq
+S16 cmPkSchMacSpsLcDeregReq
(
Pst* pst,
CmLteCellId cellId,
CmLteRnti crnti
)
#else
-PUBLIC S16 cmPkSchMacSpsLcDeregReq(pst, cellId, crnti)
+S16 cmPkSchMacSpsLcDeregReq(pst, cellId, crnti)
Pst* pst;
CmLteCellId cellId;
CmLteRnti crnti;
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSpsLcDeregReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSpsLcDeregReq
+S16 cmUnpkSchMacSpsLcDeregReq
(
SpsLcDereg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSpsLcDeregReq(func, pst, mBuf)
+S16 cmUnpkSchMacSpsLcDeregReq(func, pst, mBuf)
SpsLcDereg func;
Pst *pst;
Buffer *mBuf;
CmLteCellId cellId;
CmLteRnti crnti;
- TRC2(cmUnpkSchMacSpsLcDeregReq)
-
CMCHKUNPK(cmUnpkLteRnti, &crnti, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &cellId, mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasReq
+S16 cmPkSchMacL2MeasReq
(
Pst* pst,
RgInfL2MeasReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasReq(pst, measInfo)
+S16 cmPkSchMacL2MeasReq(pst, measInfo)
Pst* pst;
RgInfL2MeasReq *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasStopReq
+S16 cmPkSchMacL2MeasStopReq
(
Pst* pst,
RgInfL2MeasStopReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasStopReq(pst, measInfo)
+S16 cmPkSchMacL2MeasStopReq(pst, measInfo)
Pst* pst;
RgInfL2MeasStopReq *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasStopReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasSendReq
+S16 cmPkSchMacL2MeasSendReq
(
Pst* pst,
RgInfL2MeasSndReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasSendReq(pst, measInfo)
+S16 cmPkSchMacL2MeasSendReq(pst, measInfo)
Pst* pst;
RgInfL2MeasSndReq *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasSendReq)
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasReq
+S16 cmUnpkSchMacL2MeasReq
(
L2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasReq(func, pst, mBuf)
L2MeasReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfL2MeasReq measInfo;
- TRC2(cmUnpkSchMacL2MeasReq)
-
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasStopReq
+S16 cmUnpkSchMacL2MeasStopReq
(
L2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasStopReq(func, pst, mBuf)
L2MeasStopReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfL2MeasStopReq measInfo;
- TRC2(cmUnpkSchMacL2MeasStopReq)
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasSendReq
+S16 cmUnpkSchMacL2MeasSendReq
(
L2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasSendReq(func, pst, mBuf)
L2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
{
RgInfL2MeasSndReq measInfo;
- TRC2(cmUnpkSchMacL2MeasSendReq)
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchL2MeasCfm
+S16 cmPkMacSchL2MeasCfm
(
Pst* pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 cmPkMacSchL2MeasCfm(pst, measCfm)
+S16 cmPkMacSchL2MeasCfm(pst, measCfm)
Pst* pst;
RgInfL2MeasCfm *measCfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchL2MeasCfm)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchL2MeasStopCfm
+S16 cmPkMacSchL2MeasStopCfm
(
Pst* pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 cmPkMacSchL2MeasStopCfm(pst, measCfm)
+S16 cmPkMacSchL2MeasStopCfm(pst, measCfm)
Pst* pst;
RgInfL2MeasCfm *measCfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchL2MeasCfm
+S16 cmUnpkMacSchL2MeasCfm
(
L2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkMacSchL2MeasCfm(func, pst, mBuf)
L2MeasCfm func;
Pst *pst;
Buffer *mBuf;
{
RgInfL2MeasCfm measCfm;
- TRC2(cmUnpkMacSchL2MeasCfm)
-
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchL2MeasStopCfm
+S16 cmUnpkMacSchL2MeasStopCfm
(
L2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkMacSchL2MeasStopCfm(func, pst, mBuf)
L2MeasCfm func;
Pst *pst;
Buffer *mBuf;
{
RgInfL2MeasCfm measCfm;
- TRC2(cmUnpkMacSchL2MeasStopCfm)
-
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
SPutMsg(mBuf);