7880 lines
188 KiB
C
7880 lines
188 KiB
C
/*=========================================*/
|
|
/* */
|
|
/* */
|
|
/* Author: Zane Yi */
|
|
/* Date: 2007.02.01 */
|
|
/* */
|
|
/*=========================================*/
|
|
#include "./include/inc.h"
|
|
#include "./include/isup_if.h"
|
|
#include "./include/isup_struct.h"
|
|
#include "./include/isup_debug.h"
|
|
#include "./include/isup_def.h"
|
|
#include "./include/isup_const.h"
|
|
|
|
|
|
int siSelUnpkFun(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length, u8 variant);
|
|
int siSelPkFun(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type,u8 variant);
|
|
void isup_send_cvr(u32 pid);
|
|
|
|
extern int isup_transit_msg(u8 *raw_dst, u8 *raw_add, u8 len_add, u8 *raw_org, u8 len_org, u8 variant);
|
|
extern u8 isup_msg_test;
|
|
extern up_message isup_raw_msg;
|
|
|
|
|
|
static int find_port_by_sp(u8 ni, u32 dpc, u32 opc, u32 cic, u32* pid)
|
|
{
|
|
const pal_circuit_struct* circuit_str;
|
|
|
|
circuit_str = pal_ss7_find_circuit(ni, dpc, opc, cic);
|
|
|
|
if(circuit_str == NULL)
|
|
{
|
|
isup_log_err(0,"illegal cic value! ni=%d,dpc=%d,opc=%d,cic=%d\r\n",ni,opc,dpc,cic);
|
|
return -1;
|
|
}
|
|
|
|
if(isup_db.attrib.isup_run_mode == ISUP_DUAL_MODE &&
|
|
circuit_str->attrib.plat_id != isup_db.attrib.systemID)
|
|
*pid = 0xFFFFFFFF;
|
|
else
|
|
*pid = ISUP_CIRCUIT_CIC*circuit_str->id +
|
|
(cic - circuit_str->attrib.head_cic);
|
|
return 1;
|
|
}
|
|
|
|
static void isup_transmit_func(u32 remote_ip, up_message *upmsg_ptr)
|
|
{
|
|
if(isup_rv_msg.cic[1]&0xF0)
|
|
upmsg_ptr->cic[1] |= 0x80;
|
|
upmsg_ptr->dest_ip = remote_ip;
|
|
isup_redirect(upmsg_ptr);
|
|
return;
|
|
}
|
|
|
|
int isup_mdsc_proc()
|
|
{
|
|
int ret,circuit_id,cg_id,variant;
|
|
u32 pid,cic_val;
|
|
u8 msg_type;
|
|
u8 *flw_ptr; //message flow pointer
|
|
|
|
ISUP_Port_struct *port_ptr;
|
|
const pal_circuit_struct* circuit_str;
|
|
const pal_cg_struct* cg_str;
|
|
|
|
memset(&isup_rv_msg,0,sizeof(isup_rv_msg));
|
|
if(isup_GetMsg(&isup_rv_msg) == 0)
|
|
return 0;
|
|
|
|
isup_msg_csta(isup_rv_msg.msgList[0],0);
|
|
|
|
cic_val = ((isup_rv_msg.cic[1]&0x0F)<<8) + isup_rv_msg.cic[0];
|
|
|
|
if(find_port_by_sp(isup_rv_msg.sio >>6,isup_rv_msg.opc, isup_rv_msg.dpc, cic_val,&pid)==-1)
|
|
{
|
|
monitor_isup_msg(0,"RV=>",&isup_rv_msg,COL_YELLOW);
|
|
return -1;
|
|
}
|
|
if(pid >= ISUP_MAX_PORT)
|
|
{
|
|
monitor_isup_msg(0,"RV=>",&isup_rv_msg,COL_YELLOW);
|
|
if((isup_rv_msg.cic[1]&0x80) == 0)
|
|
{
|
|
isup_transmit_func(isup_db.attrib.isup_remote_ip, &isup_rv_msg);
|
|
}
|
|
else
|
|
{
|
|
isup_log_err(0,"isup_redirect discard.\r\n");
|
|
}
|
|
return -1;
|
|
}
|
|
monitor_isup_msg(pid,"RV=>",&isup_rv_msg,COL_YELLOW);
|
|
port_ptr = &isup_db.port_pond[pid];
|
|
|
|
flw_ptr = isup_rv_msg.msgList;
|
|
msg_type = isup_rv_msg.msgList[0];
|
|
flw_ptr++;
|
|
memset(&isup_rv_pdus,0,sizeof(isup_rv_pdus));
|
|
|
|
circuit_id = pid/ISUP_CIRCUIT_CIC;
|
|
|
|
circuit_str = pal_circuit_ptr(circuit_id);
|
|
if(circuit_str == NULL)
|
|
{
|
|
isup_log_err(pid,"circuit_str==NULL\r\n");
|
|
return -1;
|
|
}
|
|
|
|
cg_str = pal_cg_ptr(circuit_str->cg_id);
|
|
if(cg_str == NULL)
|
|
{
|
|
isup_log_err(pid,"cg_str==NULL\r\n");
|
|
return -1;
|
|
}
|
|
|
|
variant = cg_str->attrib.variant;
|
|
|
|
ret = siSelUnpkFun(&isup_rv_pdus,flw_ptr,msg_type,isup_rv_msg.len-1,variant);
|
|
if(ret == -2)
|
|
{
|
|
isup_log_err(pid,"[variant:%d]decode nonsupport message,message type=0x%x\r\n",variant,msg_type);
|
|
return -1;
|
|
}
|
|
else if(ret == -1)
|
|
{
|
|
isup_log_err(pid,"[variant:%d]decode error,message type=0x%x\r\n",variant,msg_type);
|
|
return -1;
|
|
}
|
|
|
|
if(isup_msg_test)
|
|
{
|
|
test_isup_msg(msg_type,1);
|
|
return 1;
|
|
}
|
|
|
|
port_ptr->sprc_cmd = msg_type;
|
|
|
|
switch(msg_type)
|
|
{
|
|
case M_ACM:
|
|
case M_ANM:
|
|
case M_CPG:
|
|
case M_CON:
|
|
case M_REL:
|
|
case M_SUS:
|
|
case M_RES:
|
|
case M_SAM:
|
|
case M_IAM:
|
|
case M_RLC:
|
|
if((msg_type==M_RLC)&&isup_check_crs_waiting(pid))
|
|
{
|
|
isup_crs_proc(pid);
|
|
}
|
|
else
|
|
{
|
|
if(port_ptr->cic_state.call_state == START_RESET)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
isup_log_err(pid,"Discard message, pid=%ld,call_state = Reset\r\n",pid);
|
|
}
|
|
else if(port_ptr->cic_state.call_state == CALLOUT_FLAG)
|
|
isup_cpco_proc(pid);
|
|
else
|
|
{
|
|
port_ptr->cic_state.call_state = CALLIN_FLAG;
|
|
isup_cpci_proc(pid);
|
|
}
|
|
}
|
|
break;
|
|
case M_BLO:
|
|
case M_UBL:
|
|
isup_blr_proc(pid);
|
|
break;
|
|
case M_BLA:
|
|
case M_UBA:
|
|
isup_bls_proc(pid);
|
|
break;
|
|
case M_CGB:
|
|
case M_CGU:
|
|
isup_mgbr_proc(pid);
|
|
break;
|
|
case M_CGBA:
|
|
case M_CGUA:
|
|
isup_mgbs_proc(pid);
|
|
break;
|
|
case M_GRS:
|
|
isup_cgrr_proc(pid);
|
|
break;
|
|
case M_GRA:
|
|
isup_cgrs_proc(pid);
|
|
break;
|
|
case M_RSC:
|
|
isup_crr_proc(pid);
|
|
break;
|
|
case M_UCIC:
|
|
isup_event_handle(pid, ISUP_DATA_IND,msg_type);
|
|
isup_log_err(pid,"Idle port=%d.\r\n",pid);
|
|
memset(port_ptr,0,sizeof(port_ptr));
|
|
break;
|
|
case M_CVT:
|
|
port_ptr->sprc_cmd = 0;
|
|
isup_send_cvr(pid);//send resp
|
|
break;
|
|
default:
|
|
isup_event_handle(pid, ISUP_DATA_IND,msg_type);
|
|
port_ptr->sprc_cmd = 0;
|
|
break;
|
|
}
|
|
if(port_ptr->sprc_cmd != 0)
|
|
isup_log_err(pid,"ignore the message,message type=0x%x,cg_id=%d,circuit=%d,cic=%d,port=%d\r\n",msg_type,cg_id,circuit_id,cic_val,pid);
|
|
port_ptr->sprc_cmd = 0;
|
|
monitor_port_state(cic_val,pid);
|
|
return 1;
|
|
}
|
|
|
|
|
|
void isup_msdc_proc(u32 pid, up_message *upmsg_ptr)
|
|
{
|
|
u32 circuit_id,offset;
|
|
u32 cic_val;
|
|
const pal_circuit_struct* circuit_str;
|
|
const pal_cg_struct* cg_str;
|
|
up_message temp_ptr;
|
|
|
|
circuit_id = pid/ISUP_CIRCUIT_CIC;
|
|
offset = pid%ISUP_CIRCUIT_CIC;
|
|
|
|
circuit_str = pal_circuit_ptr(circuit_id);
|
|
if(circuit_str == NULL)
|
|
{
|
|
isup_log_err(pid,"circuit_str==NULL\r\n");
|
|
return;
|
|
}
|
|
|
|
cg_str = pal_cg_ptr(circuit_str->cg_id);
|
|
if(cg_str == NULL)
|
|
{
|
|
isup_log_err(pid,"cg_str==NULL\r\n");
|
|
return;
|
|
}
|
|
|
|
if(offset > circuit_str->attrib.cic_range)
|
|
{
|
|
isup_log_err(pid,"CIC out of range.(pid=%d)\n",pid);
|
|
return;
|
|
}
|
|
|
|
cic_val = circuit_str->attrib.head_cic+offset;
|
|
|
|
upmsg_ptr->dest_ip = 0xffffffff;
|
|
upmsg_ptr->dpc = cg_str->attrib.dpc;
|
|
upmsg_ptr->opc = cg_str->attrib.opc;
|
|
upmsg_ptr->cic[0] = cic_val & 0xff;
|
|
upmsg_ptr->cic[1] = (cic_val >> 8) & 0xff;
|
|
upmsg_ptr->sio = (cg_str->attrib.network_id << 6) | ISUP_SI;
|
|
|
|
if(isup_raw_msg.msgList != NULL && isup_raw_msg.len > 1)
|
|
{
|
|
if(upmsg_ptr->msgList[0]==M_PAM)
|
|
{
|
|
upmsg_ptr->len = isup_raw_msg.len;
|
|
memcpy(upmsg_ptr->msgList,isup_raw_msg.msgList,MAX_SS7_MSG_LEN);
|
|
monitor_isup_msg(pid,"SD<=(pam)",upmsg_ptr,COL_WHITE);
|
|
}
|
|
else
|
|
{
|
|
memset(&temp_ptr,0,sizeof(up_message));
|
|
temp_ptr.len = isup_transit_msg(temp_ptr.msgList,upmsg_ptr->msgList,upmsg_ptr->len,isup_raw_msg.msgList,isup_raw_msg.len,cg_str->attrib.variant);
|
|
if(temp_ptr.len)
|
|
{
|
|
upmsg_ptr->len = temp_ptr.len;
|
|
memcpy(upmsg_ptr->msgList,temp_ptr.msgList,MAX_SS7_MSG_LEN);
|
|
monitor_isup_msg(pid,"SD<=(t)",upmsg_ptr,COL_WHITE);
|
|
}
|
|
else
|
|
monitor_isup_msg(pid,"SD<=(f)",upmsg_ptr,COL_WHITE);
|
|
}
|
|
memset(&isup_raw_msg,0,sizeof(up_message));
|
|
}
|
|
else
|
|
monitor_isup_msg(pid,"SD<=(i)",upmsg_ptr,COL_WHITE);
|
|
|
|
isup_msg_csta(upmsg_ptr->msgList[0],1);
|
|
if(isup_to_mtp3(upmsg_ptr)<0)
|
|
isup_log_err(pid,"send to mtp3 failed.\r\n");
|
|
return;
|
|
}
|
|
|
|
|
|
int isup_send_msg(u32 pid, u8 msg_type)
|
|
{
|
|
int ret,circuit_id,variant;
|
|
const pal_circuit_struct* circuit_str;
|
|
const pal_cg_struct* cg_str;
|
|
up_message *upmsg_ptr = &isup_sd_msg;
|
|
|
|
memset(&isup_sd_msg,0,sizeof(isup_sd_msg));
|
|
|
|
circuit_id = pid/ISUP_CIRCUIT_CIC;
|
|
|
|
circuit_str = pal_circuit_ptr(circuit_id);
|
|
if(circuit_str == NULL)
|
|
{
|
|
isup_log_err(pid,"circuit_str==NULL\r\n");
|
|
return -1;
|
|
}
|
|
|
|
cg_str = pal_cg_ptr(circuit_str->cg_id);
|
|
if(cg_str == NULL)
|
|
{
|
|
isup_log_err(pid,"cg_str==NULL\r\n");
|
|
return -1;
|
|
}
|
|
|
|
variant = cg_str->attrib.variant;
|
|
|
|
ret = siSelPkFun(&isup_sd_pdus,upmsg_ptr->msgList+1,msg_type,variant);
|
|
if(ret == -2)
|
|
{
|
|
isup_log_err(pid,"[variant:%d]encode nonsupport message failed,MSG=0x%x\r\n",variant,msg_type);
|
|
return -1;
|
|
}
|
|
else if(ret == -1)
|
|
{
|
|
isup_log_err(pid,"[variant:%d]encode error,message type=0x%x\r\n",variant,msg_type);
|
|
return -1;
|
|
}
|
|
upmsg_ptr->msgList[0] = msg_type;
|
|
upmsg_ptr->len = ret+1;
|
|
isup_msdc_proc(pid, upmsg_ptr);
|
|
return 1;
|
|
}
|
|
|
|
/* unpacking functions for ISUP information elements */
|
|
int siUnpkSiAccDelInfo (SiAccDelInfo *pAccDelInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pAccDelInfo->pres = 1;
|
|
pAccDelInfo->delInd = mBuf[0] & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int siUnpkAccTrnspt (SiAccTrnspt *pAccTrnspt,u8 *mBuf, u8 length)
|
|
{
|
|
pAccTrnspt->pres = 1;
|
|
pAccTrnspt->infoLen = length;
|
|
memcpy(pAccTrnspt->infoElmts,mBuf,pAccTrnspt->infoLen);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int siUnpkAutoCongLvl (SiAutoCongLvl *pAutoCongLvl,u8 *mBuf, u8 length)
|
|
{
|
|
pAutoCongLvl->pres = 1;
|
|
pAutoCongLvl->auCongLvl = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkBckCalInd (SiBckCalInd *pBckCalInd,u8 *mBuf, u8 length)
|
|
{
|
|
pBckCalInd->pres = 1;
|
|
pBckCalInd->chrgInd = mBuf[0] & 0x03 ;
|
|
pBckCalInd->cadPtyStatInd = (mBuf[0]>>2) & 0x03;
|
|
pBckCalInd->cadPtyCatInd = (mBuf[0]>>4) & 0x03;
|
|
pBckCalInd->end2EndMethInd = (mBuf[0]>>6) & 0x03;
|
|
pBckCalInd->intInd = mBuf[1] & 0x01 ;
|
|
pBckCalInd->end2EndInfoInd = (mBuf[1]>>1) & 0x01;
|
|
pBckCalInd->isdnUsrPrtInd = (mBuf[1]>>2) & 0x01;
|
|
pBckCalInd->holdInd = (mBuf[1]>>3) & 0x01;
|
|
pBckCalInd->isdnAccInd = (mBuf[1]>>4) & 0x01;
|
|
pBckCalInd->echoCtrlDevInd = (mBuf[1]>>5) & 0x01;
|
|
pBckCalInd->sccpMethInd = (mBuf[1]>>6) & 0x03;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int siUnpkSiCllDiverInfo (SiCllDiverInfo *pCllDivr,u8 *mBuf, u8 length)
|
|
{
|
|
pCllDivr->pres = 1;
|
|
pCllDivr->notSuscr = mBuf[0] & 0x07;
|
|
pCllDivr->redirRsn = mBuf[0]>>3 &0x0F;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiPropDly (SiPropDly *pPropDly,u8 *mBuf, u8 length)
|
|
{
|
|
pPropDly->pres = 1;
|
|
pPropDly->delayVal = (mBuf[0]<<8) | mBuf[1];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCallRef (SiCallRef *pCallRef,u8 *mBuf, u8 length)
|
|
{
|
|
pCallRef->pres = 1;
|
|
pCallRef->callId[0] = mBuf[0];
|
|
pCallRef->callId[1] = mBuf[1];
|
|
pCallRef->callId[2] = mBuf[2];
|
|
pCallRef->pntCde = mBuf[3]|((mBuf[4]&0x3F)<<8);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCdPtyNum (SiCdPtyNum *pCdPtyNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pCdPtyNum->pres = 1;
|
|
pCdPtyNum->natAddrInd = mBuf[0] & 0x07F;
|
|
pCdPtyNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pCdPtyNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
pCdPtyNum->innInd = (mBuf[1]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pCdPtyNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pCdPtyNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pCdPtyNum->oddEven) && (j > 0))
|
|
j--;
|
|
pCdPtyNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkCgPtyNum (SiCgPtyNum *pCgPtyNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pCgPtyNum->pres = 1;
|
|
pCgPtyNum->natAddrInd = mBuf[0] & 0x7F;
|
|
pCgPtyNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pCgPtyNum->scrnInd = mBuf[1] & 0x03;
|
|
pCgPtyNum->presRest = (mBuf[1]>>2) & 0x03;
|
|
pCgPtyNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
pCgPtyNum->niInd = (mBuf[1]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pCgPtyNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pCgPtyNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pCgPtyNum->oddEven) && (j > 0))
|
|
j--;
|
|
pCgPtyNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCgPtyCat (SiCgPtyCat *pCgPtyCat,u8 *mBuf, u8 length)
|
|
{
|
|
pCgPtyCat->pres = 1;
|
|
pCgPtyCat->cgPtyCat = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkCauseDgn (SiCauseDgn *pCauseDgn,u8 *mBuf, u8 length)
|
|
{
|
|
pCauseDgn->pres = 1;
|
|
pCauseDgn->location = mBuf[0]&0x0F;
|
|
pCauseDgn->cdeStand = (mBuf[0]>>5) &0x03;
|
|
|
|
if((mBuf[0]&0x80)==0x80)
|
|
{
|
|
pCauseDgn->causeVal = mBuf[1]&0x7F;
|
|
if(length>2)
|
|
{
|
|
pCauseDgn->length = (length-2);
|
|
memcpy(pCauseDgn->dgnVal,mBuf+2,pCauseDgn->length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pCauseDgn->causeVal = mBuf[2]&0x7F;
|
|
if(length>3)
|
|
{
|
|
pCauseDgn->length = (length-3);
|
|
memcpy(pCauseDgn->dgnVal,mBuf+3,pCauseDgn->length);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkCirGrpSupMTypInd (SiCirGrpSupMTypInd *pCgsmti,u8 *mBuf, u8 length)
|
|
{
|
|
pCgsmti->pres = 1;
|
|
pCgsmti->typeInd = mBuf[0]&0x03;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkCirStateInd (SiCirStateInd *pCirStateInd,u8 *mBuf, u8 length)
|
|
{
|
|
pCirStateInd->pres = 1;
|
|
pCirStateInd->length = length;
|
|
memcpy(pCirStateInd->cirSteInd,mBuf,pCirStateInd->length);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkCugIntCode (SiCugIntCode *pCugIntCode,u8 *mBuf, u8 length)
|
|
{
|
|
pCugIntCode->pres = 1;
|
|
pCugIntCode->dig1 = (mBuf[0]>>4)&0x0F;
|
|
pCugIntCode->dig2 = (mBuf[0])&0x0F;
|
|
pCugIntCode->dig3 = (mBuf[1]>>4)&0x0F;
|
|
pCugIntCode->dig4 = (mBuf[1])&0x0F;
|
|
pCugIntCode->binCde = (mBuf[2]<<8)|mBuf[3];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkConnectedNum (SiConnectedNum *pConnectedNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pConnectedNum->pres = 1;
|
|
pConnectedNum->natAddrInd = mBuf[0] & 0x7F;
|
|
pConnectedNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pConnectedNum->scrnInd = mBuf[1] & 0x03;
|
|
pConnectedNum->presRest = (mBuf[1]>>2) & 0x03;
|
|
pConnectedNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pConnectedNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pConnectedNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pConnectedNum->oddEven) && (j > 0))
|
|
j--;
|
|
pConnectedNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkConnReq (SiConnReq *pConnReq,u8 *mBuf, u8 length)
|
|
{
|
|
pConnReq->pres = 1;
|
|
pConnReq->locRef[0] = mBuf[0];
|
|
pConnReq->locRef[1] = mBuf[1];
|
|
pConnReq->locRef[2] = mBuf[2];
|
|
pConnReq->pntCde = mBuf[3]|((mBuf[4]&0x3F)<<8);
|
|
pConnReq->protClass = mBuf[5];
|
|
pConnReq->credit = mBuf[6];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkContInd (SiContInd *pContInd,u8 *mBuf, u8 length)
|
|
{
|
|
pContInd->pres = 1;
|
|
pContInd->contInd = mBuf[0]&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiEchoCtl (SiEchoCtl *pEchoCtl,u8 *mBuf, u8 length)
|
|
{
|
|
pEchoCtl->pres = 1;
|
|
pEchoCtl->outEchoRsp = mBuf[0]&0x03;
|
|
pEchoCtl->incEchoRsp = (mBuf[0]>>2)&0x03;
|
|
pEchoCtl->outEchoReq = (mBuf[0]>>4)&0x03;
|
|
pEchoCtl->incEchoReq = (mBuf[0]>>6)&0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkEvntInfo (SiEvntInfo *pEvntInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pEvntInfo->pres = 1;
|
|
pEvntInfo->evntInd = mBuf[0]&0x7F;
|
|
pEvntInfo->evntPresResInd = mBuf[0]>>7&0x01;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkFacInd (SiFacInd *pFacInd,u8 *mBuf, u8 length)
|
|
{
|
|
pFacInd->pres = 1;
|
|
pFacInd->facInd = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkFwdCallInd (SiFwdCallInd *pFwdCallInd,u8 *mBuf, u8 length)
|
|
{
|
|
pFwdCallInd->pres = 1;
|
|
pFwdCallInd->natIntCallInd = mBuf[0] & 0x01;
|
|
pFwdCallInd->end2EndMethInd = mBuf[0]>>1 &0x03;
|
|
pFwdCallInd->intInd = mBuf[0]>>3 &0x01;
|
|
pFwdCallInd->end2EndInfoInd = mBuf[0]>>4 &0x01;
|
|
pFwdCallInd->isdnUsrPrtInd = mBuf[0]>>5 &0x01;
|
|
pFwdCallInd->isdnUsrPrtPrfInd = mBuf[0]>>6 &0x03;
|
|
pFwdCallInd->isdnAccInd = mBuf[1] &0x01;
|
|
pFwdCallInd->sccpMethInd = mBuf[1]>>1 &0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkFreePhParam (SiFreePhInd *pFreePhInd,u8 *mBuf, u8 length){return 1;}//reserved
|
|
|
|
int siUnpkSiGenDigits (SiGenDigits *pGenDigits,u8 *mBuf, u8 length)
|
|
{
|
|
pGenDigits->pres = 1;
|
|
pGenDigits->typeOfDigits = (mBuf[0]) & 0x1F;
|
|
pGenDigits->encodeScheme = (mBuf[0]>>5)&0x07;
|
|
pGenDigits->length = length-1;
|
|
memcpy(pGenDigits->digits, mBuf+1, pGenDigits->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkNotifInd (SiNotifInd *pNotifInd,u8 *mBuf, u8 length)
|
|
{
|
|
pNotifInd->pres = 1;
|
|
pNotifInd->notifInd = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiGenNum (SiGenNum *pGenNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pGenNum->pres = 1;
|
|
pGenNum->nmbQual = mBuf[0];
|
|
pGenNum->natAddrInd = mBuf[1] & 0x07F;
|
|
pGenNum->oddEven = (mBuf[1]>>7) & 0x01;
|
|
pGenNum->scrnInd = mBuf[2] & 0x03;
|
|
pGenNum->presRest = (mBuf[2]>>2) & 0x03;
|
|
pGenNum->numPlan = (mBuf[2]>>4) & 0x07;
|
|
pGenNum->niInd = (mBuf[2]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+3;
|
|
for(i = 0, j = 0; i < length-3; i++)
|
|
{
|
|
pGenNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pGenNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pGenNum->oddEven) && (j > 0))
|
|
j--;
|
|
pGenNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkHopCounter (SiHopCounter *pHopCounter,u8 *mBuf, u8 length)
|
|
{
|
|
pHopCounter->pres = 1;
|
|
pHopCounter->hopCounter = mBuf[0]&0x1F;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkInfoInd (SiInfoInd *pInfoInd,u8 *mBuf, u8 length)
|
|
{
|
|
pInfoInd->pres = 1;
|
|
pInfoInd->cgPtyAddrRespInd = mBuf[0] & 0x03;
|
|
pInfoInd->holdProvInd = mBuf[0]>>2 & 0x01;
|
|
pInfoInd->cgPtyCatRespInd = mBuf[0]>>5 & 0x01;
|
|
pInfoInd->chrgInfoRespInd = mBuf[0]>>6 & 0x01;
|
|
pInfoInd->solInfoInd = mBuf[0]>>7 & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkInfoReqInd (SiInfoReqInd *pInfoReqInd,u8 *mBuf, u8 length)
|
|
{
|
|
pInfoReqInd->pres = 1;
|
|
pInfoReqInd->cgPtyAdReqInd = mBuf[0] & 0x01;
|
|
pInfoReqInd->holdingInd = mBuf[0]>>1 & 0x01;
|
|
pInfoReqInd->cgPtyCatReqInd = mBuf[0]>>3 & 0x01;
|
|
pInfoReqInd->chrgInfoReqInd = mBuf[0]>>4 & 0x01;
|
|
pInfoReqInd->malCaIdReqInd = mBuf[0]>>7 & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiMcidRspInd (SiMcidRspInd *pMcidRsp,u8 *mBuf, u8 length)
|
|
{
|
|
pMcidRsp->pres = 1;
|
|
pMcidRsp->rspInd = mBuf[0]&0x01;
|
|
pMcidRsp->hldInd = (mBuf[0]>>1)&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiMcidReqInd (SiMcidReqInd *pMcidReq,u8 *mBuf, u8 length)
|
|
{
|
|
pMcidReq->pres = 1;
|
|
pMcidReq->reqInd = mBuf[0]&0x01;
|
|
pMcidReq->hldInd = (mBuf[0]>>1)&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiMsgCompInfo (SiMsgCompInfo *pMsgCom,u8 *mBuf, u8 length)
|
|
{
|
|
pMsgCom->pres = 1;
|
|
pMsgCom->tranXInd = mBuf[0]&0x01;
|
|
pMsgCom->relCllInd = (mBuf[0]>>1)&0x01;
|
|
pMsgCom->sndNotInd = (mBuf[0]>>2)&0x01;
|
|
pMsgCom->dcrdMsgInd = (mBuf[0]>>3)&0x01;
|
|
pMsgCom->passNotPoss = (mBuf[0]>>4)&0x01;
|
|
pMsgCom->bbNbIntwkI = (mBuf[0]>>5)&0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiMlppPrec (SiMlppPrec *pMlppPrec,u8 *mBuf, u8 length)
|
|
{
|
|
pMlppPrec->pres = 1;
|
|
pMlppPrec->precdLvl = mBuf[0] & 0x0F;
|
|
pMlppPrec->lfb = (mBuf[0]>>5) & 0x03;
|
|
pMlppPrec->frstDig = (mBuf[1]>>4) & 0x0F;
|
|
pMlppPrec->scndDig = (mBuf[1]) & 0x0F;
|
|
pMlppPrec->thrdDig = (mBuf[2]>>4) & 0x0F;
|
|
pMlppPrec->frthDig = (mBuf[2]) & 0x0F;
|
|
pMlppPrec->servDomain = (mBuf[3]<<16)|(mBuf[4]<<8)|mBuf[5];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkNatConInd (SiNatConInd *pNatConInd,u8 *mBuf, u8 length)
|
|
{
|
|
pNatConInd->pres = 1;
|
|
pNatConInd->satInd = mBuf[0] & 0x03;
|
|
pNatConInd->contChkInd = mBuf[0]>>2 & 0x03;
|
|
pNatConInd->echoCntrlDevInd = mBuf[0]>>4 & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiNetSpecFacil (SiNetSpecFacil *pNetFac,u8 *mBuf, u8 length)
|
|
{
|
|
pNetFac->pres = 1;
|
|
pNetFac->length = length;
|
|
memcpy(pNetFac->netFac,mBuf,pNetFac->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkOptBckCalInd (SiOptBckCalInd *pOptBckCalInd,u8 *mBuf, u8 length)
|
|
{
|
|
pOptBckCalInd->pres = 1;
|
|
pOptBckCalInd->inbndInfoInd = mBuf[0]&0x01;
|
|
pOptBckCalInd->caFwdMayOcc = mBuf[0]>>1&0x01;
|
|
pOptBckCalInd->simpleSegmInd = mBuf[0]>>2&0x01;
|
|
pOptBckCalInd->mlppUserInd = mBuf[0]>>3&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkOpFwdCalInd (SiOpFwdCalInd *pOpFwdCalInd,u8 *mBuf, u8 length)
|
|
{
|
|
pOpFwdCalInd->pres = 1;
|
|
pOpFwdCalInd->clsdUGrpCaInd = mBuf[0]&0x03;
|
|
pOpFwdCalInd->simpleSegmInd = mBuf[0]>>2&0x01;
|
|
pOpFwdCalInd->conLineIdReqInd = mBuf[0]>>7&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkOrigCdNum (SiOrigCdNum *pOrigCdNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pOrigCdNum->pres = 1;
|
|
pOrigCdNum->natAddrInd = mBuf[0] & 0x07F;
|
|
pOrigCdNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pOrigCdNum->presRest = (mBuf[1]>>2) & 0x03;
|
|
pOrigCdNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pOrigCdNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pOrigCdNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pOrigCdNum->oddEven) && (j > 0))
|
|
j--;
|
|
pOrigCdNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSigPointCode (SiSigPointCode *pSigPointCode,u8 *mBuf, u8 length)
|
|
{
|
|
pSigPointCode->pres = 1;
|
|
pSigPointCode->sigPointCode = ((mBuf[1]&0x3F)<<8)|mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiParmCompInfo (SiParmCompInfo *pParmCom,u8 *mBuf, u8 length)
|
|
{
|
|
pParmCom->pres = 1;
|
|
pParmCom->length = length;
|
|
memcpy(pParmCom->content,mBuf,pParmCom->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkRangStat (SiRangStat *pRangStat,u8 *mBuf, u8 length)
|
|
{
|
|
int status_len;
|
|
pRangStat->pres = 1;
|
|
pRangStat->range = mBuf[0];
|
|
|
|
status_len = ((pRangStat->range&0x07) == 0)? (pRangStat->range>>3) : ((pRangStat->range>>3) + 1);
|
|
memcpy(pRangStat->status, mBuf+1, status_len%(ISUP_STATUS_LEN+1));
|
|
if(length > 5)
|
|
pRangStat->range = 32; //error and Discard
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkRangNoStat (SiRangNoStat *pRangStat,u8 *mBuf, u8 length)
|
|
{
|
|
pRangStat->pres = 1;
|
|
pRangStat->range = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkRedirInfo (SiRedirInfo *pRedirInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pRedirInfo->pres = 1;
|
|
pRedirInfo->redirInd = mBuf[0]&0x07;
|
|
pRedirInfo->origRedirReas = mBuf[0]>>4&0x0F;
|
|
pRedirInfo->redirCnt = mBuf[1]&0x07;
|
|
pRedirInfo->redirReas = mBuf[1]>>4&0x0F;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkRedirgNum (SiRedirNum *pRedirgNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pRedirgNum->pres = 1;
|
|
pRedirgNum->natAddrInd = mBuf[0] & 0x07F;
|
|
pRedirgNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pRedirgNum->presRest = (mBuf[1]>>2) & 0x03;
|
|
pRedirgNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pRedirgNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pRedirgNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pRedirgNum->oddEven) && (j > 0))
|
|
j--;
|
|
pRedirgNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiRedirRestr (SiRedirRestr *pRedirRstr,u8 *mBuf, u8 length)
|
|
{
|
|
pRedirRstr->pres = 1;
|
|
pRedirRstr->presRest = mBuf[0]&0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiRemotOper (SiRemotOper *pRemotOper,u8 *mBuf, u8 length)
|
|
{
|
|
pRemotOper->pres = 1;
|
|
pRemotOper->length = length;
|
|
memcpy(pRemotOper->content,mBuf,pRemotOper->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkServiceAct (SiServiceAct *pServiceAct,u8 *mBuf, u8 length)
|
|
{
|
|
pServiceAct->pres = 1;
|
|
pServiceAct->length = length;
|
|
memcpy(pServiceAct->serviceAct,mBuf,pServiceAct->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSubNum (SiSubNum *pSubNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pSubNum->pres = 1;
|
|
pSubNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+1;
|
|
for(i = 0, j = 0; i < length-1; i++)
|
|
{
|
|
pSubNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pSubNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pSubNum->oddEven) && (j > 0))
|
|
j--;
|
|
pSubNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSusResInd (SiSusResInd *pSusResInd,u8 *mBuf, u8 length)
|
|
{
|
|
pSusResInd->pres = 1;
|
|
pSusResInd->susResInd = mBuf[0]&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkTranNetSel (SiTranNetSel *pTranNetSel,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pTranNetSel->pres = 1;
|
|
pTranNetSel->netIdPln = mBuf[0] & 0x0F;
|
|
pTranNetSel->typNetId = (mBuf[0]>>4) & 0x07;
|
|
pTranNetSel->oddEven = (mBuf[0]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+1;
|
|
for(i = 0, j = 0; i < length-1; i++)
|
|
{
|
|
pTranNetSel->netId[j++] = num_ptr[i] & 0x0f;
|
|
pTranNetSel->netId[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pTranNetSel->oddEven) && (j > 0))
|
|
j--;
|
|
pTranNetSel->numOfDigit = j;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkTxMedReq (SiTxMedReq *pTxMedReq,u8 *mBuf, u8 length)
|
|
{
|
|
pTxMedReq->pres = 1;
|
|
pTxMedReq->trMedReq = mBuf[0];
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiUsrServInfo (SiUsrServInfo *pUsrServInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pUsrServInfo->pres = 1;
|
|
pUsrServInfo->length = length;
|
|
memcpy(pUsrServInfo->content,mBuf,pUsrServInfo->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiUsrTSrvInfo (SiUsrTSrvInfo *pUsrTSrvInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pUsrTSrvInfo->pres = 1;
|
|
pUsrTSrvInfo->length = length;
|
|
memcpy(pUsrTSrvInfo->content,mBuf,pUsrTSrvInfo->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkUsr2UsrInd (SiUsr2UsrInd *pUsr2UsrInd,u8 *mBuf, u8 length)
|
|
{
|
|
pUsr2UsrInd->pres = 1;
|
|
pUsr2UsrInd->type = mBuf[0]&0x01;
|
|
pUsr2UsrInd->serv1 = (mBuf[0]>>1)&0x03;
|
|
pUsr2UsrInd->serv2 = (mBuf[0]>>3)&0x03;
|
|
pUsr2UsrInd->serv3 = (mBuf[0]>>5)&0x03;
|
|
pUsr2UsrInd->spare = (mBuf[0]>>7)&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkUsr2UsrInfo (SiUsr2UsrInfo *pUsr2UsrInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pUsr2UsrInfo->pres = 1;
|
|
pUsr2UsrInfo->length = length;
|
|
memcpy(pUsr2UsrInfo->info, mBuf, pUsr2UsrInfo->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkPassAlng (SiPassAlng *pPassAlng,u8 *mBuf, u8 length)
|
|
{
|
|
pPassAlng->pres = 1;
|
|
pPassAlng->length = length;
|
|
memcpy(pPassAlng->passAlng,mBuf,pPassAlng->length);
|
|
return 1;
|
|
}
|
|
|
|
/* unpacking functions for ITU97/ETSIV3 Information Element */
|
|
int siUnpkSiConfTrtInd (SiConfTrtInd *pConfTrtInd,u8 *mBuf, u8 length)
|
|
{
|
|
pConfTrtInd->pres = 1;
|
|
pConfTrtInd->confAcceptInd = mBuf[0]&0x03;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pConfTrtInd->length = length-1;
|
|
memcpy(pConfTrtInd->extInfo,mBuf+1,pConfTrtInd->length);
|
|
}
|
|
else
|
|
pConfTrtInd->length = 0;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkUidActionInd (SiUidActionInd *pUidActionInd,u8 *mBuf, u8 length)
|
|
{
|
|
pUidActionInd->pres = 1;
|
|
pUidActionInd->throughConnInstInd = mBuf[0]&0x01;
|
|
pUidActionInd->t9InstInd = (mBuf[0]>>1)&0x01;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pUidActionInd->length = length-1;
|
|
memcpy(pUidActionInd->extInfo,mBuf+1,pUidActionInd->length);
|
|
}
|
|
else
|
|
pUidActionInd->length = 0;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkBackGVNS (SiBackGVNS *pBackGVNS,u8 *mBuf, u8 length)
|
|
{
|
|
pBackGVNS->pres = 1;
|
|
pBackGVNS->termAccessInd = mBuf[0]&0x03;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pBackGVNS->length = length-1;
|
|
memcpy(pBackGVNS->extInfo,mBuf+1,pBackGVNS->length);
|
|
}
|
|
else
|
|
pBackGVNS->length = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkDisplayInfo (SiDisplayInfo *pDisplayInfo,u8 *mBuf, u8 length)
|
|
{
|
|
pDisplayInfo->pres = 1;
|
|
pDisplayInfo->length = length;
|
|
memcpy(pDisplayInfo->displayInfo,mBuf,pDisplayInfo->length);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkForwardGVNS (SiForwardGVNS *pForwardGVNS,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j,point;
|
|
u8 *num_ptr;
|
|
|
|
pForwardGVNS->pres = 1;
|
|
point = 0;
|
|
//Originating participating service provider
|
|
pForwardGVNS->lenInd1 = mBuf[point] & 0x0F;
|
|
if(pForwardGVNS->lenInd1 > 4)
|
|
pForwardGVNS->lenInd1 = 4;
|
|
pForwardGVNS->oddEven1 = (mBuf[point]>>7) & 0x01;
|
|
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < pForwardGVNS->lenInd1; i++)
|
|
{
|
|
pForwardGVNS->digits1[j++] = num_ptr[i] & 0x0f;
|
|
pForwardGVNS->digits1[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pForwardGVNS->oddEven1) && (j > 0))
|
|
j--;
|
|
pForwardGVNS->numOfDigit1 = j;
|
|
if(pForwardGVNS->numOfDigit1 > 7)
|
|
pForwardGVNS->numOfDigit1 = 7;
|
|
point +=pForwardGVNS->lenInd1;
|
|
|
|
//GVNS user group
|
|
pForwardGVNS->lenInd2 = mBuf[point] & 0x0F;
|
|
if(pForwardGVNS->lenInd2 > 8)
|
|
pForwardGVNS->lenInd2 = 8;
|
|
|
|
pForwardGVNS->oddEven2 = (mBuf[point]>>7) & 0x01;
|
|
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < pForwardGVNS->lenInd2; i++)
|
|
{
|
|
pForwardGVNS->digits2[j++] = num_ptr[i] & 0x0f;
|
|
pForwardGVNS->digits2[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pForwardGVNS->oddEven2) && (j > 0))
|
|
j--;
|
|
pForwardGVNS->numOfDigit2 = j;
|
|
point +=pForwardGVNS->lenInd2;
|
|
|
|
//Terminating network routing number
|
|
pForwardGVNS->lenInd3 = mBuf[point] & 0x0F;
|
|
if(pForwardGVNS->lenInd3 > 9)
|
|
pForwardGVNS->lenInd3 = 9;
|
|
if(pForwardGVNS->lenInd3 == 0)
|
|
pForwardGVNS->lenInd3 = 1;
|
|
pForwardGVNS->numPlan = (mBuf[point]>>4) & 0x07;
|
|
pForwardGVNS->oddEven3 = (mBuf[point]>>7) & 0x01;
|
|
pForwardGVNS->natOfAddr = mBuf[++point] & 0x7f;
|
|
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < pForwardGVNS->lenInd3-1; i++)
|
|
{
|
|
pForwardGVNS->digits3[j++] = num_ptr[i] & 0x0f;
|
|
pForwardGVNS->digits3[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pForwardGVNS->oddEven3) && (j > 0))
|
|
j--;
|
|
pForwardGVNS->numOfDigit3 = j;
|
|
return 1;
|
|
}
|
|
int siUnpkCcss (SiCcss *pCcss,u8 *mBuf, u8 length)
|
|
{
|
|
pCcss->pres = 1;
|
|
pCcss->ccssCallInd = mBuf[0] & 0x01;
|
|
return 1;
|
|
}
|
|
int siUnpkNetMgmtControls (SiNetMgmtControls *pNetMgmtControls,u8 *mBuf, u8 length)
|
|
{
|
|
pNetMgmtControls->pres = 1;
|
|
pNetMgmtControls->tmpAltRoutInd = mBuf[0] & 0x01;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pNetMgmtControls->length = length-1;
|
|
memcpy(pNetMgmtControls->extInfo,mBuf+1,pNetMgmtControls->length);
|
|
}
|
|
else
|
|
pNetMgmtControls->length = 0;
|
|
return 1;
|
|
}
|
|
int siUnpkCirAsgnMap (SiCirAsgnMap *pCirAsgnMap,u8 *mBuf, u8 length)
|
|
{
|
|
pCirAsgnMap->pres = 1;
|
|
pCirAsgnMap->mapType = mBuf[0] & 0x3f;
|
|
memcpy(pCirAsgnMap->mapFormat,mBuf+1,4);
|
|
return 1;
|
|
|
|
}
|
|
int siUnpkCorrelationId (SiCorrelationId *pCorrelationId,u8 *mBuf, u8 length)
|
|
{
|
|
pCorrelationId->pres = 1;
|
|
pCorrelationId->length = length;
|
|
memcpy(pCorrelationId->correlationId,mBuf,pCorrelationId->length);
|
|
return 1;
|
|
}
|
|
int siUnpkCallDivTrtInd (SiCallDivTrtInd *pCallDivTrtInd,u8 *mBuf, u8 length)
|
|
{
|
|
pCallDivTrtInd->pres = 1;
|
|
pCallDivTrtInd->callDivInd = mBuf[0] & 0x03;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pCallDivTrtInd->length = length-1;
|
|
memcpy(pCallDivTrtInd->extInfo,mBuf+1,pCallDivTrtInd->length);
|
|
}
|
|
else
|
|
pCallDivTrtInd->length = 0;
|
|
return 1;
|
|
}
|
|
int siUnpkCallInNmb (SiCallInNmb *pCallInNmb,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pCallInNmb->pres = 1;
|
|
pCallInNmb->natAddrInd = mBuf[0] & 0x07F;
|
|
pCallInNmb->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pCallInNmb->presRest = (mBuf[1]>>2) & 0x03;
|
|
pCallInNmb->numPlan = (mBuf[1]>>4) & 0x07;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pCallInNmb->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pCallInNmb->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pCallInNmb->oddEven) && (j > 0))
|
|
j--;
|
|
pCallInNmb->numOfDigit = j;
|
|
return 1;
|
|
}
|
|
int siUnpkCallOfferTrtInd (SiCallOfferTrtInd *pCallOfferTrtInd,u8 *mBuf, u8 length)
|
|
{
|
|
pCallOfferTrtInd->pres = 1;
|
|
pCallOfferTrtInd->callOfferInd = mBuf[0] & 0x03;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pCallOfferTrtInd->length = length-1;
|
|
memcpy(pCallOfferTrtInd->extInfo,mBuf+1,pCallOfferTrtInd->length);
|
|
}
|
|
else
|
|
pCallOfferTrtInd->length = 0;
|
|
return 1;
|
|
}
|
|
int siUnpkScfId (SiScfId *pScfId,u8 *mBuf, u8 length)
|
|
{
|
|
pScfId->pres = 1;
|
|
pScfId->length = length;
|
|
memcpy(pScfId->scfId,mBuf,pScfId->length);
|
|
return 1;
|
|
}
|
|
int siUnpkUidCapInd (SiUidCapInd *pUidCapInd,u8 *mBuf, u8 length)
|
|
{
|
|
pUidCapInd->pres = 1;
|
|
pUidCapInd->throughConnInstInd = mBuf[0]&0x01;
|
|
pUidCapInd->t9InstInd = (mBuf[0]>>1)&0x01;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
{
|
|
pUidCapInd->length = length-1;
|
|
memcpy(pUidCapInd->extInfo,mBuf+1,pUidCapInd->length);
|
|
}
|
|
else
|
|
pUidCapInd->length = 0;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCollCallReq (SiCollCallReq *pCollCallReq,u8 *mBuf, u8 length)
|
|
{
|
|
pCollCallReq->pres = 1;
|
|
pCollCallReq->collCallReqInd = mBuf[0]&0x01;
|
|
return 1;
|
|
}
|
|
int siUnpkNaPaChgPID (SiNaPaChgPID *pNaPaChgPID,u8 *mBuf, u8 length)
|
|
{
|
|
pNaPaChgPID->pres = 1;
|
|
pNaPaChgPID->length = length;
|
|
memcpy(pNaPaChgPID->naPaChgPtyId,mBuf,pNaPaChgPID->length);
|
|
return 1;
|
|
}
|
|
int siUnpkCallTRef (SiCallTRef *pCallTRef,u8 *mBuf, u8 length)
|
|
{
|
|
pCallTRef->pres = 1;
|
|
pCallTRef->callTrnsfr = mBuf[0];
|
|
return 1;
|
|
|
|
}
|
|
int siUnpkLoopPrvntInd (SiLoopPrvntInd *pLoopPrvntInd,u8 *mBuf, u8 length)
|
|
{
|
|
pLoopPrvntInd->pres = 1;
|
|
pLoopPrvntInd->loopPrvntType = mBuf[0]&0x01;
|
|
pLoopPrvntInd->loopPrvntRspInd = (mBuf[0]>>1)&0x03;
|
|
return 1;
|
|
|
|
}
|
|
int siUnpkAppTransParam (SiAppTransParam *pAppTransParam,u8 *mBuf, u8 length)
|
|
{
|
|
pAppTransParam->pres = 1;
|
|
pAppTransParam->appContextId = mBuf[0]&0x7f;
|
|
pAppTransParam->atii = mBuf[1]&0x03;
|
|
pAppTransParam->apmSegInd = mBuf[2]&0x3f;
|
|
pAppTransParam->seqInd = (mBuf[2]>>6)&0x01;
|
|
if((mBuf[2]&0x80)!=0x80)
|
|
{
|
|
pAppTransParam->slr = mBuf[3]&0x7f;
|
|
pAppTransParam->length = length-4;
|
|
memcpy(pAppTransParam->encapAppInfo,mBuf+4,pAppTransParam->length);
|
|
}
|
|
else
|
|
{
|
|
pAppTransParam->length = length-3;
|
|
memcpy(pAppTransParam->encapAppInfo,mBuf+3,pAppTransParam->length);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* unpacking functions for UK specific Information Element */
|
|
int siUnpkSiNatForCalInd (SiNatForCalInd *pNatForCalInd,u8 *mBuf, u8 length)
|
|
{
|
|
pNatForCalInd->pres = 1;
|
|
pNatForCalInd->cbi = mBuf[0]&0x01;
|
|
pNatForCalInd->ntaInd = (mBuf[0]>>1)&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiNatForCalIndLbL (SiNatForCalIndLbL *pNatForCalIndLbL,u8 *mBuf, u8 length)
|
|
{
|
|
pNatForCalIndLbL->pres = 1;
|
|
pNatForCalIndLbL->rci = mBuf[0]&0x0f;
|
|
if((mBuf[0]&0x80)!=0x80)
|
|
pNatForCalIndLbL->isi = mBuf[1]&0x0f;
|
|
else
|
|
pNatForCalIndLbL->isi = 0;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkSiPresNum (SiPresNum *pPresNum,u8 *mBuf, u8 length)
|
|
{
|
|
int i,j;
|
|
u8 *num_ptr;
|
|
|
|
pPresNum->pres = 1;
|
|
pPresNum->natAddrInd = mBuf[0] & 0x7F;
|
|
pPresNum->oddEven = (mBuf[0]>>7) & 0x01;
|
|
pPresNum->scrInd = mBuf[1] & 0x03;
|
|
pPresNum->presRest = (mBuf[1]>>2) & 0x03;
|
|
pPresNum->numPlan = (mBuf[1]>>4) & 0x07;
|
|
pPresNum->pnp = (mBuf[1]>>7) & 0x01;
|
|
|
|
num_ptr = mBuf+2;
|
|
for(i = 0, j = 0; i < length-2; i++)
|
|
{
|
|
pPresNum->addrSig[j++] = num_ptr[i] & 0x0f;
|
|
pPresNum->addrSig[j++] = num_ptr[i] >> 4;
|
|
}
|
|
if((pPresNum->oddEven) && (j > 0))
|
|
j--;
|
|
pPresNum->numOfDigit = j;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
int siUnpkSiPartCLI (SiPartCLI *pPartCLI,u8 *mBuf, u8 length)
|
|
{
|
|
pPartCLI->pres = 1;
|
|
pPartCLI->swichTypeD1 = mBuf[0] & 0x0F;
|
|
pPartCLI->swichTypeD2 = mBuf[0] >> 4;
|
|
pPartCLI->pnoIdD1 = mBuf[1] & 0x0F;
|
|
pPartCLI->pnoIdD2 = mBuf[1] >> 4;
|
|
pPartCLI->pnoIdD3 = mBuf[2] & 0x0F;
|
|
pPartCLI->switchNumD1 = mBuf[2] >> 4;
|
|
pPartCLI->switchNumD2 = mBuf[3] & 0x0F;
|
|
pPartCLI->switchNumD3 = mBuf[3] >> 4;
|
|
memcpy(pPartCLI->agreement,mBuf+4,5);
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCaldSubBasSerMar (SiCaldSubBasSerMar *pCaldSubBasSerMar,u8 *mBuf, u8 length)
|
|
{
|
|
pCaldSubBasSerMar->pres = 1;
|
|
pCaldSubBasSerMar->cbInd = mBuf[0] & 0x01 ;
|
|
pCaldSubBasSerMar->subIcbInd = (mBuf[0]>>1) & 0x01;
|
|
pCaldSubBasSerMar->preIcbInd = (mBuf[0]>>2) & 0x01;
|
|
pCaldSubBasSerMar->permIcbInd = (mBuf[0]>>3) & 0x01;
|
|
pCaldSubBasSerMar->tosInd = (mBuf[0]>>4) & 0x01;
|
|
pCaldSubBasSerMar->ICBExpInd = (mBuf[0]>>5) & 0x01;
|
|
pCaldSubBasSerMar->caldSubFacInfInd = (mBuf[0]>>6) & 0x01;
|
|
pCaldSubBasSerMar->calgSubFacInfInd = (mBuf[0]>>7) & 0x01;
|
|
pCaldSubBasSerMar->permOcbInd = mBuf[1] & 0x01 ;
|
|
pCaldSubBasSerMar->ogLocCalBarInd = (mBuf[1]>>1) & 0x01;
|
|
pCaldSubBasSerMar->ogNatCalBarInd = (mBuf[1]>>2) & 0x01;
|
|
pCaldSubBasSerMar->ogIntCalBarInd = (mBuf[1]>>3) & 0x01;
|
|
pCaldSubBasSerMar->opCalBarInd = (mBuf[1]>>4) & 0x01;
|
|
pCaldSubBasSerMar->supFacCalBarInd = (mBuf[1]>>5) & 0x01;
|
|
pCaldSubBasSerMar->digMaskInd = (mBuf[1]>>6) & 0x01;
|
|
pCaldSubBasSerMar->calPreBarInd = (mBuf[1]>>7) & 0x01;
|
|
pCaldSubBasSerMar->caldSubTarGp = mBuf[2] & 0x7F;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCalgSubBasSerMar (SiCalgSubBasSerMar *pCalgSubBasSerMar,u8 *mBuf, u8 length)
|
|
{
|
|
pCalgSubBasSerMar->pres = 1;
|
|
pCalgSubBasSerMar->cbInd = mBuf[0] & 0x01 ;
|
|
pCalgSubBasSerMar->subIcbInd = (mBuf[0]>>1) & 0x01;
|
|
pCalgSubBasSerMar->preIcbInd = (mBuf[0]>>2) & 0x01;
|
|
pCalgSubBasSerMar->permIcbInd = (mBuf[0]>>3) & 0x01;
|
|
pCalgSubBasSerMar->tosInd = (mBuf[0]>>4) & 0x01;
|
|
pCalgSubBasSerMar->ICBExpInd = (mBuf[0]>>5) & 0x01;
|
|
pCalgSubBasSerMar->caldSubFacInfInd = (mBuf[0]>>6) & 0x01;
|
|
pCalgSubBasSerMar->calgSubFacInfInd = (mBuf[0]>>7) & 0x01;
|
|
pCalgSubBasSerMar->permOcbInd = mBuf[1] & 0x01 ;
|
|
pCalgSubBasSerMar->ogLocCalBarInd = (mBuf[1]>>1) & 0x01;
|
|
pCalgSubBasSerMar->ogNatCalBarInd = (mBuf[1]>>2) & 0x01;
|
|
pCalgSubBasSerMar->ogIntCalBarInd = (mBuf[1]>>3) & 0x01;
|
|
pCalgSubBasSerMar->opCalBarInd = (mBuf[1]>>4) & 0x01;
|
|
pCalgSubBasSerMar->supFacCalBarInd = (mBuf[1]>>5) & 0x01;
|
|
pCalgSubBasSerMar->digMaskInd = (mBuf[1]>>6) & 0x01;
|
|
pCalgSubBasSerMar->calPreBarInd = (mBuf[1]>>7) & 0x01;
|
|
pCalgSubBasSerMar->calgSubTarGp = mBuf[2] & 0x7F;
|
|
pCalgSubBasSerMar->opInd = (mBuf[2]>>7) & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCalgSubOrgFacMar (SiCalgSubOrgFacMar *pCalgSubOrgFacMar,u8 *mBuf, u8 length)
|
|
{
|
|
pCalgSubOrgFacMar->pres = 1;
|
|
pCalgSubOrgFacMar->disSubInd = mBuf[0] & 0x01 ;
|
|
pCalgSubOrgFacMar->attCOI = (mBuf[0]>>1) & 0x01;
|
|
pCalgSubOrgFacMar->adDurChgInd = (mBuf[0]>>2) & 0x01;
|
|
pCalgSubOrgFacMar->PBXSubInd = (mBuf[0]>>3) & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCaldSubTermFacMar (SiCaldSubTermFacMar *pCaldSubTermFacMar,u8 *mBuf, u8 length)
|
|
{
|
|
pCaldSubTermFacMar->pres = 1;
|
|
pCaldSubTermFacMar->sviInd = mBuf[0] & 0x01 ;
|
|
pCaldSubTermFacMar->cniInd = (mBuf[0]>>1) & 0x01;
|
|
pCaldSubTermFacMar->pbxNigIntInd = (mBuf[0]>>2) & 0x01;
|
|
pCaldSubTermFacMar->calWaitInd = (mBuf[0]>>3) & 0x01;
|
|
pCaldSubTermFacMar->fixedDestSerInd = (mBuf[0]>>4) & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkNatInfReqInd (SiNatInfReqInd *pNatInfReqInd,u8 *mBuf, u8 length)
|
|
{
|
|
pNatInfReqInd->pres = 1;
|
|
pNatInfReqInd->calgSubBasSerMarReqInd = mBuf[0] & 0x01 ;
|
|
pNatInfReqInd->caldSubBasSerMarReqInd = (mBuf[0]>>1) & 0x01;
|
|
pNatInfReqInd->calgSubOrgFacMarReqInd = (mBuf[0]>>2) & 0x01;
|
|
pNatInfReqInd->caldSubTerFacMarReqInd = (mBuf[0]>>3) & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int siUnpkNatInfInd (SiNatInfInd *pNatInfInd,u8 *mBuf, u8 length)
|
|
{
|
|
pNatInfInd->pres = 1;
|
|
pNatInfInd->calgSubBasSerMarRespInd = mBuf[0] & 0x01 ;
|
|
pNatInfInd->caldSubBasSerMarRespInd = (mBuf[0]>>1) & 0x01;
|
|
pNatInfInd->calgSubOrgFacMarRespInd = (mBuf[0]>>2) & 0x01;
|
|
pNatInfInd->caldSubTerFacMarRespInd = (mBuf[0]>>3) & 0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCirValRspInd (SiCirValRspInd *pCirValRspInd,u8 *mBuf, u8 length)
|
|
{
|
|
pCirValRspInd->pres = 1;
|
|
pCirValRspInd->cirValRspInd = mBuf[0] & 0x01 ;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCirGrpCharInd (SiCirGrpCharInd *pCirGrpCharInd,u8 *mBuf, u8 length)
|
|
{
|
|
pCirGrpCharInd->pres = 1;
|
|
pCirGrpCharInd->cirGrpCarInd = mBuf[0] & 0x03 ;
|
|
pCirGrpCharInd->dblSzCtrlInd = (mBuf[0]>>2) & 0x03 ;
|
|
pCirGrpCharInd->alarmCarInd = (mBuf[0]>>4) & 0x03 ;
|
|
pCirGrpCharInd->contChkReqInd = (mBuf[0]>>6) & 0x03 ;
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCirIdName (SiCirIdName *pCirIdName,u8 *mBuf, u8 length)
|
|
{
|
|
int i;
|
|
pCirIdName->pres = 1;
|
|
|
|
for(i=0;i<26;i++)
|
|
{
|
|
pCirIdName->trunkNumClli[i] = mBuf[i] & 0x7f ;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkCLLI (SiCLLI *pCLLI,u8 *mBuf, u8 length)
|
|
{
|
|
int i;
|
|
pCLLI->pres = 1;
|
|
|
|
for(i=0;i<11;i++)
|
|
{
|
|
pCLLI->clliCode[i] = mBuf[i] & 0x7f ;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* packing functions for ISUP information elements */
|
|
int siPkSiAccDelInfo (SiAccDelInfo *pAccDelInfo,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pAccDelInfo->delInd &0x01;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int siPkAccTrnspt (SiAccTrnspt *pAccTrnspt,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pAccTrnspt->infoElmts,pAccTrnspt->infoLen);
|
|
return pAccTrnspt->infoLen;
|
|
}
|
|
|
|
int siPkAutoCongLvl (SiAutoCongLvl *pAutoCongLvl,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pAutoCongLvl->auCongLvl;
|
|
return 1;
|
|
}
|
|
|
|
int siPkBckCalInd (SiBckCalInd *pBckCalInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pBckCalInd->chrgInd & 0x03;
|
|
mBuf[0] |= (pBckCalInd->cadPtyStatInd & 0x03) << 2;
|
|
mBuf[0] |= (pBckCalInd->cadPtyCatInd & 0x03) << 4;
|
|
mBuf[0] |= (pBckCalInd->end2EndMethInd & 0x03) << 6;
|
|
|
|
mBuf[1] = 0;
|
|
mBuf[1] |= pBckCalInd->intInd & 0x01;
|
|
mBuf[1] |= (pBckCalInd->end2EndInfoInd & 0x01) << 1;
|
|
mBuf[1] |= (pBckCalInd->isdnUsrPrtInd & 0x01) << 2;
|
|
mBuf[1] |= (pBckCalInd->holdInd & 0x01) << 3;
|
|
mBuf[1] |= (pBckCalInd->isdnAccInd & 0x01) << 4;
|
|
mBuf[1] |= (pBckCalInd->echoCtrlDevInd & 0x01) << 5;
|
|
mBuf[1] |= (pBckCalInd->sccpMethInd & 0x03) << 6;
|
|
|
|
return 2;
|
|
}
|
|
|
|
|
|
|
|
int siPkSiCllDiverInfo (SiCllDiverInfo *pCllDivr,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCllDivr->notSuscr&0x07;
|
|
mBuf[0] |= (pCllDivr->redirRsn & 0x0F) << 3;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiPropDly (SiPropDly *pPropDly,u8 *mBuf)
|
|
{
|
|
mBuf[0] = (pPropDly->delayVal>>8) & 0xFF;
|
|
mBuf[1] = pPropDly->delayVal & 0xFF;
|
|
return 2;
|
|
}
|
|
|
|
int siPkCallRef (SiCallRef *pCallRef,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCallRef->callId[0];
|
|
mBuf[1] = pCallRef->callId[1];
|
|
mBuf[2] = pCallRef->callId[2];
|
|
mBuf[3] = pCallRef->pntCde & 0xFF;
|
|
mBuf[4] = (pCallRef->pntCde>>8) & 0x3F;
|
|
return 5;
|
|
}
|
|
|
|
int siPkCdPtyNum (SiCdPtyNum *pCdPtyNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pCdPtyNum->numOfDigit/2 + (pCdPtyNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
|
|
pCdPtyNum->oddEven = pCdPtyNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pCdPtyNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pCdPtyNum->oddEven & 0x01) <<7;
|
|
mBuf[1] = (pCdPtyNum->numPlan & 0x07) << 4;
|
|
mBuf[1] |= (pCdPtyNum->natAddrInd & 0x01) <<7;
|
|
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pCdPtyNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pCdPtyNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pCdPtyNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkCgPtyNum (SiCgPtyNum *pCgPtyNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pCgPtyNum->numOfDigit/2 + (pCgPtyNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
|
|
pCgPtyNum->oddEven = pCgPtyNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pCgPtyNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pCgPtyNum->oddEven & 0x01) <<7;
|
|
mBuf[1] = pCgPtyNum->scrnInd & 0x03;
|
|
mBuf[1] |= (pCgPtyNum->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pCgPtyNum->numPlan & 0x07) << 4;
|
|
mBuf[1] |= (pCgPtyNum->niInd & 0x01) <<7;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pCgPtyNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pCgPtyNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pCgPtyNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkCgPtyCat (SiCgPtyCat *pCgPtyCat,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCgPtyCat->cgPtyCat;
|
|
return 1;
|
|
}
|
|
|
|
int siPkCauseDgn (SiCauseDgn *pCauseDgn,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0x80;
|
|
mBuf[0] |= pCauseDgn->location&0x0F;
|
|
mBuf[0] |= (pCauseDgn->cdeStand & 0x03)<<5;
|
|
mBuf[1] = 0x80;
|
|
mBuf[1] |= pCauseDgn->causeVal&0x7F;
|
|
if(pCauseDgn->length != 0)
|
|
memcpy(mBuf+2,pCauseDgn->dgnVal,pCauseDgn->length);
|
|
return pCauseDgn->length+2;
|
|
}
|
|
|
|
int siPkCirGrpSupMTypInd (SiCirGrpSupMTypInd *pCgsmti,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCgsmti->typeInd&0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siPkCirStateInd (SiCirStateInd *pCirStateInd,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pCirStateInd->cirSteInd,pCirStateInd->length);
|
|
return pCirStateInd->length;
|
|
}
|
|
|
|
int siPkCugIntCode (SiCugIntCode *pCugIntCode,u8 *mBuf)
|
|
{
|
|
mBuf[0] = (pCugIntCode->dig1<<4)|(pCugIntCode->dig2&0x0F);
|
|
mBuf[1] = (pCugIntCode->dig3<<4)|(pCugIntCode->dig4&0x0F);
|
|
mBuf[2] = pCugIntCode->binCde>>8;
|
|
mBuf[3] = pCugIntCode->binCde & 0xFF;
|
|
return 4;
|
|
}
|
|
|
|
int siPkConnectedNum (SiConnectedNum *pConnectedNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pConnectedNum->numOfDigit/2 + (pConnectedNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
|
|
pConnectedNum->oddEven = pConnectedNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pConnectedNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pConnectedNum->oddEven & 0x01) <<7;
|
|
mBuf[1] = pConnectedNum->scrnInd & 0x03;
|
|
mBuf[1] |= (pConnectedNum->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pConnectedNum->numPlan & 0x07) << 4;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pConnectedNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pConnectedNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pConnectedNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkConnReq (SiConnReq *pConnReq,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pConnReq->locRef[0];
|
|
mBuf[1] = pConnReq->locRef[1];
|
|
mBuf[2] = pConnReq->locRef[2];
|
|
mBuf[3] = pConnReq->pntCde & 0xFF;
|
|
mBuf[4] = (pConnReq->pntCde>>8) & 0x3F;
|
|
mBuf[5] = pConnReq->protClass;
|
|
mBuf[6] = pConnReq->credit;
|
|
return 7;
|
|
}
|
|
|
|
int siPkContInd (SiContInd *pContInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pContInd->contInd&0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiEchoCtl (SiEchoCtl *pEchoCtl,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pEchoCtl->outEchoRsp & 0x03;
|
|
mBuf[0] |= (pEchoCtl->incEchoRsp & 0x03) << 2;
|
|
mBuf[0] |= (pEchoCtl->outEchoReq & 0x03) << 4;
|
|
mBuf[0] |= (pEchoCtl->incEchoReq & 0x03) << 6;
|
|
return 1;
|
|
}
|
|
|
|
int siPkEvntInfo (SiEvntInfo *pEvntInfo,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pEvntInfo->evntInd & 0x7F;
|
|
mBuf[0] |= (pEvntInfo->evntPresResInd &0x01) << 7;
|
|
return 1;
|
|
}
|
|
|
|
|
|
int siPkFacInd (SiFacInd *pFacInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pFacInd->facInd;
|
|
return 1;
|
|
}
|
|
|
|
int siPkFwdCallInd (SiFwdCallInd *pFwdCallInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pFwdCallInd->natIntCallInd & 0x01;
|
|
mBuf[0] |= (pFwdCallInd->end2EndMethInd &0x03) << 1;
|
|
mBuf[0] |= (pFwdCallInd->intInd &0x01) << 3;
|
|
mBuf[0] |= (pFwdCallInd->end2EndInfoInd &0x01) << 4;
|
|
mBuf[0] |= (pFwdCallInd->isdnUsrPrtInd &0x01) << 5;
|
|
mBuf[0] |= (pFwdCallInd->isdnUsrPrtPrfInd &0x03) << 6;
|
|
mBuf[1] |= pFwdCallInd->isdnAccInd &0x01;
|
|
mBuf[1] |= (pFwdCallInd->sccpMethInd &0x03) << 1;
|
|
return 2;
|
|
}
|
|
|
|
int siPkFreePhParam (SiFreePhInd *pFreePhInd,u8 *mBuf){return 0;}//reserved
|
|
|
|
int siPkSiGenDigits (SiGenDigits *pGenDigits,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pGenDigits->typeOfDigits & 0x1F;
|
|
mBuf[0] |= (pGenDigits->encodeScheme & 0x07)<<5;
|
|
memcpy(mBuf+1, pGenDigits->digits, pGenDigits->length);
|
|
return pGenDigits->length + 1;
|
|
}
|
|
|
|
int siPkNotifInd (SiNotifInd *pNotifInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNotifInd->notifInd;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiGenNum (SiGenNum *pGenNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pGenNum->numOfDigit/2 + (pGenNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+3;
|
|
pGenNum->oddEven = pGenNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pGenNum->nmbQual;
|
|
mBuf[1] = pGenNum->natAddrInd & 0x7F;
|
|
mBuf[1] |= (pGenNum->oddEven & 0x01) <<7;
|
|
mBuf[2] = pGenNum->scrnInd & 0x03;
|
|
mBuf[2] |= (pGenNum->presRest & 0x03) << 2;
|
|
mBuf[2] |= (pGenNum->numPlan & 0x07) << 4;
|
|
mBuf[2] |= (pGenNum->niInd & 0x01) <<7;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pGenNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pGenNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pGenNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 3;
|
|
}
|
|
|
|
int siPkHopCounter (SiHopCounter *pHopCounter,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pHopCounter->hopCounter&0x1F;
|
|
return 1;
|
|
}
|
|
|
|
int siPkInfoInd (SiInfoInd *pInfoInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pInfoInd->cgPtyAddrRespInd & 0x03;
|
|
mBuf[0] |= (pInfoInd->holdProvInd& 0x01) <<2 ;
|
|
mBuf[0] |= (pInfoInd->cgPtyCatRespInd& 0x01) <<5 ;
|
|
mBuf[0] |= (pInfoInd->chrgInfoRespInd& 0x01) <<6 ;
|
|
mBuf[0] |= (pInfoInd->solInfoInd& 0x01) <<7;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkInfoReqInd (SiInfoReqInd *pInfoReqInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pInfoReqInd->cgPtyAdReqInd & 0x01;
|
|
mBuf[0] |= (pInfoReqInd->holdingInd & 0x01) <<1;
|
|
mBuf[0] |= (pInfoReqInd->cgPtyCatReqInd& 0x01) <<3 ;
|
|
mBuf[0] |= (pInfoReqInd->chrgInfoReqInd& 0x01) <<4 ;
|
|
mBuf[0] |= (pInfoReqInd->malCaIdReqInd& 0x01)<<7;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkSiMcidRspInd (SiMcidRspInd *pMcidRsp,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pMcidRsp->rspInd &0x01;
|
|
mBuf[0] |= (pMcidRsp->hldInd &0x01)<<1;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiMcidReqInd (SiMcidReqInd *pMcidReq,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pMcidReq->reqInd &0x01;
|
|
mBuf[0] |= (pMcidReq->hldInd &0x01)<<1;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiMsgCompInfo (SiMsgCompInfo *pMsgCom,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pMsgCom->tranXInd &0x01;
|
|
mBuf[0] |= (pMsgCom->relCllInd &0x01)<<1;
|
|
mBuf[0] |= (pMsgCom->sndNotInd &0x01)<<2;
|
|
mBuf[0] |= (pMsgCom->dcrdMsgInd &0x01)<<3;
|
|
mBuf[0] |= (pMsgCom->passNotPoss &0x01)<<4;
|
|
mBuf[0] |= (pMsgCom->bbNbIntwkI &0x03)<<5;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiMlppPrec (SiMlppPrec *pMlppPrec,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pMlppPrec->precdLvl & 0x0F;
|
|
mBuf[0] |= (pMlppPrec->lfb & 0x03)<<5;
|
|
mBuf[1] = pMlppPrec->scndDig &0x0f;
|
|
mBuf[1] |= (pMlppPrec->frstDig & 0x0f)<<4;
|
|
mBuf[2] = pMlppPrec->frthDig &0x0f;
|
|
mBuf[2] |= (pMlppPrec->thrdDig & 0x0f)<<4;
|
|
mBuf[3] = (pMlppPrec->servDomain>>16) &0xFF;
|
|
mBuf[4] = (pMlppPrec->servDomain>>8) &0xFF;
|
|
mBuf[5] = pMlppPrec->servDomain &0xFF;
|
|
return 6;
|
|
}
|
|
|
|
int siPkNatConInd (SiNatConInd *pNatConInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = 0;
|
|
mBuf[0] |= pNatConInd->satInd & 0x03;
|
|
mBuf[0] |= (pNatConInd->contChkInd & 0x03) << 2;
|
|
mBuf[0] |= (pNatConInd->echoCntrlDevInd & 0x01) << 4;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiNetSpecFacil (SiNetSpecFacil *pNetFac,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pNetFac->netFac,pNetFac->length);
|
|
return pNetFac->length;
|
|
}
|
|
|
|
int siPkOptBckCalInd (SiOptBckCalInd *pOptBckCalInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pOptBckCalInd->inbndInfoInd & 0x01;
|
|
mBuf[0] |= (pOptBckCalInd->caFwdMayOcc & 0x01) << 1;
|
|
mBuf[0] |= (pOptBckCalInd->simpleSegmInd & 0x01) << 2;
|
|
mBuf[0] |= (pOptBckCalInd->mlppUserInd & 0x01) << 3;
|
|
return 1;
|
|
}
|
|
|
|
int siPkOpFwdCalInd (SiOpFwdCalInd *pOpFwdCalInd,u8 *mBuf)
|
|
{
|
|
|
|
mBuf[0] = pOpFwdCalInd->clsdUGrpCaInd & 0x03;
|
|
mBuf[0] |= (pOpFwdCalInd->simpleSegmInd & 0x01) << 2;
|
|
mBuf[0] |= (pOpFwdCalInd->conLineIdReqInd & 0x01) << 7;
|
|
return 1;
|
|
}
|
|
|
|
int siPkOrigCdNum (SiOrigCdNum *pOrigCdNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pOrigCdNum->numOfDigit/2 + (pOrigCdNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
pOrigCdNum->oddEven = pOrigCdNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pOrigCdNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pOrigCdNum->oddEven & 0x01) << 7;
|
|
mBuf[1] = (pOrigCdNum->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pOrigCdNum->numPlan & 0x07) << 4;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pOrigCdNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pOrigCdNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pOrigCdNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkSigPointCode (SiSigPointCode *pSigPointCode,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pSigPointCode->sigPointCode & 0xFF;
|
|
mBuf[1] = (pSigPointCode->sigPointCode>>8) & 0x3F;
|
|
return 2;
|
|
}
|
|
|
|
int siPkSiParmCompInfo (SiParmCompInfo *pParmCom,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pParmCom->content,pParmCom->length);
|
|
return pParmCom->length;
|
|
}
|
|
|
|
int siPkRangStat (SiRangStat *pRangStat,u8 *mBuf)
|
|
{
|
|
int status_len;
|
|
mBuf[0] = pRangStat->range;
|
|
status_len = ((pRangStat->range&0x07) == 0)? (pRangStat->range>>3) : ((pRangStat->range>>3) + 1);
|
|
memcpy(mBuf+1, pRangStat->status, status_len);
|
|
return status_len+1;
|
|
}
|
|
int siPkRangNoStat (SiRangNoStat *pRangStat,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pRangStat->range;
|
|
return 1;
|
|
}
|
|
|
|
int siPkRedirInfo (SiRedirInfo *pRedirInfo,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pRedirInfo->redirInd & 0x07;
|
|
mBuf[0] |= (pRedirInfo->origRedirReas & 0x0F) << 4;
|
|
mBuf[1] = pRedirInfo->redirCnt & 0x07;
|
|
mBuf[1] |= (pRedirInfo->redirReas & 0x0F) << 4;
|
|
return 2;
|
|
}
|
|
|
|
int siPkRedirgNum (SiRedirNum *pRedirgNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pRedirgNum->numOfDigit/2 + (pRedirgNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
pRedirgNum->oddEven = pRedirgNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pRedirgNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pRedirgNum->oddEven & 0x01) << 7;
|
|
mBuf[1] = (pRedirgNum->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pRedirgNum->numPlan & 0x07) << 4;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pRedirgNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pRedirgNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pRedirgNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkSiRedirRestr (SiRedirRestr *pRedirRstr,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pRedirRstr->presRest & 0x03;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiRemotOper (SiRemotOper *pRemotOper,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pRemotOper->content,pRemotOper->length);
|
|
return pRemotOper->length;
|
|
}
|
|
|
|
int siPkServiceAct (SiServiceAct *pServiceAct,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pServiceAct->serviceAct,pServiceAct->length);
|
|
return pServiceAct->length;
|
|
}
|
|
|
|
int siPkSubNum (SiSubNum *pSubNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pSubNum->numOfDigit/2 + (pSubNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+1;
|
|
pSubNum->oddEven = pSubNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = (pSubNum->oddEven &0x01) <<7;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pSubNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pSubNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pSubNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 1;
|
|
}
|
|
|
|
int siPkSusResInd (SiSusResInd *pSusResInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pSusResInd->susResInd &0x01;
|
|
return 1;
|
|
}
|
|
|
|
int siPkTranNetSel (SiTranNetSel *pTranNetSel,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pTranNetSel->numOfDigit/2 + (pTranNetSel->numOfDigit & 0x01);
|
|
num_ptr = mBuf+1;
|
|
|
|
pTranNetSel->oddEven = pTranNetSel->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pTranNetSel->netIdPln & 0x0F;
|
|
mBuf[0] |= (pTranNetSel->typNetId & 0x03) <<4;
|
|
mBuf[0] |= (pTranNetSel->oddEven & 0x01) <<7;
|
|
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pTranNetSel->netId[j++] & 0x0f;
|
|
num_ptr[i] += pTranNetSel->netId[j++] << 4;
|
|
}
|
|
|
|
if(pTranNetSel->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 1;
|
|
}
|
|
|
|
int siPkTxMedReq (SiTxMedReq *pTxMedReq,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pTxMedReq->trMedReq;
|
|
return 1;
|
|
}
|
|
|
|
int siPkSiUsrServInfo (SiUsrServInfo *pUsrServInfo,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pUsrServInfo->content,pUsrServInfo->length);
|
|
return pUsrServInfo->length;
|
|
}
|
|
|
|
int siPkSiUsrTSrvInfo (SiUsrTSrvInfo *pUsrTSrvInfo,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pUsrTSrvInfo->content,pUsrTSrvInfo->length);
|
|
return pUsrTSrvInfo->length;
|
|
}
|
|
|
|
int siPkUsr2UsrInd (SiUsr2UsrInd *pUsr2UsrInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pUsr2UsrInd->type & 0x01;
|
|
mBuf[0] |= (pUsr2UsrInd->serv1 & 0x03)<<1;
|
|
mBuf[0] |= (pUsr2UsrInd->serv2 & 0x03)<<3;
|
|
mBuf[0] |= (pUsr2UsrInd->serv3 & 0x03)<<5;
|
|
mBuf[0] |= (pUsr2UsrInd->spare & 0x01)<<7;
|
|
return 1;
|
|
}
|
|
|
|
int siPkUsr2UsrInfo (SiUsr2UsrInfo *pUsr2UsrInfo,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf, pUsr2UsrInfo->info, pUsr2UsrInfo->length);
|
|
return pUsr2UsrInfo->length;
|
|
}
|
|
|
|
int siPkPassAlng (SiPassAlng *pPassAlng,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pPassAlng->passAlng,pPassAlng->length);
|
|
return pPassAlng->length;
|
|
}
|
|
/* packing functions for ITU97/ETSIV3 Information Element */
|
|
int siPkSiConfTrtInd (SiConfTrtInd *pConfTrtInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pConfTrtInd->confAcceptInd&0x03;
|
|
if(pConfTrtInd->length)
|
|
memcpy(mBuf+1, pConfTrtInd->extInfo, pConfTrtInd->length);
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pConfTrtInd->length+1;
|
|
}
|
|
int siPkUidActionInd (SiUidActionInd *pUidActionInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pUidActionInd->throughConnInstInd&0x01;
|
|
mBuf[0] |= (pUidActionInd->t9InstInd&0x01) << 1;
|
|
if(pUidActionInd->length)
|
|
memcpy(mBuf+1, pUidActionInd->extInfo, pUidActionInd->length);
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pUidActionInd->length+1;
|
|
}
|
|
int siPkBackGVNS (SiBackGVNS *pBackGVNS,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pBackGVNS->termAccessInd&0x03;
|
|
if(pBackGVNS->length)
|
|
{
|
|
memcpy(mBuf+1, pBackGVNS->extInfo, pBackGVNS->length);
|
|
}
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pBackGVNS->length+1;
|
|
}
|
|
|
|
int siPkDisplayInfo (SiDisplayInfo *pDisplayInfo,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pDisplayInfo->displayInfo,pDisplayInfo->length);
|
|
return pDisplayInfo->length;
|
|
}
|
|
int siPkForwardGVNS (SiForwardGVNS *pForwardGVNS,u8 *mBuf)
|
|
{
|
|
int i,j,num_len,point;
|
|
u8 *num_ptr;
|
|
|
|
point = 0;
|
|
//Originating participating service provider
|
|
num_len = pForwardGVNS->numOfDigit1/2 + (pForwardGVNS->numOfDigit1 & 0x01);
|
|
if(num_len>4)
|
|
num_len=4;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
mBuf[point] = num_len & 0x0F;
|
|
mBuf[point] |= (pForwardGVNS->numOfDigit1 & 0x01) << 7;
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pForwardGVNS->digits1[j++] & 0x0f;
|
|
num_ptr[i] += pForwardGVNS->digits1[j++] << 4;
|
|
}
|
|
|
|
if(pForwardGVNS->numOfDigit1 & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
point +=num_len;
|
|
|
|
//GVNS user group
|
|
num_len = pForwardGVNS->numOfDigit2/2 + (pForwardGVNS->numOfDigit2 & 0x01);
|
|
if(num_len>8)
|
|
num_len=8;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
mBuf[point] = num_len & 0x0F;
|
|
mBuf[point] |= (pForwardGVNS->numOfDigit2 & 0x01) << 7;
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pForwardGVNS->digits2[j++] & 0x0f;
|
|
num_ptr[i] += pForwardGVNS->digits2[j++] << 4;
|
|
}
|
|
|
|
if(pForwardGVNS->numOfDigit2 & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
point +=num_len;
|
|
|
|
//Terminating network routing number
|
|
num_len = pForwardGVNS->numOfDigit3/2 + (pForwardGVNS->numOfDigit3 & 0x01);
|
|
if(num_len>8)
|
|
num_len=8;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
mBuf[point] = (num_len+1) & 0x0F;
|
|
mBuf[point] |= (pForwardGVNS->numPlan & 0x03) << 4;
|
|
mBuf[point] |= (pForwardGVNS->numOfDigit2 & 0x01) << 7;
|
|
point++;
|
|
mBuf[point] = pForwardGVNS->natOfAddr & 0x07F;
|
|
point++;
|
|
num_ptr = mBuf+point;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pForwardGVNS->digits3[j++] & 0x0f;
|
|
num_ptr[i] += pForwardGVNS->digits3[j++] << 4;
|
|
}
|
|
|
|
if(pForwardGVNS->numOfDigit3 & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
point +=num_len;
|
|
|
|
return point;
|
|
}
|
|
int siPkCcss (SiCcss *pCcss,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCcss->ccssCallInd&0x01;
|
|
return 1;
|
|
}
|
|
int siPkNetMgmtControls (SiNetMgmtControls *pNetMgmtControls,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNetMgmtControls->tmpAltRoutInd&0x01;
|
|
if(pNetMgmtControls->length)
|
|
memcpy(mBuf+1, pNetMgmtControls->extInfo, pNetMgmtControls->length);
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pNetMgmtControls->length+1;
|
|
}
|
|
int siPkCirAsgnMap (SiCirAsgnMap *pCirAsgnMap,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCirAsgnMap->mapType&0x03F;
|
|
memcpy(mBuf+1,pCirAsgnMap->mapFormat,4);
|
|
return 5;
|
|
}
|
|
int siPkCorrelationId (SiCorrelationId *pCorrelationId,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pCorrelationId->correlationId,pCorrelationId->length);
|
|
return pCorrelationId->length;
|
|
}
|
|
int siPkCallDivTrtInd (SiCallDivTrtInd *pCallDivTrtInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCallDivTrtInd->callDivInd&0x03;
|
|
if(pCallDivTrtInd->length)
|
|
memcpy(mBuf+1, pCallDivTrtInd->extInfo, pCallDivTrtInd->length);
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pCallDivTrtInd->length+1;
|
|
}
|
|
int siPkCallInNmb (SiCallInNmb *pCallInNmb,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pCallInNmb->numOfDigit/2 + (pCallInNmb->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
pCallInNmb->oddEven = pCallInNmb->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pCallInNmb->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pCallInNmb->oddEven & 0x01) << 7;
|
|
mBuf[1] = (pCallInNmb->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pCallInNmb->numPlan & 0x07) << 4;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pCallInNmb->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pCallInNmb->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pCallInNmb->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
int siPkCallOfferTrtInd (SiCallOfferTrtInd *pCallOfferTrtInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCallOfferTrtInd->callOfferInd&0x03;
|
|
if(pCallOfferTrtInd->length)
|
|
memcpy(mBuf+1, pCallOfferTrtInd->extInfo, pCallOfferTrtInd->length);
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pCallOfferTrtInd->length+1;
|
|
}
|
|
int siPkScfId (SiScfId *pScfId,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pScfId->scfId,pScfId->length);
|
|
return pScfId->length;
|
|
}
|
|
int siPkUidCapInd (SiUidCapInd *pUidCapInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pUidCapInd->throughConnInstInd&0x01;
|
|
mBuf[0] |= (pUidCapInd->t9InstInd&0x01) << 1;
|
|
if(pUidCapInd->length)
|
|
{
|
|
memcpy(mBuf+1, pUidCapInd->extInfo, pUidCapInd->length);
|
|
}
|
|
else
|
|
mBuf[0] = mBuf[0] | 0x80;
|
|
return pUidCapInd->length+1;
|
|
}
|
|
int siPkCollCallReq (SiCollCallReq *pCollCallReq,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCollCallReq->collCallReqInd & 0x01;
|
|
return 1;
|
|
}
|
|
int siPkNaPaChgPID (SiNaPaChgPID *pNaPaChgPID,u8 *mBuf)
|
|
{
|
|
memcpy(mBuf,pNaPaChgPID->naPaChgPtyId,pNaPaChgPID->length);
|
|
return pNaPaChgPID->length;
|
|
}
|
|
int siPkCallTRef (SiCallTRef *pCallTRef,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCallTRef->callTrnsfr;
|
|
return 1;
|
|
}
|
|
int siPkLoopPrvntInd (SiLoopPrvntInd *pLoopPrvntInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pLoopPrvntInd->loopPrvntType & 0x01;
|
|
mBuf[0] |= (pLoopPrvntInd->loopPrvntRspInd & 0x03)<<1;
|
|
return 1;
|
|
}
|
|
int siPkAppTransParam (SiAppTransParam *pAppTransParam,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pAppTransParam->appContextId & 0x7f;
|
|
mBuf[0] |= 0x80;
|
|
mBuf[1] = pAppTransParam->atii & 0x03;
|
|
mBuf[1] |= 0x80;
|
|
mBuf[2] = pAppTransParam->apmSegInd & 0x3f;
|
|
mBuf[2] |= (pAppTransParam->seqInd & 0x01)<<6;
|
|
|
|
if(pAppTransParam->slr)
|
|
{
|
|
mBuf[3] = pAppTransParam->slr & 0x7f;
|
|
mBuf[3] = mBuf[3] |0x80;
|
|
memcpy(mBuf+4,pAppTransParam->encapAppInfo,pAppTransParam->length);
|
|
return pAppTransParam->length+4;
|
|
}
|
|
else
|
|
{
|
|
mBuf[2] |= 0x80;
|
|
memcpy(mBuf+3,pAppTransParam->encapAppInfo,pAppTransParam->length);
|
|
return pAppTransParam->length+3;
|
|
}
|
|
}
|
|
|
|
/* packing functions for UK specific Information Element */
|
|
int siPkSiNatForCalInd (SiNatForCalInd *pNatForCalInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNatForCalInd->cbi & 0x01;
|
|
mBuf[0] |= (pNatForCalInd->ntaInd & 0x01)<<1;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkSiNatForCalIndLbL (SiNatForCalIndLbL *pNatForCalIndLbL,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNatForCalIndLbL->rci & 0x0f;
|
|
if(pNatForCalIndLbL->isi)
|
|
{
|
|
mBuf[1] = pNatForCalIndLbL->isi & 0x0f;
|
|
mBuf[1] = mBuf[1] |0x80;
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
mBuf[0] = mBuf[0] |0x80;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
int siPkSiPresNum (SiPresNum *pPresNum,u8 *mBuf)
|
|
{
|
|
int i,j,num_len;
|
|
u8 *num_ptr;
|
|
num_len = pPresNum->numOfDigit/2 + (pPresNum->numOfDigit & 0x01);
|
|
num_ptr = mBuf+2;
|
|
|
|
pPresNum->oddEven = pPresNum->numOfDigit & 0x01;
|
|
|
|
mBuf[0] = pPresNum->natAddrInd & 0x7F;
|
|
mBuf[0] |= (pPresNum->oddEven & 0x01) <<7;
|
|
mBuf[1] = pPresNum->scrInd & 0x03;
|
|
mBuf[1] |= (pPresNum->presRest & 0x03) << 2;
|
|
mBuf[1] |= (pPresNum->numPlan & 0x07) << 4;
|
|
mBuf[1] |= (pPresNum->pnp & 0x01) <<7;
|
|
if(num_len==0)
|
|
num_len=1;
|
|
for(i = 0, j = 0; i < num_len; i++)
|
|
{
|
|
num_ptr[i] = pPresNum->addrSig[j++] & 0x0f;
|
|
num_ptr[i] += pPresNum->addrSig[j++] << 4;
|
|
}
|
|
|
|
if(pPresNum->numOfDigit & 0x01)
|
|
num_ptr[num_len-1] &= 0x0f;
|
|
return num_len + 2;
|
|
}
|
|
|
|
|
|
|
|
int siPkSiPartCLI (SiPartCLI *pPartCLI,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pPartCLI->swichTypeD1& 0x0f;
|
|
mBuf[0] += pPartCLI->swichTypeD2 << 4;
|
|
|
|
mBuf[1] = pPartCLI->pnoIdD1& 0x0f;
|
|
mBuf[1] += pPartCLI->pnoIdD2 << 4;
|
|
|
|
mBuf[2] = pPartCLI->pnoIdD3& 0x0f;
|
|
mBuf[2] += pPartCLI->switchNumD1 << 4;
|
|
|
|
mBuf[3] = pPartCLI->switchNumD2& 0x0f;
|
|
mBuf[3] += pPartCLI->switchNumD3 << 4;
|
|
|
|
memcpy(mBuf+4,pPartCLI->agreement,5);
|
|
return 9;
|
|
}
|
|
|
|
int siPkCaldSubBasSerMar (SiCaldSubBasSerMar *pCaldSubBasSerMar,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCaldSubBasSerMar->cbInd & 0x01 ;
|
|
mBuf[0] |= (pCaldSubBasSerMar->subIcbInd & 0x01) <<1;
|
|
mBuf[0] |= (pCaldSubBasSerMar->preIcbInd & 0x01) <<2;
|
|
mBuf[0] |= (pCaldSubBasSerMar->permIcbInd & 0x01) <<3;
|
|
mBuf[0] |= (pCaldSubBasSerMar->tosInd & 0x01) <<4;
|
|
mBuf[0] |= (pCaldSubBasSerMar->ICBExpInd & 0x01) <<5;
|
|
mBuf[0] |= (pCaldSubBasSerMar->caldSubFacInfInd & 0x01) <<6;
|
|
mBuf[0] |= (pCaldSubBasSerMar->calgSubFacInfInd & 0x01) <<7;
|
|
mBuf[1] = pCaldSubBasSerMar->permOcbInd & 0x01;
|
|
mBuf[1] |= (pCaldSubBasSerMar->ogLocCalBarInd & 0x01) <<1;
|
|
mBuf[1] |= (pCaldSubBasSerMar->ogNatCalBarInd & 0x01) <<2;
|
|
mBuf[1] |= (pCaldSubBasSerMar->ogIntCalBarInd & 0x01) <<3;
|
|
mBuf[1] |= (pCaldSubBasSerMar->opCalBarInd & 0x01) <<4;
|
|
mBuf[1] |= (pCaldSubBasSerMar->supFacCalBarInd & 0x01)<<5;
|
|
mBuf[1] |= (pCaldSubBasSerMar->digMaskInd & 0x01) <<6;
|
|
mBuf[1] |= (pCaldSubBasSerMar->calPreBarInd & 0x01) <<7;
|
|
mBuf[2] = pCaldSubBasSerMar->caldSubTarGp & 0x7F;
|
|
return 3;
|
|
}
|
|
|
|
|
|
int siPkCalgSubBasSerMar (SiCalgSubBasSerMar *pCalgSubBasSerMar,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCalgSubBasSerMar->cbInd & 0x01 ;
|
|
mBuf[0] |= (pCalgSubBasSerMar->subIcbInd & 0x01) <<1;
|
|
mBuf[0] |= (pCalgSubBasSerMar->preIcbInd & 0x01) <<2;
|
|
mBuf[0] |= (pCalgSubBasSerMar->permIcbInd & 0x01) <<3;
|
|
mBuf[0] |= (pCalgSubBasSerMar->tosInd & 0x01) <<4;
|
|
mBuf[0] |= (pCalgSubBasSerMar->ICBExpInd & 0x01) <<5;
|
|
mBuf[0] |= (pCalgSubBasSerMar->caldSubFacInfInd & 0x01) <<6;
|
|
mBuf[0] |= (pCalgSubBasSerMar->calgSubFacInfInd & 0x01) <<7;
|
|
mBuf[1] = pCalgSubBasSerMar->permOcbInd & 0x01;
|
|
mBuf[1] |= (pCalgSubBasSerMar->ogLocCalBarInd & 0x01) <<1;
|
|
mBuf[1] |= (pCalgSubBasSerMar->ogNatCalBarInd & 0x01) <<2;
|
|
mBuf[1] |= (pCalgSubBasSerMar->ogIntCalBarInd & 0x01) <<3;
|
|
mBuf[1] |= (pCalgSubBasSerMar->opCalBarInd & 0x01) <<4;
|
|
mBuf[1] |= (pCalgSubBasSerMar->supFacCalBarInd & 0x01)<<5;
|
|
mBuf[1] |= (pCalgSubBasSerMar->digMaskInd & 0x01) <<6;
|
|
mBuf[1] |= (pCalgSubBasSerMar->calPreBarInd & 0x01) <<7;
|
|
mBuf[2] = pCalgSubBasSerMar->calgSubTarGp & 0x7F;
|
|
mBuf[2] |= (pCalgSubBasSerMar->opInd & 0x01) <<7;
|
|
return 3;
|
|
}
|
|
|
|
|
|
int siPkCalgSubOrgFacMar (SiCalgSubOrgFacMar *pCalgSubOrgFacMar,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCalgSubOrgFacMar->disSubInd & 0x01 ;
|
|
mBuf[0] |= (pCalgSubOrgFacMar->attCOI & 0x01) <<1;
|
|
mBuf[0] |= (pCalgSubOrgFacMar->adDurChgInd & 0x01) <<2;
|
|
mBuf[0] |= (pCalgSubOrgFacMar->PBXSubInd & 0x01) <<3;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkCaldSubTermFacMar (SiCaldSubTermFacMar *pCaldSubTermFacMar,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCaldSubTermFacMar->sviInd & 0x01 ;
|
|
mBuf[0] |= (pCaldSubTermFacMar->cniInd & 0x01) <<1;
|
|
mBuf[0] |= (pCaldSubTermFacMar->pbxNigIntInd & 0x01) <<2;
|
|
mBuf[0] |= (pCaldSubTermFacMar->calWaitInd & 0x01) <<3;
|
|
mBuf[0] |= (pCaldSubTermFacMar->fixedDestSerInd & 0x01) <<4;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkNatInfReqInd (SiNatInfReqInd *pNatInfReqInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNatInfReqInd->calgSubBasSerMarReqInd & 0x01 ;
|
|
mBuf[0] |= (pNatInfReqInd->caldSubBasSerMarReqInd & 0x01) <<1;
|
|
mBuf[0] |= (pNatInfReqInd->calgSubOrgFacMarReqInd & 0x01) <<2;
|
|
mBuf[0] |= (pNatInfReqInd->caldSubTerFacMarReqInd & 0x01) <<3;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
|
|
int siPkNatInfInd (SiNatInfInd *pNatInfInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pNatInfInd->calgSubBasSerMarRespInd & 0x01 ;
|
|
mBuf[0] |= (pNatInfInd->caldSubBasSerMarRespInd & 0x01) <<1;
|
|
mBuf[0] |= (pNatInfInd->calgSubOrgFacMarRespInd & 0x01) <<2;
|
|
mBuf[0] |= (pNatInfInd->caldSubTerFacMarRespInd & 0x01) <<3;
|
|
mBuf[1] = 0;
|
|
return 2;
|
|
}
|
|
//for ansi-isup
|
|
int siPkCirValRspInd (SiCirValRspInd *pCirValRspInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCirValRspInd->cirValRspInd & 0x01 ;
|
|
return 1;
|
|
}
|
|
|
|
int siPkCirGrpCharInd (SiCirGrpCharInd *pCirGrpCharInd,u8 *mBuf)
|
|
{
|
|
mBuf[0] = pCirGrpCharInd->cirGrpCarInd & 0x03 ;
|
|
mBuf[0] |= (pCirGrpCharInd->dblSzCtrlInd & 0x03) <<2;
|
|
mBuf[0] |= (pCirGrpCharInd->alarmCarInd & 0x03) <<4;
|
|
mBuf[0] |= (pCirGrpCharInd->contChkReqInd & 0x03) <<6;
|
|
return 1;
|
|
}
|
|
|
|
int siPkCirIdName (SiCirIdName *pCirIdName,u8 *mBuf)
|
|
{
|
|
int i;
|
|
for(i=0;i<26;i++)
|
|
{
|
|
mBuf[i] = pCirIdName->trunkNumClli[i] & 0x7f ;
|
|
}
|
|
return 26;
|
|
}
|
|
|
|
int siPkCLLI (SiCLLI *pCLLI,u8 *mBuf)
|
|
{
|
|
int i;
|
|
for(i=0;i<11;i++)
|
|
{
|
|
mBuf[i] = pCLLI->clliCode[i] & 0x7f ;
|
|
}
|
|
return 11;
|
|
}
|
|
|
|
|
|
/* unpacking/packing functions for ISUP message */
|
|
int siUnpkACM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduACM *ptr = &(pdus_ptr->m.addrComp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=2 m_v=0
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkBckCalInd(&ptr->bckCalInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_OPBACKCALLIND:
|
|
siUnpkOptBckCalInd (&ptr->optBckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CAUSIND:
|
|
siUnpkCauseDgn (&ptr->causeDgn,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt (&ptr->accTrans,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd1,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDUSD:
|
|
siUnpkTxMedReq(&ptr->txMedUsed,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL:
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCDELINFO:
|
|
siUnpkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRNUM:
|
|
siUnpkCdPtyNum(&ptr->redirNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLDIVERS:
|
|
siUnpkSiCllDiverInfo(&ptr->cllDivr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRRESTR:
|
|
siUnpkSiRedirRestr(&ptr->redirRstr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONFTRTIND: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_UIDACTIONIND: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkUidActionInd(&ptr->uidActionInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALDSUBBASSERMAR: //UK specific
|
|
siUnpkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkACM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduACM *ptr = &(pdus_ptr->m.addrComp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkBckCalInd(&ptr->bckCalInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
if(ptr->optBckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPBACKCALLIND;
|
|
flw_ptr[1] = siPkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->causeDgn.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CAUSIND;
|
|
flw_ptr[1] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->notifInd1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsed.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDUSD;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsed,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accDelInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCDELINFO;
|
|
flw_ptr[1] = siPkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRNUM;
|
|
flw_ptr[1] = siPkCdPtyNum(&ptr->redirNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cllDivr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLLDIVERS;
|
|
flw_ptr[1] = siPkSiCllDiverInfo(&ptr->cllDivr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirRstr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRRESTR;
|
|
flw_ptr[1] = siPkSiRedirRestr(&ptr->redirRstr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->confTrtInd.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CONFTRTIND;
|
|
flw_ptr[1] = siPkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->uidActionInd.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_UIDACTIONIND;
|
|
flw_ptr[1] = siPkUidActionInd(&ptr->uidActionInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubBasSerMar.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkANM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduANM *ptr = &(pdus_ptr->m.answer);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_BACKCALLIND:
|
|
siUnpkBckCalInd (&ptr->bckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPBACKCALLIND:
|
|
siUnpkOptBckCalInd (&ptr->optBckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONNUMB:
|
|
siUnpkConnectedNum(&ptr->connNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt (&ptr->accTrans,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCDELINFO:
|
|
siUnpkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd1,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLHISTORY:
|
|
siUnpkSiPropDly(&ptr->cllHstry,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDUSD:
|
|
siUnpkTxMedReq(&ptr->txMedUsed,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRGNUM:
|
|
siUnpkCdPtyNum(&ptr->redirNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL:
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRRESTR:
|
|
siUnpkSiRedirRestr(&ptr->redirRstr,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_BACKWARDGVNS: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkBackGVNS(&ptr->backGVNS,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_DISPLAYINFO: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkDisplayInfo(&ptr->displayInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALDSUBBASSERMAR: //UK specific
|
|
siUnpkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkANM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduANM *ptr = &(pdus_ptr->m.answer);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
if(ptr->bckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_BACKCALLIND;
|
|
flw_ptr[1] = siPkBckCalInd(&ptr->bckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->optBckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPBACKCALLIND;
|
|
flw_ptr[1] = siPkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONNUMB;
|
|
flw_ptr[1] = siPkConnectedNum(&ptr->connNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accDelInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCDELINFO;
|
|
flw_ptr[1] = siPkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cllHstry.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLLHISTORY;
|
|
flw_ptr[1] = siPkSiPropDly(&ptr->cllHstry,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsed.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDUSD;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsed,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRGNUM;
|
|
flw_ptr[1] = siPkCdPtyNum(&ptr->redirNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirRstr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRRESTR;
|
|
flw_ptr[1] = siPkSiRedirRestr(&ptr->redirRstr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->backGVNS.pres == 1)//(SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_BACKWARDGVNS;
|
|
flw_ptr[1] = siPkBackGVNS(&ptr->backGVNS,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->displayInfo.pres == 1)//(SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_DISPLAYINFO;
|
|
flw_ptr[1] = siPkDisplayInfo(&ptr->displayInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubBasSerMar.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
|
|
int siUnpkCPG(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCPG *ptr = &(pdus_ptr->m.caProg);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkEvntInfo(&ptr->evntInfo,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_EVNTINFO:
|
|
siUnpkEvntInfo(&ptr->evntInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CAUSIND:
|
|
siUnpkCauseDgn (&ptr->causeDgn,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_BACKCALLIND:
|
|
siUnpkBckCalInd (&ptr->bckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPBACKCALLIND:
|
|
siUnpkOptBckCalInd (&ptr->optBckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt (&ptr->accTrans,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd1,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDUSD:
|
|
siUnpkTxMedReq(&ptr->txMedUsed,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCDELINFO:
|
|
siUnpkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRNUM:
|
|
siUnpkCdPtyNum(&ptr->redirNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLDIVERS:
|
|
siUnpkSiCllDiverInfo(&ptr->cllDivr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRRESTR:
|
|
siUnpkSiRedirRestr(&ptr->redirRstr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALLTRNSFRNMB: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkCgPtyNum(&ptr->calTrnsNmb,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONNUMB: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkConnectedNum(&ptr->connNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_BACKWARDGVNS: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkBackGVNS(&ptr->backGVNS,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLHISTORY: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiPropDly(&ptr->cllHstry,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONFTRTIND: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_UIDACTIONIND: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkUidActionInd(&ptr->uidActionInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALDSUBBASSERMAR: //UK specific
|
|
siUnpkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkCPG(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCPG *ptr = &(pdus_ptr->m.caProg);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkEvntInfo(&ptr->evntInfo,flw_ptr);
|
|
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
if(ptr->evntInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_EVNTINFO;
|
|
flw_ptr[1] = siPkEvntInfo(&ptr->evntInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->causeDgn.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CAUSIND;
|
|
flw_ptr[1] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->bckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_BACKCALLIND;
|
|
flw_ptr[1] = siPkBckCalInd(&ptr->bckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->optBckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPBACKCALLIND;
|
|
flw_ptr[1] = siPkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsed.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDUSD;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsed,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accDelInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCDELINFO;
|
|
flw_ptr[1] = siPkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRNUM;
|
|
flw_ptr[1] = siPkCdPtyNum(&ptr->redirNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cllDivr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLLDIVERS;
|
|
flw_ptr[1] = siPkSiCllDiverInfo(&ptr->cllDivr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirRstr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRRESTR;
|
|
flw_ptr[1] = siPkSiRedirRestr(&ptr->redirRstr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->calTrnsNmb.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CALLTRNSFRNMB;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->calTrnsNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connNum.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CONNUMB;
|
|
flw_ptr[1] = siPkConnectedNum(&ptr->connNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->backGVNS.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_BACKWARDGVNS;
|
|
flw_ptr[1] = siPkBackGVNS(&ptr->backGVNS,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cllHstry.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CLLHISTORY;
|
|
flw_ptr[1] = siPkSiPropDly(&ptr->cllHstry,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->confTrtInd.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CONFTRTIND;
|
|
flw_ptr[1] = siPkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->uidActionInd.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_UIDACTIONIND;
|
|
flw_ptr[1] = siPkUidActionInd(&ptr->uidActionInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubBasSerMar.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
|
|
int siUnpkCQR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCQR *ptr = &(pdus_ptr->m.cirGrpQryRes);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=2
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangNoStat(&ptr->rangNoStat,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCirStateInd(&ptr->cirSteInd,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCQR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCQR *ptr = &(pdus_ptr->m.cirGrpQryRes);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 len;//opt_pointer
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
|
|
len = flw_ptr-pointer_ptr;
|
|
*(pointer_ptr) = len;
|
|
flw_ptr[0] = siPkRangNoStat(&ptr->rangNoStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
pointer_ptr++;
|
|
|
|
len = flw_ptr-pointer_ptr;
|
|
*(pointer_ptr) = len;
|
|
flw_ptr[0] = siPkCirStateInd(&ptr->cirSteInd,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
pointer_ptr++;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkGRA(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduGRA *ptr = &(pdus_ptr->m.cirGrpResAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangStat(&ptr->rangStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkGRA(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduGRA *ptr = &(pdus_ptr->m.cirGrpResAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
|
|
//M-variable
|
|
opt_pointer =0;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*(pointer_ptr++) = 1;
|
|
|
|
flw_ptr[0] = siPkRangStat(&ptr->rangStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCFN(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCFN *ptr = &(pdus_ptr->m.confusion);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCauseDgn(&ptr->causeDgn,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCFN(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCFN *ptr = &(pdus_ptr->m.confusion);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCON(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCON *ptr = &(pdus_ptr->m.connect);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=2 m_v=0
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkBckCalInd(&ptr->bckCalInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_OPBACKCALLIND:
|
|
siUnpkOptBckCalInd (&ptr->optBckCalInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONNUMB:
|
|
siUnpkConnectedNum(&ptr->connNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt (&ptr->accTrans,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDUSD:
|
|
siUnpkTxMedReq(&ptr->txMedUsed,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL:
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCDELINFO:
|
|
siUnpkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLHISTORY:
|
|
siUnpkSiPropDly(&ptr->cllHstry,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRGNUM:
|
|
siUnpkCdPtyNum(&ptr->redirNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRRESTR:
|
|
siUnpkSiRedirRestr(&ptr->redirRstr,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_BACKWARDGVNS: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkBackGVNS(&ptr->backGVNS,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONFTRTIND: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
|
|
case ME_CALDSUBBASSERMAR: //UK specific
|
|
siUnpkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkCON(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCON *ptr = &(pdus_ptr->m.connect);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkBckCalInd(&ptr->bckCalInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
if(ptr->optBckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPBACKCALLIND;
|
|
flw_ptr[1] = siPkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONNUMB;
|
|
flw_ptr[1] = siPkConnectedNum(&ptr->connNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsed.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDUSD;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsed,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accDelInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCDELINFO;
|
|
flw_ptr[1] = siPkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cllHstry.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLLHISTORY;
|
|
flw_ptr[1] = siPkSiPropDly(&ptr->cllHstry,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRGNUM;
|
|
flw_ptr[1] = siPkCdPtyNum(&ptr->redirNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirRstr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRRESTR;
|
|
flw_ptr[1] = siPkSiRedirRestr(&ptr->redirRstr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
|
|
if(ptr->backGVNS.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_BACKWARDGVNS;
|
|
flw_ptr[1] = siPkBackGVNS(&ptr->backGVNS,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->confTrtInd.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CONFTRTIND;
|
|
flw_ptr[1] = siPkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubBasSerMar.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCOT(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCOT *ptr = &(pdus_ptr->m.continuity);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkContInd(&ptr->contInd,flw_ptr,0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCOT(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCOT *ptr = &(pdus_ptr->m.continuity);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
opt_pointer = 0;
|
|
pointer_ptr = 0;
|
|
|
|
//M-fixed
|
|
siPkContInd(&ptr->contInd,flw_ptr);
|
|
flw_ptr += 1;
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkFRJ(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduFRJ *ptr = &(pdus_ptr->m.facReject);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=1
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkFacInd(&ptr->facInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCauseDgn(&ptr->causeDgn,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkFRJ(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduFRJ *ptr = &(pdus_ptr->m.facReject);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
siPkFacInd(&ptr->facInd,flw_ptr);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
//Optional
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkINF(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduINF *ptr = &(pdus_ptr->m.info);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=2 m_v=0
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkInfoInd(&ptr->infoInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CALGPARTCAT:
|
|
siUnpkCgPtyCat(&ptr->cgPtyCat,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGPARTNUM:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef(&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONREQ:
|
|
siUnpkConnReq(&ptr->connReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NATINFIND: //UK specific
|
|
siUnpkNatInfInd(&ptr->natInfInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALDSUBBASSERMAR://UK specific
|
|
siUnpkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGSUBBASSERMAR://UK specific
|
|
siUnpkCalgSubBasSerMar(&ptr->calgSubBasSerMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGSUBORIFACMAR://UK specific
|
|
siUnpkCalgSubOrgFacMar(&ptr->calgSubOrgFacMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALDSUBTERFACMAR://UK specific
|
|
siUnpkCaldSubTermFacMar(&ptr->caldSubTermFacMar,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkINF(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduINF *ptr = &(pdus_ptr->m.info);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkInfoInd(&ptr->infoInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
if(ptr->cgPtyCat.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALGPARTCAT;
|
|
flw_ptr[1] = siPkCgPtyCat(&ptr->cgPtyCat,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALGPARTNUM;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONREQ;
|
|
flw_ptr[1] = siPkConnReq(&ptr->connReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
|
|
if(ptr->natInfInd.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_NATINFIND;
|
|
flw_ptr[1] = siPkNatInfInd(&ptr->natInfInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubBasSerMar.pres == 1) //UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCaldSubBasSerMar(&ptr->caldSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->calgSubBasSerMar.pres == 1) //UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALGSUBBASSERMAR;
|
|
flw_ptr[1] = siPkCalgSubBasSerMar(&ptr->calgSubBasSerMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->calgSubOrgFacMar.pres == 1) //UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALGSUBORIFACMAR;
|
|
flw_ptr[1] = siPkCalgSubOrgFacMar(&ptr->calgSubOrgFacMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->caldSubTermFacMar.pres == 1) //UK specific
|
|
{
|
|
flw_ptr[0] = ME_CALDSUBTERFACMAR;
|
|
flw_ptr[1] = siPkCaldSubTermFacMar(&ptr->caldSubTermFacMar,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkINR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduINR *ptr = &(pdus_ptr->m.infoReq);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=2 m_v=0
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkInfoReqInd(&ptr->infoReqInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CALREF:
|
|
siUnpkCallRef(&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NATINFREQIND: //UK specific
|
|
siUnpkNatInfReqInd(&ptr->natInfReqInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkINR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduINR *ptr = &(pdus_ptr->m.infoReq);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkInfoReqInd(&ptr->infoReqInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->natInfReqInd.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_NATINFREQIND;
|
|
flw_ptr[1] = siPkNatInfReqInd(&ptr->natInfReqInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkIAM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduIAM *ptr = &(pdus_ptr->m.initAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
//check mandatory length
|
|
//m_f=5 m_v=1
|
|
if(length < 6)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkNatConInd(&ptr->natConInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
siUnpkFwdCallInd(&ptr->fwdCallInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
siUnpkCgPtyCat(&ptr->cgPtyCat,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
siUnpkTxMedReq(&ptr->txMedReq,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCdPtyNum(&ptr->cdPtyNum,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_TRANNETSEL:
|
|
siUnpkTranNetSel(&ptr->tranNetSel,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGPARTNUM:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPFWDCALLIND:
|
|
siUnpkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRGNUM:
|
|
siUnpkRedirgNum(&ptr->redirgNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRINFO:
|
|
siUnpkRedirInfo(&ptr->redirInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLSDUGRPINTCDE:
|
|
siUnpkCugIntCode(&ptr->cugIntCode,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONREQ:
|
|
siUnpkConnReq(&ptr->connReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ORIGCALDNUM:
|
|
siUnpkOrigCdNum(&ptr->origCdNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USRSERVINFO:
|
|
siUnpkSiUsrServInfo(&ptr->usrServInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PROPDLYCTR:
|
|
siUnpkSiPropDly(&ptr->propDly,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USRSERVINFOPR:
|
|
siUnpkSiUsrServInfo(&ptr->usrServInfo1,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENDIGITS:
|
|
siUnpkSiGenDigits(&ptr->genDigits,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ORISCCDE:
|
|
siUnpkSigPointCode(&ptr->orgPteCde,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USRTSRVINFO:
|
|
siUnpkSiUsrTSrvInfo(&ptr->usrTSrvInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_MLPPPREC:
|
|
siUnpkSiMlppPrec(&ptr->mlppPrec,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDPRM:
|
|
siUnpkTxMedReq(&ptr->txMedUsPr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_LOCNMB:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum1,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
// SS7_ITU97
|
|
case ME_FORWARDGVNS:
|
|
siUnpkForwardGVNS(&ptr->forwardGVNS,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CCSS:
|
|
siUnpkCcss(&ptr->ccss,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETMGMTCONTROLS:
|
|
siUnpkNetMgmtControls(&ptr->netMgmtControls,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CIRASGNMAP:
|
|
siUnpkCirAsgnMap(&ptr->cirAsgnMap,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CORRELATIONID:
|
|
siUnpkCorrelationId(&ptr->correlationId,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALLDIVTRTIND:
|
|
siUnpkCallDivTrtInd(&ptr->callDivTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALLINNMB:
|
|
siUnpkCallInNmb(&ptr->callInNmb,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALLOFFERTRTIND:
|
|
siUnpkCallOfferTrtInd(&ptr->callOfferTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONFTRTIND:
|
|
siUnpkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SCFID:
|
|
siUnpkScfId(&ptr->scfId,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_UIDCAPIND:
|
|
siUnpkUidCapInd(&ptr->uidCapInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL:
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_HOPCOUNTER:
|
|
siUnpkHopCounter(&ptr->hopCounter,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_COLLCALLREQ:
|
|
siUnpkCollCallReq(&ptr->collCallReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
//UK specific
|
|
case ME_NATFORCALIND:
|
|
siUnpkSiNatForCalInd(&ptr->natForCalInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PRESNUM:
|
|
siUnpkSiPresNum(&ptr->presNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_LASDIVLINID:
|
|
siUnpkCgPtyNum(&ptr->lasDivLinId,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARTCLI:
|
|
siUnpkSiPartCLI(&ptr->partCLI,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NATFORCALIND_LTL:
|
|
siUnpkSiNatForCalIndLbL(&ptr->natForCalIndLbL,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siUnpkIAM_AN(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduIAM *ptr = &(pdus_ptr->m.initAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
//check mandatory length
|
|
//m_f=4 m_v=2
|
|
if(length < 6)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkNatConInd(&ptr->natConInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
siUnpkFwdCallInd(&ptr->fwdCallInd,flw_ptr,0);
|
|
flw_ptr += 2;
|
|
siUnpkCgPtyCat(&ptr->cgPtyCat,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkSiUsrServInfo(&ptr->usrServInfo,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCdPtyNum(&ptr->cdPtyNum,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_TRANNETSEL:
|
|
siUnpkTranNetSel(&ptr->tranNetSel,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGPARTNUM:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPFWDCALLIND:
|
|
siUnpkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRGNUM:
|
|
siUnpkRedirgNum(&ptr->redirgNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRINFO:
|
|
siUnpkRedirInfo(&ptr->redirInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLSDUGRPINTCDE:
|
|
siUnpkCugIntCode(&ptr->cugIntCode,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONREQ:
|
|
siUnpkConnReq(&ptr->connReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ORIGCALDNUM:
|
|
siUnpkOrigCdNum(&ptr->origCdNum,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PROPDLYCTR:
|
|
siUnpkSiPropDly(&ptr->propDly,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USRSERVINFOPR:
|
|
siUnpkSiUsrServInfo(&ptr->usrServInfo1,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENDIGITS:
|
|
siUnpkSiGenDigits(&ptr->genDigits,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ORISCCDE:
|
|
siUnpkSigPointCode(&ptr->orgPteCde,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USRTSRVINFO:
|
|
siUnpkSiUsrTSrvInfo(&ptr->usrTSrvInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_MLPPPREC:
|
|
siUnpkSiMlppPrec(&ptr->mlppPrec,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDPRM:
|
|
siUnpkTxMedReq(&ptr->txMedUsPr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_LOCNMB:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum1,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkIAM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduIAM *ptr = &(pdus_ptr->m.initAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkNatConInd(&ptr->natConInd,flw_ptr);
|
|
flw_ptr += siPkFwdCallInd(&ptr->fwdCallInd,flw_ptr);
|
|
flw_ptr += siPkCgPtyCat(&ptr->cgPtyCat,flw_ptr);
|
|
flw_ptr += siPkTxMedReq(&ptr->txMedReq,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkCdPtyNum(&ptr->cdPtyNum,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
if(ptr->tranNetSel.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANNETSEL;
|
|
flw_ptr[1] = siPkTranNetSel(&ptr->tranNetSel,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALGPARTNUM;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->natForCalInd.pres == 1)//UK specific
|
|
{
|
|
flw_ptr[0] = ME_NATFORCALIND;
|
|
flw_ptr[1] = siPkSiNatForCalInd(&ptr->natForCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->opFwdCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPFWDCALLIND;
|
|
flw_ptr[1] = siPkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirgNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRGNUM;
|
|
flw_ptr[1] = siPkRedirgNum(&ptr->redirgNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRINFO;
|
|
flw_ptr[1] = siPkRedirInfo(&ptr->redirInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cugIntCode.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLSDUGRPINTCDE;
|
|
flw_ptr[1] = siPkCugIntCode(&ptr->cugIntCode,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONREQ;
|
|
flw_ptr[1] = siPkConnReq(&ptr->connReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->origCdNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ORIGCALDNUM;
|
|
flw_ptr[1] = siPkOrigCdNum(&ptr->origCdNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->usrServInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USRSERVINFO;
|
|
flw_ptr[1] = siPkSiUsrServInfo(&ptr->usrServInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->propDly.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PROPDLYCTR;
|
|
flw_ptr[1] = siPkSiPropDly(&ptr->propDly,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usrServInfo1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USRSERVINFOPR;
|
|
flw_ptr[1] = siPkSiUsrServInfo(&ptr->usrServInfo1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genDigits.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENDIGITS;
|
|
flw_ptr[1] = siPkSiGenDigits(&ptr->genDigits,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->orgPteCde.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ORISCCDE;
|
|
flw_ptr[1] = siPkSigPointCode(&ptr->orgPteCde,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usrTSrvInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USRTSRVINFO;
|
|
flw_ptr[1] = siPkSiUsrTSrvInfo(&ptr->usrTSrvInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->mlppPrec.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MLPPPREC;
|
|
flw_ptr[1] = siPkSiMlppPrec(&ptr->mlppPrec,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsPr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDPRM;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsPr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_LOCNMB;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
// SS7_ITU97
|
|
if(ptr->forwardGVNS.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_FORWARDGVNS;
|
|
flw_ptr[1] = siPkForwardGVNS(&ptr->forwardGVNS,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->ccss.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CCSS;
|
|
flw_ptr[1] = siPkCcss(&ptr->ccss,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netMgmtControls.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETMGMTCONTROLS;
|
|
flw_ptr[1] = siPkNetMgmtControls(&ptr->netMgmtControls,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cirAsgnMap.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CIRASGNMAP;
|
|
flw_ptr[1] = siPkCirAsgnMap(&ptr->cirAsgnMap,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->correlationId.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CORRELATIONID;
|
|
flw_ptr[1] = siPkCorrelationId(&ptr->correlationId,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callDivTrtInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALLDIVTRTIND;
|
|
flw_ptr[1] = siPkCallDivTrtInd(&ptr->callDivTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callInNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALLINNMB;
|
|
flw_ptr[1] = siPkCallInNmb(&ptr->callInNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callOfferTrtInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALLOFFERTRTIND;
|
|
flw_ptr[1] = siPkCallOfferTrtInd(&ptr->callOfferTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->confTrtInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONFTRTIND;
|
|
flw_ptr[1] = siPkSiConfTrtInd(&ptr->confTrtInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->scfId.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SCFID;
|
|
flw_ptr[1] = siPkScfId(&ptr->scfId,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->uidCapInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_UIDCAPIND;
|
|
flw_ptr[1] = siPkUidCapInd(&ptr->uidCapInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->hopCounter.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_HOPCOUNTER;
|
|
flw_ptr[1] = siPkHopCounter(&ptr->hopCounter,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->collCallReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_COLLCALLREQ;
|
|
flw_ptr[1] = siPkCollCallReq(&ptr->collCallReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
//UK specific
|
|
// if(ptr->natForCalInd.pres == 1)
|
|
// {
|
|
// flw_ptr[0] = ME_NATFORCALIND;
|
|
// flw_ptr[1] = siPkSiNatForCalInd(&ptr->natForCalInd,flw_ptr+2);
|
|
// flw_ptr += flw_ptr[1] + 2;
|
|
// *pointer_ptr = opt_pointer;
|
|
// }
|
|
if(ptr->presNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PRESNUM;
|
|
flw_ptr[1] = siPkSiPresNum(&ptr->presNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->lasDivLinId.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_LASDIVLINID;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->lasDivLinId,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->partCLI.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARTCLI;
|
|
flw_ptr[1] = siPkSiPartCLI(&ptr->partCLI,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->natForCalIndLbL.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NATFORCALIND_LTL;
|
|
flw_ptr[1] = siPkSiNatForCalIndLbL(&ptr->natForCalIndLbL,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siPkIAM_AN(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduIAM *ptr = &(pdus_ptr->m.initAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkNatConInd(&ptr->natConInd,flw_ptr);
|
|
flw_ptr += siPkFwdCallInd(&ptr->fwdCallInd,flw_ptr);
|
|
flw_ptr += siPkCgPtyCat(&ptr->cgPtyCat,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 3;
|
|
|
|
*(pointer_ptr++) = 3;
|
|
|
|
flw_ptr[0] = siPkSiUsrServInfo(&ptr->usrServInfo,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 3;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
*(pointer_ptr++) = opt_pointer;
|
|
|
|
flw_ptr[0] = siPkCdPtyNum(&ptr->cdPtyNum,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 1 + opt_pointer -1;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
|
|
|
|
//Optional
|
|
if(ptr->tranNetSel.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANNETSEL;
|
|
flw_ptr[1] = siPkTranNetSel(&ptr->tranNetSel,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALGPARTNUM;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->opFwdCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPFWDCALLIND;
|
|
flw_ptr[1] = siPkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirgNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRGNUM;
|
|
flw_ptr[1] = siPkRedirgNum(&ptr->redirgNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRINFO;
|
|
flw_ptr[1] = siPkRedirInfo(&ptr->redirInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cugIntCode.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLSDUGRPINTCDE;
|
|
flw_ptr[1] = siPkCugIntCode(&ptr->cugIntCode,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONREQ;
|
|
flw_ptr[1] = siPkConnReq(&ptr->connReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->origCdNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ORIGCALDNUM;
|
|
flw_ptr[1] = siPkOrigCdNum(&ptr->origCdNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->propDly.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PROPDLYCTR;
|
|
flw_ptr[1] = siPkSiPropDly(&ptr->propDly,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usrServInfo1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USRSERVINFOPR;
|
|
flw_ptr[1] = siPkSiUsrServInfo(&ptr->usrServInfo1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genDigits.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENDIGITS;
|
|
flw_ptr[1] = siPkSiGenDigits(&ptr->genDigits,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->orgPteCde.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ORISCCDE;
|
|
flw_ptr[1] = siPkSigPointCode(&ptr->orgPteCde,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usrTSrvInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USRTSRVINFO;
|
|
flw_ptr[1] = siPkSiUsrTSrvInfo(&ptr->usrTSrvInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->mlppPrec.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MLPPPREC;
|
|
flw_ptr[1] = siPkSiMlppPrec(&ptr->mlppPrec,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->txMedUsPr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDPRM;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsPr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum1.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_LOCNMB;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum1,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkREL(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduREL *ptr = &(pdus_ptr->m.release);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkCauseDgn(&ptr->causeDgn,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_REDIRINFO:
|
|
siUnpkRedirInfo(&ptr->redirInfo,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRNUM:
|
|
siUnpkCdPtyNum(&ptr->redirNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SIGPTCDE:
|
|
siUnpkSigPointCode(&ptr->sigPointCode,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_AUTOCONGLVL:
|
|
siUnpkAutoCongLvl (&ptr->auCongLvl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NETSPFAC:
|
|
siUnpkSiNetSpecFacil(&ptr->netFac,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCDELINFO:
|
|
siUnpkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REDIRRESTR:
|
|
siUnpkSiRedirRestr(&ptr->redirRstr,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_DISPLAYINFO: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkDisplayInfo(&ptr->displayInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkREL(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduREL *ptr = &(pdus_ptr->m.release);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
//Optional
|
|
if(ptr->redirInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRINFO;
|
|
flw_ptr[1] = siPkRedirInfo(&ptr->redirInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRNUM;
|
|
flw_ptr[1] = siPkCdPtyNum(&ptr->redirNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->sigPointCode.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SIGPTCDE;
|
|
flw_ptr[1] = siPkSigPointCode(&ptr->sigPointCode,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->auCongLvl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_AUTOCONGLVL;
|
|
flw_ptr[1] = siPkAutoCongLvl(&ptr->auCongLvl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->netFac.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NETSPFAC;
|
|
flw_ptr[1] = siPkSiNetSpecFacil(&ptr->netFac,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accDelInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCDELINFO;
|
|
flw_ptr[1] = siPkSiAccDelInfo(&ptr->accDelInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->redirRstr.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REDIRRESTR;
|
|
flw_ptr[1] = siPkSiRedirRestr(&ptr->redirRstr,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->displayInfo.pres == 1)//(SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_DISPLAYINFO;
|
|
flw_ptr[1] = siPkDisplayInfo(&ptr->displayInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkRLC(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduRLC *ptr = &(pdus_ptr->m.relComplete);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CAUSIND:
|
|
siUnpkCauseDgn(&ptr->causeDgn,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkRLC(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduRLC *ptr = &(pdus_ptr->m.relComplete);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->causeDgn.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CAUSIND;
|
|
flw_ptr[1] = siPkCauseDgn(&ptr->causeDgn,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkSAM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduSAM *ptr = &(pdus_ptr->m.subAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkSubNum(&ptr->subNum,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkSAM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduSAM *ptr = &(pdus_ptr->m.subAddr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkSubNum(&ptr->subNum,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkUSR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduUSR *ptr = &(pdus_ptr->m.usr2Usr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkUsr2UsrInfo(&ptr->usr2UsrInfo,pointer_ptr+1, pointer_ptr[0]);
|
|
flw_ptr++;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkUSR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduUSR *ptr = &(pdus_ptr->m.usr2Usr);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 2;
|
|
*(pointer_ptr++) = 2;
|
|
*pointer_ptr = 0;
|
|
flw_ptr[0] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
//Optional
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkFOT(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduFOT *ptr = &(pdus_ptr->m.fwdTrans);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CALREF:
|
|
siUnpkCallRef(&ptr->callRef,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkFOT(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduFOT *ptr = &(pdus_ptr->m.fwdTrans);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkRES(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduRES *ptr = &(pdus_ptr->m.resume);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkSusResInd(&ptr->suspResInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CALREF:
|
|
siUnpkCallRef(&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkRES(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduRES *ptr = &(pdus_ptr->m.resume);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkSusResInd(&ptr->suspResInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkSUS(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduSUS *ptr = &(pdus_ptr->m.suspend);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkSusResInd(&ptr->suspResInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CALREF:
|
|
siUnpkCallRef(&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkSUS(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduSUS *ptr = &(pdus_ptr->m.suspend);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkSusResInd(&ptr->suspResInd,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*pointer_ptr = 0;
|
|
opt_pointer=1;
|
|
|
|
//Optional
|
|
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCGB(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCGB *ptr = &(pdus_ptr->m.cirGrpBlk);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=1
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangStat(&ptr->rangStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCGB(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCGB *ptr = &(pdus_ptr->m.cirGrpBlk);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
opt_pointer=0;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 1;
|
|
flw_ptr[0] = siPkRangStat(&ptr->rangStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCGBA(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCGBA *ptr = &(pdus_ptr->m.cirGrpBlkAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=1
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangStat(&ptr->rangStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCGBA(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCGBA *ptr = &(pdus_ptr->m.cirGrpBlkAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
opt_pointer=1;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 1;
|
|
flw_ptr[0] = siPkRangStat(&ptr->rangStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCGU(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCGU *ptr = &(pdus_ptr->m.cirGrpUnblk);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=1
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
//flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangStat(&ptr->rangStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCGU(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCGU *ptr = &(pdus_ptr->m.cirGrpUnblk);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
opt_pointer=0;
|
|
//M-fixed
|
|
flw_ptr += siPkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 1;
|
|
flw_ptr[0] = siPkRangStat(&ptr->rangStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCGUA(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCGUA *ptr = &(pdus_ptr->m.cirGrpUblkAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=1
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangStat(&ptr->rangStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCGUA(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCGUA *ptr = &(pdus_ptr->m.cirGrpUblkAck);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
opt_pointer =0;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkCirGrpSupMTypInd(&ptr->cgsmti,flw_ptr);
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 1;
|
|
flw_ptr[0] = siPkRangStat(&ptr->rangStat,flw_ptr+1);
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkGRS(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduGRS *ptr = &(pdus_ptr->m.cirGrpRes);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
// flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangNoStat(&ptr->rangNoStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkGRS(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduGRS *ptr = &(pdus_ptr->m.cirGrpRes);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*(pointer_ptr++) = 1;
|
|
|
|
flw_ptr[0] = siPkRangNoStat(&ptr->rangNoStat,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCQM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCQM *ptr = &(pdus_ptr->m.cirGrpQry);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=1
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
//flw_ptr += *flw_ptr;
|
|
pointer_ptr = flw_ptr + *flw_ptr;
|
|
if(pointer_ptr+pointer_ptr[0]+1-raw_ptr > length)
|
|
return -1;
|
|
siUnpkRangNoStat(&ptr->rangNoStat,pointer_ptr+1, pointer_ptr[0]);
|
|
|
|
//Optional
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkCQM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCQM *ptr = &(pdus_ptr->m.cirGrpQry);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr += 1;
|
|
*(pointer_ptr++) = 1;
|
|
flw_ptr[0] = siPkRangNoStat(&ptr->rangNoStat,flw_ptr+1);
|
|
opt_pointer = flw_ptr[0] + 2;
|
|
flw_ptr += flw_ptr[0]+1;
|
|
|
|
//Optional
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkFAA(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduFAA *ptr = &(pdus_ptr->m.facAccept);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkFacInd(&ptr->facInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONREQ:
|
|
siUnpkConnReq(&ptr->connReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkFAA(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduFAA *ptr = &(pdus_ptr->m.facAccept);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkFacInd(&ptr->facInd,flw_ptr);
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
|
|
//Optional
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONREQ;
|
|
flw_ptr[1] = siPkConnReq(&ptr->connReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkFAR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduFAR *ptr = &(pdus_ptr->m.facRequest);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=1 m_v=0
|
|
if(length < 1)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkFacInd(&ptr->facInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_USR2USRIND:
|
|
siUnpkUsr2UsrInd (&ptr->usr2UsrInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALREF:
|
|
siUnpkCallRef (&ptr->callRef,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CONREQ:
|
|
siUnpkConnReq(&ptr->connReq,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkFAR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduFAR *ptr = &(pdus_ptr->m.facRequest);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkFacInd(&ptr->facInd,flw_ptr);
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
|
|
//Optional
|
|
if(ptr->usr2UsrInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRIND;
|
|
flw_ptr[1] = siPkUsr2UsrInd(&ptr->usr2UsrInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->callRef.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALREF;
|
|
flw_ptr[1] = siPkCallRef(&ptr->callRef,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->connReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CONREQ;
|
|
flw_ptr[1] = siPkConnReq(&ptr->connReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkPAM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduPAM *ptr = &(pdus_ptr->m.passAlng);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
siUnpkPassAlng(&ptr->passAlng,flw_ptr,length);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int siPkPAM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduPAM *ptr = &(pdus_ptr->m.passAlng);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
pointer_ptr = 0;
|
|
opt_pointer = 0;
|
|
|
|
return siPkPassAlng(&ptr->passAlng,flw_ptr);
|
|
}
|
|
|
|
int siUnpkUPT(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduUPAT *ptr = &(pdus_ptr->m.usrPrtAvTst);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkUPT(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduUPAT *ptr = &(pdus_ptr->m.usrPrtAvTst);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkUPA(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduUPAT *ptr = &(pdus_ptr->m.usrPrtAvTst);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkUPA(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduUPAT *ptr = &(pdus_ptr->m.usrPrtAvTst);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkFAC(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduFAC *ptr = &(pdus_ptr->m.facility);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_REMOTOPER:
|
|
siUnpkSiRemotOper(&ptr->remotOper,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_SERVACT:
|
|
siUnpkServiceAct(&ptr->serviceAct,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALLTRNSFRNMB: // (SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkCgPtyNum(&ptr->calTrnsNmb,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt (&ptr->accTrans,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkFAC(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduFAC *ptr = &(pdus_ptr->m.facility);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->remotOper.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_REMOTOPER;
|
|
flw_ptr[1] = siPkSiRemotOper(&ptr->remotOper,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->serviceAct.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_SERVACT;
|
|
flw_ptr[1] = siPkServiceAct(&ptr->serviceAct,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->calTrnsNmb.pres == 1)// (SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = ME_CALLTRNSFRNMB;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->calTrnsNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->notifInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkNRM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduNRM *ptr = &(pdus_ptr->m.netResMgt);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ECHOCNTRL:
|
|
siUnpkSiEchoCtl(&ptr->echoControl,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_TRANSMEDUSD:
|
|
siUnpkTxMedReq(&ptr->txMedUsed,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkNRM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduNRM *ptr = &(pdus_ptr->m.netResMgt);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->txMedUsed.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_TRANSMEDUSD;
|
|
flw_ptr[1] = siPkTxMedReq(&ptr->txMedUsed,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->echoControl.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ECHOCNTRL;
|
|
flw_ptr[1] = siPkSiEchoCtl(&ptr->echoControl,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkIDR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduIDR *ptr = &(pdus_ptr->m.identReq);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MCIDREQ:
|
|
siUnpkSiMcidReqInd(&ptr->mcidReq,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkIDR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduIDR *ptr = &(pdus_ptr->m.identReq);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->mcidReq.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MCIDREQ;
|
|
flw_ptr[1] = siPkSiMcidReqInd(&ptr->mcidReq,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkIRS(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduIRS *ptr = &(pdus_ptr->m.identRsp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MCIDRSP:
|
|
siUnpkSiMcidRspInd(&ptr->mcidRsp,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CALGPARTNUM:
|
|
siUnpkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case MEI_CHRGINFODELAY: //( SS7_ITU97 || SS7_ETSIV3)
|
|
siUnpkNaPaChgPID(&ptr->naPaChgPID,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkIRS(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduIRS *ptr = &(pdus_ptr->m.identRsp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->mcidRsp.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MCIDRSP;
|
|
flw_ptr[1] = siPkSiMcidRspInd(&ptr->mcidRsp,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->cgPtyNum.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CALGPARTNUM;
|
|
flw_ptr[1] = siPkCgPtyNum(&ptr->cgPtyNum,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->naPaChgPID.pres == 1)//( SS7_ITU97 || SS7_ETSIV3)
|
|
{
|
|
flw_ptr[0] = MEI_CHRGINFODELAY;
|
|
flw_ptr[1] = siPkNaPaChgPID(&ptr->naPaChgPID,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkSGM(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduSGM *ptr = &(pdus_ptr->m.segment);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_ACCTPORT:
|
|
siUnpkAccTrnspt(&ptr->accTrans,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_USR2USRINFO:
|
|
siUnpkUsr2UsrInfo (&ptr->usr2UsrInfo,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgComp,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENDIGITS:
|
|
siUnpkSiGenDigits(&ptr->genDigits,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_NOTIFINDC:
|
|
siUnpkNotifInd(&ptr->notifInd,flw_ptr+2, flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_GENNMB:
|
|
siUnpkSiGenNum(&ptr->genNmb,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkSGM(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduSGM *ptr = &(pdus_ptr->m.segment);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->accTrans.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_ACCTPORT;
|
|
flw_ptr[1] = siPkAccTrnspt(&ptr->accTrans,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->usr2UsrInfo.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_USR2USRINFO;
|
|
flw_ptr[1] = siPkUsr2UsrInfo(&ptr->usr2UsrInfo,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->msgComp.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgComp,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->genDigits.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENDIGITS;
|
|
flw_ptr[1] = siPkSiGenDigits(&ptr->genDigits,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->notifInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_NOTIFINDC;
|
|
flw_ptr[1] = siPkNotifInd(&ptr->notifInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(ptr->genNmb.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_GENNMB;
|
|
flw_ptr[1] = siPkSiGenNum(&ptr->genNmb,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
|
|
int siUnpkPRI(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduPRI *ptr = &(pdus_ptr->m.preRelease);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPBACKCALLIND:
|
|
siUnpkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_OPFWDCALLIND:
|
|
siUnpkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_APPTRAN:
|
|
siUnpkAppTransParam(&ptr->appTransParam,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkPRI(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduPRI *ptr = &(pdus_ptr->m.preRelease);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->optBckCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPBACKCALLIND;
|
|
flw_ptr[1] = siPkOptBckCalInd(&ptr->optBckCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->opFwdCalInd.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_OPFWDCALLIND;
|
|
flw_ptr[1] = siPkOpFwdCalInd(&ptr->opFwdCalInd,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->appTransParam.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_APPTRAN;
|
|
flw_ptr[1] = siPkAppTransParam(&ptr->appTransParam,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkAPP(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduAPP *ptr = &(pdus_ptr->m.appTransport);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=0 m_v=0
|
|
// if(length < 1)
|
|
// return -1;
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_MSGCOMP:
|
|
siUnpkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_PARCOMPIN:
|
|
siUnpkSiParmCompInfo(&ptr->parmCom,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_APPTRAN:
|
|
siUnpkAppTransParam(&ptr->appTransParam,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkAPP(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduAPP *ptr = &(pdus_ptr->m.appTransport);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
//Optional
|
|
if(ptr->msgCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_MSGCOMP;
|
|
flw_ptr[1] = siPkSiMsgCompInfo(&ptr->msgCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->parmCom.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_PARCOMPIN;
|
|
flw_ptr[1] = siPkSiParmCompInfo(&ptr->parmCom,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->appTransParam.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_APPTRAN;
|
|
flw_ptr[1] = siPkAppTransParam(&ptr->appTransParam,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
int siUnpkCVR(SiAllPdus *pdus_ptr, u8 *raw_ptr, u16 length)
|
|
{
|
|
SiPduCVR *ptr = &(pdus_ptr->m.cirValRsp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
|
|
|
|
//check mandatory length
|
|
//m_f=2 m_v=0
|
|
if(length < 2)
|
|
return -1;
|
|
|
|
//M-fixed
|
|
siUnpkCirValRspInd(&ptr->valRspInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
siUnpkCirGrpCharInd(&ptr->grpCharInd,flw_ptr,0);
|
|
flw_ptr += 1;
|
|
|
|
//M-variable
|
|
|
|
//Optional
|
|
if(*flw_ptr != 0)
|
|
{
|
|
flw_ptr += *flw_ptr;
|
|
while(*flw_ptr != 0)
|
|
{
|
|
if(flw_ptr+flw_ptr[1]+2-raw_ptr > length)
|
|
return -3;
|
|
switch(*flw_ptr)
|
|
{
|
|
case ME_CIRIDNAME:
|
|
siUnpkCirIdName(&ptr->cirIdName,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
case ME_CLLI:
|
|
siUnpkCLLI(&ptr->clli,flw_ptr+2,flw_ptr[1]);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
default:
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int siPkCVR(SiAllPdus *pdus_ptr, u8 *raw_ptr)
|
|
{
|
|
SiPduCVR *ptr = &(pdus_ptr->m.cirValRsp);
|
|
u8 *flw_ptr = raw_ptr;
|
|
u8 *pointer_ptr;
|
|
u8 opt_pointer;
|
|
|
|
|
|
//M-fixed
|
|
flw_ptr += siPkCirValRspInd(&ptr->valRspInd,flw_ptr);
|
|
flw_ptr += siPkCirGrpCharInd(&ptr->grpCharInd,flw_ptr);
|
|
|
|
//M-variable
|
|
opt_pointer = 1;
|
|
pointer_ptr = flw_ptr;
|
|
flw_ptr++;
|
|
*pointer_ptr = 0;
|
|
|
|
//Optional
|
|
if(ptr->cirIdName.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CIRIDNAME;
|
|
flw_ptr[1] = siPkCirIdName(&ptr->cirIdName,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
if(ptr->clli.pres == 1)
|
|
{
|
|
flw_ptr[0] = ME_CLLI;
|
|
flw_ptr[1] = siPkCLLI(&ptr->clli,flw_ptr+2);
|
|
flw_ptr += flw_ptr[1] + 2;
|
|
*pointer_ptr = opt_pointer;
|
|
}
|
|
|
|
if(*pointer_ptr != 0)
|
|
*(flw_ptr++) = 0; //End of optional parameters
|
|
|
|
return flw_ptr - raw_ptr;
|
|
}
|
|
|
|
|
|
static int siSelUnpkFun_ITU(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length)
|
|
{
|
|
switch(type)
|
|
{
|
|
case M_ACM:
|
|
return siUnpkACM(pdus_ptr, raw_ptr, length);
|
|
case M_ANM:
|
|
return siUnpkANM(pdus_ptr, raw_ptr, length);
|
|
case M_CPG:
|
|
return siUnpkCPG(pdus_ptr, raw_ptr, length);
|
|
case M_CGB:
|
|
return siUnpkCGB(pdus_ptr, raw_ptr, length);
|
|
case M_CGBA:
|
|
return siUnpkCGBA(pdus_ptr, raw_ptr, length);
|
|
case M_CQM:
|
|
return siUnpkCQM(pdus_ptr, raw_ptr, length);
|
|
case M_CQR:
|
|
return siUnpkCQR(pdus_ptr, raw_ptr, length);
|
|
case M_GRS:
|
|
return siUnpkGRS(pdus_ptr, raw_ptr, length);
|
|
case M_GRA:
|
|
return siUnpkGRA(pdus_ptr, raw_ptr, length);
|
|
case M_CGU:
|
|
return siUnpkCGU(pdus_ptr, raw_ptr, length);
|
|
case M_CGUA:
|
|
return siUnpkCGUA(pdus_ptr, raw_ptr, length);
|
|
case M_CFN:
|
|
return siUnpkCFN(pdus_ptr, raw_ptr, length);
|
|
case M_CON:
|
|
return siUnpkCON(pdus_ptr, raw_ptr, length);
|
|
case M_COT:
|
|
return siUnpkCOT(pdus_ptr, raw_ptr, length);
|
|
case M_FAC:
|
|
return siUnpkFAC(pdus_ptr, raw_ptr, length);
|
|
case M_FAA:
|
|
return siUnpkFAA(pdus_ptr, raw_ptr, length);
|
|
case M_FRJ:
|
|
return siUnpkFRJ(pdus_ptr, raw_ptr, length);
|
|
case M_FAR:
|
|
return siUnpkFAR(pdus_ptr, raw_ptr, length);
|
|
case M_FOT:
|
|
return siUnpkFOT(pdus_ptr, raw_ptr, length);
|
|
case M_IDR:
|
|
return siUnpkIDR(pdus_ptr, raw_ptr, length);
|
|
case M_IRS:
|
|
return siUnpkIRS(pdus_ptr, raw_ptr, length);
|
|
case M_INF:
|
|
return siUnpkINF(pdus_ptr, raw_ptr, length);
|
|
case M_INR:
|
|
return siUnpkINR(pdus_ptr, raw_ptr, length);
|
|
case M_IAM:
|
|
return siUnpkIAM(pdus_ptr, raw_ptr, length);
|
|
case M_NRM:
|
|
return siUnpkNRM(pdus_ptr, raw_ptr, length);
|
|
case M_PAM:
|
|
return siUnpkPAM(pdus_ptr, raw_ptr, length);
|
|
case M_REL:
|
|
return siUnpkREL(pdus_ptr, raw_ptr, length);
|
|
case M_RLC:
|
|
return siUnpkRLC(pdus_ptr, raw_ptr, length);
|
|
case M_RES:
|
|
return siUnpkRES(pdus_ptr, raw_ptr, length);
|
|
case M_SGM:
|
|
return siUnpkSGM(pdus_ptr, raw_ptr, length);
|
|
case M_SAM:
|
|
return siUnpkSAM(pdus_ptr, raw_ptr, length);
|
|
case M_SUS:
|
|
return siUnpkSUS(pdus_ptr, raw_ptr, length);
|
|
case M_UPA:
|
|
return siUnpkUPA(pdus_ptr, raw_ptr, length);
|
|
case M_UPT:
|
|
return siUnpkUPT(pdus_ptr, raw_ptr, length);
|
|
case M_USR:
|
|
return siUnpkUSR(pdus_ptr, raw_ptr, length);
|
|
case M_PRI:
|
|
return siUnpkPRI(pdus_ptr, raw_ptr, length);
|
|
case M_APP:
|
|
return siUnpkAPP(pdus_ptr, raw_ptr, length);
|
|
case M_UBL:
|
|
case M_UBA:
|
|
case M_UCIC:
|
|
case M_BLO:
|
|
case M_BLA:
|
|
case M_RSC:
|
|
case M_OLM:
|
|
case M_LPA:
|
|
case M_CRG:
|
|
return 1;
|
|
default:
|
|
break;
|
|
}
|
|
return -2;//nonsupport
|
|
}
|
|
|
|
static int siSelPkFun_ITU(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case M_ACM:
|
|
return siPkACM(pdus_ptr, raw_ptr);
|
|
case M_ANM:
|
|
return siPkANM(pdus_ptr, raw_ptr);
|
|
case M_CPG:
|
|
return siPkCPG(pdus_ptr, raw_ptr);
|
|
case M_CGB:
|
|
return siPkCGB(pdus_ptr, raw_ptr);
|
|
case M_CGBA:
|
|
return siPkCGBA(pdus_ptr, raw_ptr);
|
|
case M_CQM:
|
|
return siPkCQM(pdus_ptr, raw_ptr);
|
|
case M_CQR:
|
|
return siPkCQR(pdus_ptr, raw_ptr);
|
|
case M_GRS:
|
|
return siPkGRS(pdus_ptr, raw_ptr);
|
|
case M_GRA:
|
|
return siPkGRA(pdus_ptr, raw_ptr);
|
|
case M_CGU:
|
|
return siPkCGU(pdus_ptr, raw_ptr);
|
|
case M_CGUA:
|
|
return siPkCGUA(pdus_ptr, raw_ptr);
|
|
case M_CFN:
|
|
return siPkCFN(pdus_ptr, raw_ptr);
|
|
case M_CON:
|
|
return siPkCON(pdus_ptr, raw_ptr);
|
|
case M_COT:
|
|
return siPkCOT(pdus_ptr, raw_ptr);
|
|
case M_FAC:
|
|
return siPkFAC(pdus_ptr, raw_ptr);
|
|
case M_FAA:
|
|
return siPkFAA(pdus_ptr, raw_ptr);
|
|
case M_FRJ:
|
|
return siPkFRJ(pdus_ptr, raw_ptr);
|
|
case M_FAR:
|
|
return siPkFAR(pdus_ptr, raw_ptr);
|
|
case M_FOT:
|
|
return siPkFOT(pdus_ptr, raw_ptr);
|
|
case M_IDR:
|
|
return siPkIDR(pdus_ptr, raw_ptr);
|
|
case M_IRS:
|
|
return siPkIRS(pdus_ptr, raw_ptr);
|
|
case M_INF:
|
|
return siPkINF(pdus_ptr, raw_ptr);
|
|
case M_INR:
|
|
return siPkINR(pdus_ptr, raw_ptr);
|
|
case M_IAM:
|
|
return siPkIAM(pdus_ptr, raw_ptr);
|
|
case M_NRM:
|
|
return siPkNRM(pdus_ptr, raw_ptr);
|
|
case M_PAM:
|
|
return siPkPAM(pdus_ptr, raw_ptr);
|
|
case M_REL:
|
|
return siPkREL(pdus_ptr, raw_ptr);
|
|
case M_RLC:
|
|
return siPkRLC(pdus_ptr, raw_ptr);
|
|
case M_RES:
|
|
return siPkRES(pdus_ptr, raw_ptr);
|
|
case M_SGM:
|
|
return siPkSGM(pdus_ptr, raw_ptr);
|
|
case M_SAM:
|
|
return siPkSAM(pdus_ptr, raw_ptr);
|
|
case M_SUS:
|
|
return siPkSUS(pdus_ptr, raw_ptr);
|
|
case M_UPA:
|
|
return siPkUPA(pdus_ptr, raw_ptr);
|
|
case M_UPT:
|
|
return siPkUPT(pdus_ptr, raw_ptr);
|
|
case M_USR:
|
|
return siPkUSR(pdus_ptr, raw_ptr);
|
|
case M_PRI:
|
|
return siPkPRI(pdus_ptr, raw_ptr);
|
|
case M_APP:
|
|
return siPkAPP(pdus_ptr, raw_ptr);
|
|
case M_UBL:
|
|
case M_UBA:
|
|
case M_UCIC:
|
|
case M_BLO:
|
|
case M_BLA:
|
|
case M_RSC:
|
|
case M_OLM:
|
|
case M_LPA:
|
|
case M_CRG:
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
static int siSelUnpkFun_ANSI(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length)
|
|
{
|
|
switch(type)
|
|
{
|
|
case M_ACM:
|
|
return siUnpkACM(pdus_ptr, raw_ptr, length);
|
|
case M_ANM:
|
|
return siUnpkANM(pdus_ptr, raw_ptr, length);
|
|
case M_CPG:
|
|
return siUnpkCPG(pdus_ptr, raw_ptr, length);
|
|
case M_CGB:
|
|
return siUnpkCGB(pdus_ptr, raw_ptr, length);
|
|
case M_CGBA:
|
|
return siUnpkCGBA(pdus_ptr, raw_ptr, length);
|
|
case M_CQM:
|
|
return siUnpkCQM(pdus_ptr, raw_ptr, length);
|
|
case M_CQR:
|
|
return siUnpkCQR(pdus_ptr, raw_ptr, length);
|
|
case M_GRS:
|
|
return siUnpkGRS(pdus_ptr, raw_ptr, length);
|
|
case M_GRA:
|
|
return siUnpkGRA(pdus_ptr, raw_ptr, length);
|
|
case M_CGU:
|
|
return siUnpkCGU(pdus_ptr, raw_ptr, length);
|
|
case M_CGUA:
|
|
return siUnpkCGUA(pdus_ptr, raw_ptr, length);
|
|
case M_CFN:
|
|
return siUnpkCFN(pdus_ptr, raw_ptr, length);
|
|
case M_CON:
|
|
return siUnpkCON(pdus_ptr, raw_ptr, length);
|
|
case M_COT:
|
|
return siUnpkCOT(pdus_ptr, raw_ptr, length);
|
|
case M_FAC:
|
|
return siUnpkFAC(pdus_ptr, raw_ptr, length);
|
|
case M_FAA:
|
|
return siUnpkFAA(pdus_ptr, raw_ptr, length);
|
|
case M_FRJ:
|
|
return siUnpkFRJ(pdus_ptr, raw_ptr, length);
|
|
case M_FAR:
|
|
return siUnpkFAR(pdus_ptr, raw_ptr, length);
|
|
case M_FOT:
|
|
return siUnpkFOT(pdus_ptr, raw_ptr, length);
|
|
case M_IDR:
|
|
return siUnpkIDR(pdus_ptr, raw_ptr, length);
|
|
case M_IRS:
|
|
return siUnpkIRS(pdus_ptr, raw_ptr, length);
|
|
case M_INF:
|
|
return siUnpkINF(pdus_ptr, raw_ptr, length);
|
|
case M_INR:
|
|
return siUnpkINR(pdus_ptr, raw_ptr, length);
|
|
case M_IAM:
|
|
return siUnpkIAM_AN(pdus_ptr, raw_ptr, length);
|
|
case M_NRM:
|
|
return siUnpkNRM(pdus_ptr, raw_ptr, length);
|
|
case M_PAM:
|
|
return siUnpkPAM(pdus_ptr, raw_ptr, length);
|
|
case M_REL:
|
|
return siUnpkREL(pdus_ptr, raw_ptr, length);
|
|
case M_RLC:
|
|
return siUnpkRLC(pdus_ptr, raw_ptr, length);
|
|
case M_RES:
|
|
return siUnpkRES(pdus_ptr, raw_ptr, length);
|
|
case M_SGM:
|
|
return siUnpkSGM(pdus_ptr, raw_ptr, length);
|
|
case M_SAM:
|
|
return siUnpkSAM(pdus_ptr, raw_ptr, length);
|
|
case M_SUS:
|
|
return siUnpkSUS(pdus_ptr, raw_ptr, length);
|
|
case M_UPA:
|
|
return siUnpkUPA(pdus_ptr, raw_ptr, length);
|
|
case M_UPT:
|
|
return siUnpkUPT(pdus_ptr, raw_ptr, length);
|
|
case M_USR:
|
|
return siUnpkUSR(pdus_ptr, raw_ptr, length);
|
|
case M_PRI:
|
|
return siUnpkPRI(pdus_ptr, raw_ptr, length);
|
|
case M_CVR://for ansi only
|
|
return siUnpkCVR(pdus_ptr, raw_ptr, length);
|
|
case M_UBL:
|
|
case M_UBA:
|
|
case M_UCIC:
|
|
case M_BLO:
|
|
case M_BLA:
|
|
case M_RSC:
|
|
case M_OLM:
|
|
case M_LPA:
|
|
case M_CRG:
|
|
case M_CVT://only for ansi
|
|
return 1;
|
|
default:
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
static int siSelPkFun_ANSI(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case M_ACM:
|
|
return siPkACM(pdus_ptr, raw_ptr);
|
|
case M_ANM:
|
|
return siPkANM(pdus_ptr, raw_ptr);
|
|
case M_CPG:
|
|
return siPkCPG(pdus_ptr, raw_ptr);
|
|
case M_CGB:
|
|
return siPkCGB(pdus_ptr, raw_ptr);
|
|
case M_CGBA:
|
|
return siPkCGBA(pdus_ptr, raw_ptr);
|
|
case M_CQM:
|
|
return siPkCQM(pdus_ptr, raw_ptr);
|
|
case M_CQR:
|
|
return siPkCQR(pdus_ptr, raw_ptr);
|
|
case M_GRS:
|
|
return siPkGRS(pdus_ptr, raw_ptr);
|
|
case M_GRA:
|
|
return siPkGRA(pdus_ptr, raw_ptr);
|
|
case M_CGU:
|
|
return siPkCGU(pdus_ptr, raw_ptr);
|
|
case M_CGUA:
|
|
return siPkCGUA(pdus_ptr, raw_ptr);
|
|
case M_CFN:
|
|
return siPkCFN(pdus_ptr, raw_ptr);
|
|
case M_CON:
|
|
return siPkCON(pdus_ptr, raw_ptr);
|
|
case M_COT:
|
|
return siPkCOT(pdus_ptr, raw_ptr);
|
|
case M_FAC:
|
|
return siPkFAC(pdus_ptr, raw_ptr);
|
|
case M_FAA:
|
|
return siPkFAA(pdus_ptr, raw_ptr);
|
|
case M_FRJ:
|
|
return siPkFRJ(pdus_ptr, raw_ptr);
|
|
case M_FAR:
|
|
return siPkFAR(pdus_ptr, raw_ptr);
|
|
case M_FOT:
|
|
return siPkFOT(pdus_ptr, raw_ptr);
|
|
case M_IDR:
|
|
return siPkIDR(pdus_ptr, raw_ptr);
|
|
case M_IRS:
|
|
return siPkIRS(pdus_ptr, raw_ptr);
|
|
case M_INF:
|
|
return siPkINF(pdus_ptr, raw_ptr);
|
|
case M_INR:
|
|
return siPkINR(pdus_ptr, raw_ptr);
|
|
case M_IAM:
|
|
return siPkIAM_AN(pdus_ptr, raw_ptr);
|
|
case M_NRM:
|
|
return siPkNRM(pdus_ptr, raw_ptr);
|
|
case M_PAM:
|
|
return siPkPAM(pdus_ptr, raw_ptr);
|
|
case M_REL:
|
|
return siPkREL(pdus_ptr, raw_ptr);
|
|
case M_RLC:
|
|
return siPkRLC(pdus_ptr, raw_ptr);
|
|
case M_RES:
|
|
return siPkRES(pdus_ptr, raw_ptr);
|
|
case M_SGM:
|
|
return siPkSGM(pdus_ptr, raw_ptr);
|
|
case M_SAM:
|
|
return siPkSAM(pdus_ptr, raw_ptr);
|
|
case M_SUS:
|
|
return siPkSUS(pdus_ptr, raw_ptr);
|
|
case M_UPA:
|
|
return siPkUPA(pdus_ptr, raw_ptr);
|
|
case M_UPT:
|
|
return siPkUPT(pdus_ptr, raw_ptr);
|
|
case M_USR:
|
|
return siPkUSR(pdus_ptr, raw_ptr);
|
|
case M_PRI:
|
|
return siPkPRI(pdus_ptr, raw_ptr);
|
|
case M_CVR:
|
|
return siPkCVR(pdus_ptr, raw_ptr);
|
|
case M_UBL:
|
|
case M_UBA:
|
|
case M_UCIC:
|
|
case M_BLO:
|
|
case M_BLA:
|
|
case M_RSC:
|
|
case M_OLM:
|
|
case M_LPA:
|
|
case M_CRG:
|
|
case M_CVT://only for ansi
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int siSelUnpkFun(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length, u8 variant)
|
|
{
|
|
switch(variant)
|
|
{
|
|
case VARIANT_ITU:
|
|
case VARIANT_ETSI:
|
|
case VARIANT_UK:
|
|
return siSelUnpkFun_ITU(pdus_ptr, raw_ptr, type, length);
|
|
case VARIANT_ANSI:
|
|
return siSelUnpkFun_ANSI(pdus_ptr, raw_ptr, type, length);
|
|
default:
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
int siSelPkFun(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type,u8 variant)
|
|
{
|
|
switch(variant)
|
|
{
|
|
case VARIANT_ETSI:
|
|
case VARIANT_UK:
|
|
case VARIANT_ITU:
|
|
return siSelPkFun_ITU(pdus_ptr, raw_ptr, type);
|
|
case VARIANT_ANSI:
|
|
return siSelPkFun_ANSI(pdus_ptr, raw_ptr, type);
|
|
default:
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//static int siSelUnpkFun_ETSI(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length)
|
|
//{
|
|
// return -1;
|
|
//}
|
|
//
|
|
//static int siSelPkFun_ETSI(SiAllPdus *pdus_ptr, u8 *raw_ptr, int type)
|
|
//{
|
|
// return -1;
|
|
//}
|
|
//
|
|
//static int siSelUnpkFun_UK(SiAllPdus *pdus_ptr, u8 *raw_ptr, u8 type, int length)
|
|
//{
|
|
// return -1;
|
|
//}
|
|
//
|
|
//static int siSelPkFun_UK(SiAllPdus *pdus_ptr, u8 *raw_ptr, int type)
|
|
//{
|
|
// return -1;
|
|
//}
|
|
|
|
void isup_send_cvr(u32 pid)
|
|
{
|
|
SiPduCVR *ptr = &(isup_sd_pdus.m.cirValRsp);
|
|
|
|
memset(ptr,0,sizeof(SiPduCVR));
|
|
ptr->valRspInd.cirValRspInd = 0; //0=successful,1=failure
|
|
ptr->grpCharInd.cirGrpCarInd = 2;
|
|
ptr->grpCharInd.dblSzCtrlInd = 3;
|
|
ptr->grpCharInd.alarmCarInd = 1;
|
|
ptr->grpCharInd.contChkReqInd = 1;
|
|
isup_send_msg(pid,M_CVR);
|
|
}
|
|
|