561 lines
16 KiB
C
561 lines
16 KiB
C
|
|
/************************************************************/
|
|
/*Title: scmg.c */
|
|
/*Descr: SCCP Management */
|
|
/*Author: Liang Hanxi */
|
|
/*Create: 2002-2-19 */
|
|
/*Modify: 2002-5-7 */
|
|
|
|
/************************************************************/
|
|
|
|
#include "./include/sccp.h"
|
|
|
|
/*===========export================*/
|
|
void localssn_timer ( );
|
|
void sst_timer ( );
|
|
int sclc2scmg ( Intra_Msg * intramsg );
|
|
BOOL CheckAvail ( SCCP_ADDR * addr );
|
|
|
|
/*===========import================*/
|
|
extern int scrc_route ( Intra_Msg * pIntraMsg, BOOL ForceAnsi );
|
|
extern int send_msg ( Intra_Msg * pIntraMsg, BYTE ansi_flag );
|
|
extern void sccp_sethb ( );
|
|
extern int CollectLocalInfo ( );
|
|
extern int AddToIpList ( DWORD ip, BYTE ssn );
|
|
extern void snmpLogInfo ( char *logInfo );
|
|
extern void spLogDebug ( DWORD mask, const char *fmt, ... );
|
|
/*===========private================*/
|
|
static BYTE ssn_status ( int spc, BYTE ssn, BYTE NetID );
|
|
void spac ( int spc, BYTE NetID );
|
|
void sppc ( int spc, BYTE NetID );
|
|
void spcc ( int spc, BYTE NetID );
|
|
static void ssac ( int spc, BYTE ssn, BYTE NetID, BOOL relay );
|
|
static void sscc ( int spc, BYTE ssn, BYTE NetID );
|
|
static void sspc ( int spc, BYTE ssn, BYTE NetID, BOOL relay );
|
|
static void lcst ( int spc, BYTE ssn, BYTE ntype, BYTE NetID );
|
|
static void bcst ( BYTE ssn, BYTE ntype );
|
|
static void bcst_relay ( int spc, BYTE ssn, BYTE ntype, BYTE NetID );
|
|
static int build_scmgmsg ( BYTE * intramsg, BYTE type, int spc, BYTE ssn, BYTE NetID );
|
|
static int parse_scmgmsg ( BYTE * data, BYTE * type, int *spc, BYTE * ssn, BYTE NetID );
|
|
|
|
/* by simon at 23/9/25 */
|
|
extern DWORD ExistIP[64];
|
|
extern DWORD ExistIPNum;
|
|
extern SCOC_BUF ScocBuf;
|
|
extern LOCAL_SSN LocalSSN[256];
|
|
extern u8 ExistSSN[64];
|
|
extern u8 ExistSSNNum;
|
|
extern struct _dpc2sls
|
|
{
|
|
int dpc;
|
|
u8 sls;
|
|
} dpc2sls[256]; // used for sequence control, add by Roy Jiang, 2007-09-17
|
|
extern SCCP_OPT SCCP_Param;
|
|
extern u8 MNP_Flag[2];
|
|
extern SCCP_ROUTE RouteList[SCCP_ROUTE_NUM];
|
|
extern int RelatedSSNNum;
|
|
extern RL_SSN RelatedSSN[SCCP_RLSSN_NUM];
|
|
extern int RelatedSPCNum;
|
|
extern RL_SPC RelatedSPC[SCCP_RLSPC_NUM];
|
|
extern GTTATT_OMC GTTAttribute[SCCP_ROUTE_NUM];
|
|
extern SCCP_CSTA SccpCsta[96];
|
|
extern DWORD SccpCstaInd;
|
|
extern SCCP_Capture_Buf SCCPCapBuf;
|
|
|
|
void localssn_timer ( ) //called per 1s
|
|
{
|
|
int i;
|
|
LOCAL_SSN *pSSN;
|
|
|
|
for ( i = 0; i < ExistSSNNum; i++ )
|
|
{
|
|
pSSN = &LocalSSN[ExistSSN[i]];
|
|
if( pSSN->status[0] == ST_Enable && pSSN->local != 1 && pSSN->timeout[0]-- <= 0 )
|
|
pSSN->status[0] = ST_Disable;
|
|
if( pSSN->status[1] == ST_Enable && pSSN->local != 2 && pSSN->timeout[1]-- <= 0 )
|
|
pSSN->status[1] = ST_Disable;
|
|
}
|
|
}
|
|
|
|
int sclc2scmg ( Intra_Msg * intramsg )
|
|
{
|
|
BYTE *pmsg;
|
|
BYTE ntype, ssn;
|
|
int spc;
|
|
BOOL relay = 0;
|
|
|
|
intramsg->msgsource = FROM_SCMG;
|
|
pmsg = intramsg->data;
|
|
parse_scmgmsg ( intramsg->data, &ntype, &spc, &ssn, intramsg->NetID );
|
|
|
|
snmpLogInfo ( "sclc2scmg (): start..." );
|
|
|
|
spLogDebug ( SCCPDB_SCMG, "Receive %s Message.ssn=%d,src_spc=%X", ntype == SSA_MSG ? "SSA" : ( ntype == SSP_MSG ? "SSP" : ( ntype == SST_MSG ? "SST" : "SCMG" ) ), ssn, spc );
|
|
switch ( ntype )
|
|
{
|
|
case SSA_MSG:
|
|
//to enable subsystem
|
|
SccpCsta[SccpCstaInd].avail[11]++;
|
|
if( intramsg->OPC != SCCP_Param.spc[intramsg->NetID] && intramsg->CGA.DPC != SCCP_Param.spc[intramsg->NetID] )
|
|
{
|
|
lcst ( spc, ssn, SSA_MSG, intramsg->NetID );
|
|
if( spc == intramsg->CGA.DPC )
|
|
relay = 1;
|
|
}
|
|
ssac ( spc, ssn, intramsg->NetID, relay );
|
|
|
|
break;
|
|
case SSC_MSG:
|
|
SccpCsta[SccpCstaInd].avail[7]++;
|
|
sscc ( spc, ssn, intramsg->NetID );
|
|
break;
|
|
case SSP_MSG:
|
|
SccpCsta[SccpCstaInd].avail[10]++;
|
|
if( intramsg->OPC != SCCP_Param.spc[intramsg->NetID] && intramsg->CGA.DPC != SCCP_Param.spc[intramsg->NetID] )
|
|
{
|
|
lcst ( spc, ssn, SSP_MSG, intramsg->NetID );
|
|
if( spc == intramsg->CGA.DPC )
|
|
relay = 1;
|
|
}
|
|
sspc ( spc, ssn, intramsg->NetID, relay );
|
|
|
|
break;
|
|
case SST_MSG:
|
|
if( LocalSSN[ssn].status[0] == ST_Enable || LocalSSN[ssn].status[1] == ST_Enable )
|
|
pmsg[0] = SSA_MSG;
|
|
else
|
|
return 1;
|
|
|
|
memcpy ( &intramsg->CDA, &intramsg->CGA, sizeof ( SCCP_ADDR ) );
|
|
intramsg->CGA.DPC = SCCP_Param.spc[intramsg->NetID];
|
|
intramsg->CGA.GTI = 0;
|
|
intramsg->CGA.SSN = 1;
|
|
intramsg->CGA.RI = RI_SSN;
|
|
intramsg->CGA.len = 0;
|
|
|
|
spLogDebug ( SCCPDB_SCMG, "Send %s Message.ssn=%d,dst_spc=%X", ( pmsg[0] == SSA_MSG ) ? "SSA" : ( ( pmsg[0] == SSP_MSG ) ? "SSP" : "SSC" ), ssn, intramsg->CDA.DPC );
|
|
send_msg ( intramsg, mtp3_ansiFlag ( intramsg->NetID ) );
|
|
break;
|
|
case SOR_MSG:
|
|
//to send SOG
|
|
pmsg[0] = SOG_MSG; //to send SOG
|
|
memcpy ( &intramsg->CDA, &intramsg->CGA, sizeof ( SCCP_ADDR ) );
|
|
scrc_route ( intramsg, 0 );
|
|
break;
|
|
case SOG_MSG:
|
|
//to disable local subsystem
|
|
break;
|
|
}
|
|
snmpLogInfo ( "sclc2scmg (): end..." );
|
|
return 1;
|
|
}
|
|
|
|
BOOL CheckAvail ( SCCP_ADDR * addr )
|
|
{
|
|
BYTE status;
|
|
|
|
status = ssn_status ( addr->DPC, addr->SSN, addr->NetID );
|
|
if( status == ST_Disable )
|
|
{
|
|
spLogDebug ( SCCPDB_ERR, "<009>Subsystem Failure.NetID=%d,SPC=%x,SSN=%d", addr->NetID, addr->DPC, addr->SSN );
|
|
SccpCsta[SccpCstaInd].error[4]++;
|
|
return 0;
|
|
}
|
|
else if( status == ST_Congest )
|
|
{
|
|
spLogDebug ( SCCPDB_ERR, "<010>Subsystem Congest.NetID=%d,SPC=%x,SSN=%d", addr->NetID, addr->DPC, addr->SSN );
|
|
SccpCsta[SccpCstaInd].error[5]++;
|
|
return 0;
|
|
}
|
|
//else if(sccp_status(addr->DPC,addr->NetID)==ST_Disable)
|
|
// return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
BYTE ssn_status ( int spc, BYTE ssn, BYTE NetID )
|
|
//related subsystem
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSSNNum; i++ )
|
|
{
|
|
if( RelatedSSN[i].status == 0 )
|
|
continue;
|
|
if( RelatedSSN[i].DPC != spc || RelatedSSN[i].SSN != ssn || RelatedSSN[i].NetID != NetID )
|
|
continue;
|
|
|
|
return RelatedSSN[i].status;
|
|
}
|
|
return ST_Enable;
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SPAC Module----------> */
|
|
/////////////////////////
|
|
void spac ( int spc, BYTE NetID )
|
|
{
|
|
int i, j;
|
|
|
|
for ( i = 0; i < RelatedSPCNum; i++ )
|
|
{
|
|
if( spc == RelatedSPC[i].DPC && NetID == RelatedSPC[i].NetID )
|
|
{
|
|
RelatedSPC[i].status = ST_Enable;
|
|
for ( j = 0; j < RelatedSSNNum; j++ )
|
|
{
|
|
if( RelatedSSN[j].status == 0 )
|
|
continue;
|
|
if( spc == RelatedSSN[j].DPC && NetID == RelatedSSN[j].NetID )
|
|
{
|
|
if( RelatedSPC[i].status == ST_Disable )
|
|
RelatedSSN[j].SST = 1;
|
|
RelatedSSN[j].status = ST_Enable;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SPPC Module----------> */
|
|
/////////////////////////
|
|
void sppc ( int spc, BYTE NetID )
|
|
{
|
|
int i, j;
|
|
|
|
for ( i = 0; i < RelatedSPCNum; i++ )
|
|
{
|
|
if( spc == RelatedSPC[i].DPC && NetID == RelatedSPC[i].NetID )
|
|
{
|
|
RelatedSPC[i].status = ST_Disable;
|
|
for ( j = 0; j < RelatedSSNNum; j++ )
|
|
{
|
|
if( RelatedSSN[j].status == 0 )
|
|
continue;
|
|
if( spc == RelatedSSN[j].DPC && NetID == RelatedSSN[j].NetID )
|
|
{
|
|
RelatedSSN[j].SST = 0;
|
|
RelatedSSN[j].status = ST_Disable;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SPCC Module----------> */
|
|
/////////////////////////
|
|
void spcc ( int spc, BYTE NetID )
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSPCNum; i++ )
|
|
{
|
|
if( spc == RelatedSSN[i].DPC && NetID == RelatedSSN[i].NetID )
|
|
RelatedSSN[i].status = ST_Congest;
|
|
}
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SSAC Module----------> */
|
|
/////////////////////////
|
|
|
|
int register_ssn ( BYTE ssn, BYTE usertype ) //enable local subsystem
|
|
{
|
|
BYTE localindex = LocalSSN[ssn].local % 3;
|
|
|
|
LocalSSN[ssn].RegFlag = 1;
|
|
if( localindex > 0 )
|
|
{
|
|
CollectLocalInfo ( );
|
|
LocalSSN[ssn].status[localindex - 1] = ST_Enable;
|
|
}
|
|
else
|
|
{
|
|
printf ( "Subsystem %d not equiped.check your GTT Table.\n", ssn );
|
|
return 0;
|
|
}
|
|
|
|
if( usertype == 3 )
|
|
SCCP_Param.CO_SSN = ssn;
|
|
|
|
SccpCsta[SccpCstaInd].avail[8]++;
|
|
LocalSSN[ssn].nbuf = usertype % 4;
|
|
if( LocalSSN[ssn].nbuf == 3 )
|
|
SCCP_Param.CO_SSN = ssn;
|
|
bcst ( ssn, SSA_MSG );
|
|
|
|
return 1;
|
|
}
|
|
|
|
void ssac ( int spc, BYTE ssn, BYTE NetID, BOOL relay ) //enable remote subsystem
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSSNNum; i++ )
|
|
{
|
|
if( RelatedSSN[i].status == 0 )
|
|
continue;
|
|
if( RelatedSSN[i].DPC != spc || RelatedSSN[i].SSN != ssn || RelatedSSN[i].NetID != NetID )
|
|
continue;
|
|
|
|
if( RelatedSSN[i].status == ST_Disable && relay ) //Disable->Enable
|
|
bcst_relay ( spc, ssn, SSA_MSG, NetID );
|
|
RelatedSSN[i].SST = 0;
|
|
RelatedSSN[i].status = ST_Enable;
|
|
|
|
}
|
|
}
|
|
|
|
void sscc ( int spc, BYTE ssn, BYTE NetID ) //enable remote subsystem
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSSNNum; i++ )
|
|
{
|
|
if( RelatedSSN[i].status == 0 )
|
|
continue;
|
|
if( RelatedSSN[i].DPC != spc || RelatedSSN[i].SSN != ssn || RelatedSSN[i].NetID != NetID )
|
|
continue;
|
|
|
|
RelatedSSN[i].status = ST_Congest;
|
|
}
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SSPC Module----------> */
|
|
/////////////////////////
|
|
int stop_ssn ( BYTE ssn ) //disable local subsystem
|
|
{
|
|
BYTE localindex = LocalSSN[ssn].local % 3;
|
|
int i;
|
|
|
|
LocalSSN[ssn].RegFlag = 0;
|
|
spLogDebug ( SCCPDB_SCMG, "Disable local subsystem. ssn=%d", ssn );
|
|
|
|
if( localindex > 0 )
|
|
{
|
|
CollectLocalInfo ( );
|
|
/* add by daniel on 2005-9-15 */
|
|
for ( i = 0; i <= 1; i++ )
|
|
{
|
|
if( SCCP_Param.OMCIP[i] > 0 )
|
|
AddToIpList ( SCCP_Param.OMCIP[i], ssn );
|
|
}
|
|
/* add by daniel on 2005-9-15 */
|
|
LocalSSN[ssn].status[localindex - 1] = ST_Disable;
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
sccp_sethb ( );
|
|
SccpCsta[SccpCstaInd].avail[9]++;
|
|
bcst ( ssn, SSP_MSG );
|
|
return 1;
|
|
}
|
|
|
|
void sspc ( int spc, BYTE ssn, BYTE NetID, BOOL relay ) //disable remote subsystem
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSSNNum; i++ )
|
|
{
|
|
if( RelatedSSN[i].status == 0 )
|
|
continue;
|
|
if( RelatedSSN[i].DPC != spc || RelatedSSN[i].SSN != ssn || RelatedSSN[i].NetID != NetID )
|
|
continue;
|
|
|
|
if( RelatedSSN[i].status == ST_Enable ) //Enable->Disable
|
|
{
|
|
RelatedSSN[i].timeout = T_sst;
|
|
RelatedSSN[i].SST = 1;
|
|
if( relay )
|
|
bcst_relay ( spc, ssn, SSP_MSG, NetID );
|
|
}
|
|
|
|
RelatedSSN[i].status = ST_Disable;
|
|
}
|
|
}
|
|
|
|
/////////////////////////
|
|
/*SSTC Module----------> */
|
|
/////////////////////////
|
|
void sst_timer ( )
|
|
{
|
|
Intra_Msg outmsg;
|
|
RL_SSN *pSSN;
|
|
int i;
|
|
|
|
for ( i = 0; i < RelatedSSNNum; i++ )
|
|
{
|
|
pSSN = &RelatedSSN[i];
|
|
if( !pSSN->SST )
|
|
continue;
|
|
if( pSSN->timeout-- > 0 )
|
|
continue;
|
|
if( pSSN->DPC == SCCP_Param.spc[pSSN->NetID] )
|
|
continue;
|
|
|
|
outmsg.msgtype = UDT_MSG;
|
|
outmsg.msgsource = FROM_SCMG;
|
|
|
|
outmsg.CGA.DPC = SCCP_Param.spc[pSSN->NetID];
|
|
outmsg.CGA.SSN = 1;
|
|
outmsg.CGA.GTI = 0;
|
|
outmsg.CGA.RI = RI_SSN;
|
|
outmsg.CGA.len = 0;
|
|
|
|
outmsg.CDA.DPC = pSSN->DPC;
|
|
outmsg.CDA.SSN = 1; //SCMG
|
|
outmsg.CDA.GTI = 0; //No GT
|
|
outmsg.CDA.RI = 1;
|
|
outmsg.CDA.len = 0;
|
|
|
|
outmsg.NetID = pSSN->NetID;
|
|
|
|
outmsg.CDA.ip = INADDR_NONE;
|
|
|
|
outmsg.msglen = build_scmgmsg ( outmsg.data, SST_MSG, pSSN->DPC, pSSN->SSN, pSSN->NetID );
|
|
spLogDebug ( SCCPDB_SCMG, "SST spc=%X,ssn=%d", pSSN->DPC, pSSN->SSN );
|
|
send_msg ( &outmsg, mtp3_ansiFlag ( pSSN->NetID ) );
|
|
pSSN->timeout = T_sst;
|
|
}
|
|
}
|
|
|
|
/////////////////////////
|
|
/*LCST Module----------> */
|
|
/////////////////////////
|
|
|
|
void lcst ( int spc, BYTE ssn, BYTE ntype, BYTE NetID )
|
|
{
|
|
Intra_Msg outmsg;
|
|
int i;
|
|
|
|
spLogDebug ( SCCPDB_SCMG, "Start Local Broatcast.spc=%X,ssn=%d,ntype=%d", spc, ssn, ntype );
|
|
outmsg.msgtype = UDT_MSG;
|
|
outmsg.msgsource = FROM_SCMG;
|
|
outmsg.CGA.SSN = 1;
|
|
outmsg.CGA.GTI = 0;
|
|
outmsg.CGA.len = 0;
|
|
outmsg.CGA.RI = 1;
|
|
outmsg.CGA.DPC = SCCP_Param.spc[NetID];
|
|
outmsg.CDA.GTI = 0;
|
|
outmsg.NetID = outmsg.CDA.NetID = outmsg.CGA.NetID = NetID;
|
|
|
|
outmsg.CDA.DPC = SCCP_Param.spc[NetID];
|
|
outmsg.CDA.SSN = 1;
|
|
outmsg.CDA.RI = 1;
|
|
outmsg.CDA.len = 0;
|
|
|
|
outmsg.msglen = build_scmgmsg ( outmsg.data, ntype, spc, ssn, NetID );
|
|
|
|
for ( i = 2; i < 256; i++ )
|
|
{
|
|
if( LocalSSN[i].status[0] > 0 && LocalSSN[i].local != 1 )
|
|
{
|
|
outmsg.CDA.ip = LocalSSN[i].ip[0];
|
|
send_msg ( &outmsg, mtp3_ansiFlag ( NetID ) );
|
|
}
|
|
if( LocalSSN[i].status[1] > 0 && LocalSSN[i].local != 2 )
|
|
{
|
|
outmsg.CDA.ip = LocalSSN[i].ip[1];
|
|
send_msg ( &outmsg, mtp3_ansiFlag ( NetID ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////
|
|
/*BCST Module----------> */
|
|
/////////////////////////
|
|
void bcst ( BYTE ssn, BYTE ntype )
|
|
{
|
|
Intra_Msg outmsg;
|
|
int i;
|
|
|
|
spLogDebug ( SCCPDB_SCMG, "Start Remote Broadcase ssn=%d,ntype=%d", ssn, ntype );
|
|
outmsg.msgtype = UDT_MSG;
|
|
outmsg.msgsource = FROM_SCMG;
|
|
outmsg.CDA.GTI = 0;
|
|
for ( i = 0; i < RelatedSPCNum; i++ )
|
|
{
|
|
if( RelatedSPC[i].status != ST_Enable )
|
|
continue;
|
|
outmsg.CGA.SSN = 1;
|
|
outmsg.CGA.GTI = 0;
|
|
outmsg.CGA.len = 0;
|
|
outmsg.CGA.RI = 1;
|
|
outmsg.CGA.DPC = SCCP_Param.spc[RelatedSPC[i].NetID];
|
|
outmsg.CDA.ip = INADDR_NONE;
|
|
outmsg.CDA.DPC = RelatedSPC[i].DPC;
|
|
outmsg.CDA.SSN = 1;
|
|
outmsg.CDA.RI = 1;
|
|
outmsg.CDA.len = 0;
|
|
outmsg.NetID = outmsg.CDA.NetID = outmsg.CGA.NetID = RelatedSPC[i].NetID;
|
|
|
|
outmsg.msglen = build_scmgmsg ( outmsg.data, ntype, SCCP_Param.spc[outmsg.NetID], ssn, outmsg.NetID );
|
|
send_msg ( &outmsg, mtp3_ansiFlag ( outmsg.NetID ) );
|
|
}
|
|
}
|
|
|
|
void bcst_relay ( int spc, BYTE ssn, BYTE ntype, BYTE NetID )
|
|
{
|
|
Intra_Msg outmsg;
|
|
int i;
|
|
|
|
spLogDebug ( SCCPDB_SCMG, "relay Broadcase spc:%X,ssn%d,ntype:%d", spc, ssn, ntype );
|
|
outmsg.msgtype = UDT_MSG;
|
|
outmsg.msgsource = FROM_SCMG;
|
|
outmsg.CDA.GTI = 0;
|
|
outmsg.CGA.SSN = 1;
|
|
outmsg.CGA.GTI = 0;
|
|
outmsg.CGA.len = 0;
|
|
outmsg.CGA.RI = 1;
|
|
outmsg.NetID = outmsg.CGA.NetID = outmsg.CDA.NetID = NetID;
|
|
for ( i = 0; i < RelatedSPCNum; i++ )
|
|
{
|
|
if( NetID != RelatedSPC[i].NetID )
|
|
return;
|
|
if( RelatedSPC[i].status == ST_Disable || spc == RelatedSPC[i].DPC )
|
|
continue;
|
|
|
|
outmsg.CGA.DPC = SCCP_Param.spc[RelatedSPC[i].NetID];
|
|
outmsg.CDA.ip = INADDR_NONE;
|
|
outmsg.CDA.DPC = RelatedSPC[i].DPC;
|
|
outmsg.CDA.SSN = 1;
|
|
outmsg.CDA.RI = 1;
|
|
outmsg.CDA.len = 0;
|
|
|
|
outmsg.msglen = build_scmgmsg ( outmsg.data, ntype, spc, ssn, NetID );
|
|
send_msg ( &outmsg, mtp3_ansiFlag ( NetID ) );
|
|
}
|
|
}
|
|
|
|
int build_scmgmsg ( BYTE * data, BYTE type, int spc, BYTE ssn, BYTE NetID )
|
|
{
|
|
int pos = 0;
|
|
|
|
data[pos++] = type;
|
|
data[pos++] = ssn;
|
|
memcpy ( data + pos, ( BYTE * ) & spc, SCCP_Param.spclen[NetID] );
|
|
pos += SCCP_Param.spclen[NetID];
|
|
data[pos++] = 0;
|
|
if( type == SSC_MSG )
|
|
data[pos++] = 0;
|
|
return pos;
|
|
}
|
|
|
|
int parse_scmgmsg ( BYTE * data, BYTE * type, int *spc, BYTE * ssn, BYTE NetID )
|
|
{
|
|
int pos = 0;
|
|
|
|
*type = data[pos++];
|
|
*ssn = data[pos++];
|
|
*spc = 0;
|
|
memcpy ( ( BYTE * ) spc, data + pos, SCCP_Param.spclen[NetID] );
|
|
pos += SCCP_Param.spclen[NetID];
|
|
return 1;
|
|
}
|