689 lines
23 KiB
C
689 lines
23 KiB
C
/*
|
|
** CDMA 2000 project, SMPP module
|
|
**
|
|
** File name: smpp_test.c
|
|
** Written by Li Long at 2004-11-25
|
|
** CVS $Id: smpp_test.c,v0.1 2004/11/25 17:03:14 lilong Exp $
|
|
**
|
|
*/
|
|
|
|
#include "./include/smpp.h"
|
|
|
|
#define SD_PKT_NUM 10
|
|
#define STORE_MSG_ITEM 5
|
|
|
|
typedef struct SMPP_MSG_STORE_STRUCT
|
|
{
|
|
BYTE short_message[SMPP_MSG_LEN];
|
|
BYTE message_id[65];
|
|
} SMPP_MSG_STORE_STRUCT;
|
|
|
|
typedef struct SMPP_LINK_ATTRIBUTE
|
|
{
|
|
BYTE enable;
|
|
BYTE session_type; //BIND_TX/BIND_RX/BIND_TRX
|
|
BYTE message_mode; //STORE AND FORWARD/DATAGRAM/TRANSACTION
|
|
BYTE terminal_type; //SMPP_CLIENT/SMPP_SERVER
|
|
} SMPP_LINK_ATTRIBUTE;
|
|
static struct itimerval itimer,old_itimer;
|
|
static int timer_counter[MAX_SMPP_LINK];
|
|
static int stateFlag[MAX_SMPP_LINK];
|
|
static int msg_count[MAX_SMPP_LINK];
|
|
static int msg_pointer[MAX_SMPP_LINK];
|
|
static SMPP_MSG_STORE_STRUCT store_msg_buf[MAX_SMPP_LINK][STORE_MSG_ITEM];
|
|
static SMPP_LINK_ATTRIBUTE smpp_link_attr[MAX_SMPP_LINK];
|
|
|
|
static void On_Timer();
|
|
static void SetTimer();
|
|
static void smpp_test_init();
|
|
static void sendTestSM(int, int);
|
|
static int smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pData, WORD dataLen);
|
|
static int smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate);
|
|
|
|
void smpp_test_init()
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<MAX_SMPP_LINK; i++)
|
|
{
|
|
memset(store_msg_buf[i], 0, sizeof(SMPP_MSG_STORE_STRUCT)*STORE_MSG_ITEM);
|
|
msg_pointer[i] = 0;
|
|
}
|
|
}
|
|
|
|
int main(int argc,char *argv[])
|
|
{
|
|
pid_t pid;
|
|
int i, ch;
|
|
BYTE link, ret;
|
|
unsigned char tx_service_number[8], rx_service_number[8];
|
|
unsigned char store_and_forward_service_number[8];
|
|
|
|
heartbeat_init(0xFFFF);
|
|
// #ifdef SMPP_DEBUG
|
|
debug_init();
|
|
// #endif
|
|
iptrMainInit();
|
|
snmp_init(SMPP_PORT);
|
|
mtp_shm_init();
|
|
sccp_init();
|
|
|
|
smpp_init_new();
|
|
smpp_test_init();
|
|
|
|
for (i=0; i<MAX_SMPP_LINK; i++)
|
|
{
|
|
stateFlag[i] = FALSE;
|
|
timer_counter[i]= 0;
|
|
msg_count[i] = 0;
|
|
}
|
|
|
|
opterr = 0;
|
|
strcpy(tx_service_number, "9910");
|
|
strcpy(rx_service_number, "9920");
|
|
strcpy(store_and_forward_service_number, "6666");
|
|
while( (ch = getopt(argc, argv, "scabd")) != -1 )
|
|
{
|
|
switch (ch)
|
|
{
|
|
case 's':
|
|
ret = smpp_registerLink(SMPP_SERVER, BIND_TX, tx_service_number, DATAGRAM);
|
|
if ((ret&0x80) == 0x80) {
|
|
link = ret&0x7f;
|
|
printf("(TX) session_type = %d, linkNo=%d\n", BIND_TX, link);
|
|
smpp_attach_link(link, smpp_onDataRecv, smpp_onLinkStateChange);
|
|
|
|
smpp_link_attr[link].enable = 1;
|
|
smpp_link_attr[link].session_type = BIND_TX;
|
|
smpp_link_attr[link].message_mode = DATAGRAM;
|
|
smpp_link_attr[link].terminal_type = SMPP_SERVER;
|
|
}
|
|
break;
|
|
case 'c':
|
|
ret = smpp_registerLink(SMPP_CLIENT, BIND_TX, tx_service_number, DATAGRAM);
|
|
if ((ret&0x80) == 0x80) {
|
|
link = ret&0x7f;
|
|
printf("(TX) session_type = %d, linkNo=%d\n", BIND_TX, link);
|
|
smpp_attach_link(link, smpp_onDataRecv, smpp_onLinkStateChange);
|
|
|
|
smpp_link_attr[link].enable = 1;
|
|
smpp_link_attr[link].session_type = BIND_TX;
|
|
smpp_link_attr[link].message_mode = DATAGRAM;
|
|
smpp_link_attr[link].terminal_type = SMPP_CLIENT;
|
|
}
|
|
break;
|
|
case 'a':
|
|
ret = smpp_registerLink(SMPP_CLIENT, BIND_RX, rx_service_number, DATAGRAM);
|
|
if ((ret&0x80) == 0x80) {
|
|
link = ret&0x7f;
|
|
printf("(RX) session_type = %d, linkNo=%d\n", BIND_RX, link);
|
|
smpp_attach_link(link, smpp_onDataRecv, smpp_onLinkStateChange);
|
|
|
|
smpp_link_attr[link].enable = 1;
|
|
smpp_link_attr[link].session_type = BIND_RX;
|
|
smpp_link_attr[link].message_mode = DATAGRAM;
|
|
smpp_link_attr[link].terminal_type = SMPP_CLIENT;
|
|
}
|
|
break;
|
|
case 'b':
|
|
ret = smpp_registerLink(SMPP_SERVER, BIND_RX, rx_service_number, DATAGRAM);
|
|
if ((ret&0x80) == 0x80) {
|
|
link = ret&0x7f;
|
|
printf("(RX) session_type = %d, linkNo=%d\n", BIND_RX, link);
|
|
smpp_attach_link(link, smpp_onDataRecv, smpp_onLinkStateChange);
|
|
|
|
smpp_link_attr[link].enable = 1;
|
|
smpp_link_attr[link].session_type = BIND_RX;
|
|
smpp_link_attr[link].message_mode = DATAGRAM;
|
|
smpp_link_attr[link].terminal_type = SMPP_SERVER;
|
|
}
|
|
break;
|
|
case 'd':
|
|
if ((pid=fork())!=0) exit(0);
|
|
setsid();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetTimer();
|
|
while(1)
|
|
{
|
|
usleep(50);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void On_Timer()
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<MAX_SMPP_LINK; i++)
|
|
{ // 2 msgs per second
|
|
if (timer_counter[i]==25)
|
|
timer_counter[i]=0;
|
|
if ((timer_counter[i]%25)==0)
|
|
{
|
|
if (stateFlag[i] == TRUE)
|
|
{
|
|
if ( (smpp_link_attr[i].session_type == BIND_TX) && (smpp_link_attr[i].terminal_type == SMPP_CLIENT) )
|
|
{
|
|
sendTestSM(i, 0);
|
|
msg_count[i]++;
|
|
}
|
|
if ( (smpp_link_attr[i].session_type == BIND_RX) && (smpp_link_attr[i].terminal_type == SMPP_SERVER) )
|
|
{
|
|
sendTestSM(i, 1);
|
|
msg_count[i]++;
|
|
}
|
|
if (smpp_link_attr[i].session_type == BIND_TRX)
|
|
{
|
|
sendTestSM(i, 2);
|
|
msg_count[i]++;
|
|
}
|
|
}
|
|
}
|
|
timer_counter[i]++;
|
|
|
|
if (msg_count[i] == SD_PKT_NUM)
|
|
{
|
|
smpp_close(i);
|
|
}
|
|
}
|
|
|
|
iptrans_timer();
|
|
// #ifdef SMPP_DEBUG
|
|
debug_rt();
|
|
// #endif //end ifdef SMPP_DEBUG
|
|
snmp_timer();
|
|
mtp3_proc();
|
|
heartbeat_timer();
|
|
sccp_timer();
|
|
|
|
smpp_fsm();
|
|
}
|
|
|
|
void SetTimer()
|
|
{
|
|
struct sigaction act;
|
|
act.sa_handler=On_Timer;
|
|
sigemptyset(&act.sa_mask);
|
|
act.sa_flags=0;
|
|
if(sigaction(SIGALRM,&act,NULL)<0)
|
|
{
|
|
perror("Produce Sigaction");
|
|
exit(1);
|
|
}
|
|
|
|
itimer.it_interval.tv_sec=0;
|
|
itimer.it_interval.tv_usec=20*1000;
|
|
itimer.it_value.tv_sec=0;
|
|
itimer.it_value.tv_usec=20*1000;
|
|
|
|
if (setitimer(ITIMER_REAL,&itimer,&old_itimer) !=0 )
|
|
{
|
|
printf("Setting Timer error! \n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
int smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pMsg, WORD dataLen)
|
|
{
|
|
int sequence_number=100;
|
|
SMPP_MSG smpp_msg;
|
|
int pointer;
|
|
int i;
|
|
|
|
switch (pMsg->message_type)
|
|
{
|
|
case 0x0B: /* SUBMIT SM */
|
|
printf("[TEST PROGRAM]Link %d received SUBMIT SM:\n", linkNo);
|
|
|
|
/* store smpp message */
|
|
if (smpp_link_attr[linkNo].message_mode == STORE_AND_FORWARD)
|
|
{
|
|
//if (pMsg->pdu.submit_sm.sm_length < SMPP_MSG_LEN)
|
|
{
|
|
pointer = (msg_pointer[linkNo]+1)%STORE_MSG_ITEM;
|
|
memcpy(&store_msg_buf[linkNo][pointer].short_message,
|
|
pMsg->pdu.submit_sm.short_message, pMsg->pdu.submit_sm.sm_length);
|
|
sprintf(store_msg_buf[linkNo][pointer].message_id,
|
|
"%ld", pMsg->pdu.submit_sm.head.sequence_number);
|
|
}
|
|
}
|
|
|
|
/* fill with SUBMIT SM RESP structure. */
|
|
smpp_msg.message_type = 0x0C;
|
|
smpp_msg.pdu.submit_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
smpp_msg.pdu.submit_sm_resp.head.sequence_number = pMsg->pdu.submit_sm.head.sequence_number;
|
|
sprintf(smpp_msg.pdu.submit_sm_resp.message_id, "%ld",
|
|
smpp_msg.pdu.submit_sm_resp.head.sequence_number);
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x0C: /* SUBMIT SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received SUBMIT SM RESP.\n", linkNo);
|
|
break;
|
|
case 0x0D: /* SUBMIT MULTI */
|
|
printf("[TEST PROGRAM]Link %d received SUBMIT MULTI.\n", linkNo);
|
|
/* store smpp message */
|
|
if (smpp_link_attr[linkNo].message_mode == STORE_AND_FORWARD)
|
|
{
|
|
//if (pMsg->pdu.submit_multi.sm_length < SMPP_MSG_LEN)
|
|
{
|
|
pointer = (msg_pointer[linkNo]+1)%STORE_MSG_ITEM;
|
|
memcpy(&store_msg_buf[linkNo][pointer].short_message,
|
|
pMsg->pdu.submit_sm.short_message, pMsg->pdu.submit_multi.sm_length);
|
|
sprintf(store_msg_buf[linkNo][pointer].message_id,
|
|
"%ld", pMsg->pdu.submit_multi.head.sequence_number);
|
|
}
|
|
}
|
|
|
|
/* fill with SUBMIT MULTI RESP structure. */
|
|
smpp_msg.message_type = 0x0E;
|
|
smpp_msg.pdu.submit_multi_resp.head.command_status = htonl(ESME_ROK);
|
|
smpp_msg.pdu.submit_multi_resp.head.sequence_number = pMsg->pdu.submit_multi.head.sequence_number;
|
|
sprintf(smpp_msg.pdu.submit_multi_resp.message_id, "%ld",
|
|
smpp_msg.pdu.submit_multi_resp.head.sequence_number);
|
|
smpp_msg.pdu.submit_multi_resp.no_unsuccess = 0;
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x0E: /* SUBMIT MULTI RESP */
|
|
printf("[TEST PROGRAM]Link %d received SUBMIT MULTI RESP.\n", linkNo);
|
|
break;
|
|
case 0x0F: /* DELIVER SM */
|
|
printf("[TEST PROGRAM]Link %d received DELIVER SM.\n", linkNo);
|
|
|
|
/* store smpp message */
|
|
if (smpp_link_attr[linkNo].message_mode == STORE_AND_FORWARD)
|
|
{
|
|
//if (pMsg->pdu.deliver_sm.sm_length < SMPP_MSG_LEN)
|
|
{
|
|
pointer = (msg_pointer[linkNo]+1)%STORE_MSG_ITEM;
|
|
memcpy(&store_msg_buf[linkNo][pointer].short_message,
|
|
pMsg->pdu.deliver_sm.short_message, pMsg->pdu.deliver_sm.sm_length);
|
|
sprintf(store_msg_buf[linkNo][pointer].message_id,
|
|
"%ld", pMsg->pdu.deliver_sm.head.sequence_number);
|
|
}
|
|
}
|
|
|
|
/* fill with DELIVER SM RESP structure. */
|
|
smpp_msg.message_type = 0x10;
|
|
smpp_msg.pdu.deliver_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
smpp_msg.pdu.deliver_sm_resp.head.sequence_number = pMsg->pdu.deliver_sm.head.sequence_number;
|
|
smpp_msg.pdu.deliver_sm_resp.message_id = 0x0;
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x10: /* DELIVER SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received DELIVER SM RESP.\n", linkNo);
|
|
break;
|
|
case 0x11: /* DATA SM */
|
|
printf("[TEST PROGRAM]Link %d received DATA SM.\n", linkNo);
|
|
|
|
/* store smpp message */
|
|
if (smpp_link_attr[linkNo].message_mode == STORE_AND_FORWARD)
|
|
{
|
|
if (strlen(pMsg->pdu.data_sm.message_payload) < SMPP_MSG_LEN)
|
|
{
|
|
pointer = (msg_pointer[linkNo]+1)%STORE_MSG_ITEM;
|
|
memcpy(&store_msg_buf[linkNo][pointer].short_message,
|
|
pMsg->pdu.data_sm.message_payload, strlen(pMsg->pdu.data_sm.message_payload));
|
|
sprintf(store_msg_buf[linkNo][pointer].message_id,
|
|
"%ld", pMsg->pdu.data_sm.head.sequence_number);
|
|
}
|
|
}
|
|
|
|
/* fill with DATA SM RESP structure. */
|
|
smpp_msg.message_type = 0x12;
|
|
smpp_msg.pdu.data_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
smpp_msg.pdu.data_sm_resp.head.sequence_number = pMsg->pdu.data_sm.head.sequence_number;
|
|
sprintf(smpp_msg.pdu.data_sm_resp.message_id, "%ld",
|
|
smpp_msg.pdu.data_sm_resp.head.sequence_number);
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x12: /* DATA SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received DATA SM RESP.\n", linkNo);
|
|
break;
|
|
case 0x13: /* QUERY SM */
|
|
printf("[TEST PROGRAM]Link %d received QUERY SM.\n", linkNo);
|
|
|
|
pointer = -1;
|
|
for (i=0; i<STORE_MSG_ITEM; i++)
|
|
{
|
|
if (strcmp(store_msg_buf[linkNo][i].message_id, pMsg->pdu.query_sm.message_id) == 0)
|
|
{
|
|
pointer = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* fill with QUERY SM RESP structure */
|
|
smpp_msg.message_type = 0x14;
|
|
smpp_msg.pdu.query_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
smpp_msg.pdu.query_sm_resp.head.sequence_number = pMsg->pdu.query_sm.head.sequence_number;
|
|
sprintf(smpp_msg.pdu.query_sm_resp.message_id, "%ld",
|
|
smpp_msg.pdu.query_sm_resp.head.sequence_number);
|
|
smpp_msg.pdu.query_sm_resp.final_date[0] = 0x0;
|
|
if (pointer == -1)
|
|
{
|
|
smpp_msg.pdu.query_sm_resp.message_state = 0x04;
|
|
}
|
|
else
|
|
{
|
|
smpp_msg.pdu.query_sm_resp.message_state = 0x02;
|
|
}
|
|
|
|
smpp_msg.pdu.query_sm_resp.error_code = 0x0;
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x14: /* QUERY SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received QUERY SM RESP.\n", linkNo);
|
|
break;
|
|
case 0x15: /* CANCEL SM */
|
|
printf("[TEST PROGRAM]Link %d received CANCEL SM RESP.\n", linkNo);
|
|
pointer = -1;
|
|
if (pMsg->pdu.cancel_sm.message_id[0] == 0){
|
|
memset(store_msg_buf[linkNo], 0, sizeof(SMPP_MSG_STORE_STRUCT)*STORE_MSG_ITEM);
|
|
msg_pointer[linkNo] = 0;
|
|
smpp_msg.pdu.cancel_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
}else{
|
|
for (i=0; i<STORE_MSG_ITEM; i++)
|
|
{
|
|
printf("[TEST program]message id in query sm=%s, message id in store message=%s",
|
|
pMsg->pdu.cancel_sm.message_id, store_msg_buf[linkNo][i].message_id);
|
|
if (strcmp(store_msg_buf[linkNo][i].message_id, pMsg->pdu.cancel_sm.message_id) == 0)
|
|
{
|
|
pointer = i;
|
|
break;
|
|
}
|
|
}
|
|
if (pointer == -1)
|
|
{
|
|
smpp_msg.pdu.cancel_sm_resp.head.command_status = htonl(ESME_RCANCELFAIL);
|
|
}else{
|
|
smpp_msg.pdu.cancel_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
}
|
|
}
|
|
|
|
/* fill with CANCEL SM RESP structure */
|
|
smpp_msg.message_type = 0x16;
|
|
smpp_msg.pdu.cancel_sm_resp.head.sequence_number = pMsg->pdu.cancel_sm.head.sequence_number;
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x16: /* CANCEL SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received CANCEL RESP.\n", linkNo);
|
|
break;
|
|
case 0x17: /* REPLACE SM */
|
|
printf("[TEST PROGRAM]Link %d received REPLACE SM.\n", linkNo);
|
|
pointer = -1;
|
|
for (i=0; i<STORE_MSG_ITEM; i++)
|
|
{
|
|
if (strcmp(store_msg_buf[linkNo][i].message_id, pMsg->pdu.replace_sm.message_id) == 0)
|
|
{
|
|
pointer = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* store new smpp message */
|
|
if (pointer != -1)
|
|
{
|
|
//if (pMsg->pdu.replace_sm.sm_length < SMPP_MSG_LEN)
|
|
{
|
|
memcpy(&store_msg_buf[linkNo][pointer].short_message,
|
|
pMsg->pdu.replace_sm.short_message, pMsg->pdu.replace_sm.sm_length);
|
|
}
|
|
}
|
|
|
|
/* fill with REPLACE SM RESP structure */
|
|
smpp_msg.message_type = 0x18;
|
|
if (pointer == -1)
|
|
{
|
|
smpp_msg.pdu.replace_sm_resp.head.command_status = htonl(ESME_RREPLACEFAIL);
|
|
}
|
|
else
|
|
{
|
|
smpp_msg.pdu.replace_sm_resp.head.command_status = htonl(ESME_ROK);
|
|
}
|
|
smpp_msg.pdu.replace_sm_resp.head.sequence_number = pMsg->pdu.replace_sm.head.sequence_number;
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
break;
|
|
case 0x18: /* REPLACE SM RESP */
|
|
printf("[TEST PROGRAM]Link %d received REPLACE SM RESP.\n", linkNo);
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
return sequence_number;
|
|
}
|
|
|
|
int smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate)
|
|
{
|
|
printf("[TEST PROGRAM]link %d state change to %d\n",linkNo, linkstate);
|
|
if (linkstate == 1)
|
|
stateFlag[linkNo] = TRUE;
|
|
else
|
|
stateFlag[linkNo] = FALSE;
|
|
|
|
return linkNo;
|
|
}
|
|
|
|
//0-submit_sm, 1-deliver_sm, 2-data_sm
|
|
void sendTestSM(int linkNo, int msg_type)
|
|
{
|
|
SMPP_MSG smpp_msg;
|
|
WORD dataLen;
|
|
|
|
memset(&smpp_msg, 0, sizeof(SMPP_MSG));
|
|
switch (msg_type)
|
|
{
|
|
case 0: //send submit sm
|
|
smpp_msg.message_type = 0x0B;
|
|
smpp_msg.optional_param_flag1 = 0x0FF67FFF;
|
|
smpp_msg.optional_param_flag2 = 0x0;
|
|
|
|
//Mandatory parameters.
|
|
strcpy(smpp_msg.pdu.submit_sm.service_type, "USSD");
|
|
smpp_msg.pdu.submit_sm.source_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.submit_sm.source_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.submit_sm.source_addr, "172.18.166.1");
|
|
smpp_msg.pdu.submit_sm.dest_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.submit_sm.dest_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.submit_sm.destination_addr, "13923482085");
|
|
smpp_msg.pdu.submit_sm.esm_class = 0x00;
|
|
smpp_msg.pdu.submit_sm.protocol_id = 0x0;
|
|
smpp_msg.pdu.submit_sm.priority_flag = 0x3;
|
|
strcpy(smpp_msg.pdu.submit_sm.schedule_delivery_time, "041231151200000R");
|
|
strcpy(smpp_msg.pdu.submit_sm.validity_period, "041231151200000+");
|
|
smpp_msg.pdu.submit_sm.registered_delivery = 0x11;
|
|
smpp_msg.pdu.submit_sm.replace_if_present_flag = 0x01;
|
|
smpp_msg.pdu.submit_sm.data_coding = 0x07;
|
|
smpp_msg.pdu.submit_sm.sm_default_msg_id = 0x01;
|
|
smpp_msg.pdu.submit_sm.sm_length = 0x0;
|
|
strcpy(smpp_msg.pdu.submit_sm.short_message, "");
|
|
//Optional parameters.
|
|
smpp_msg.pdu.submit_sm.user_message_reference = 0x00;
|
|
smpp_msg.pdu.submit_sm.source_port = 0x6666;
|
|
smpp_msg.pdu.submit_sm.source_addr_subunit = 0x01;
|
|
smpp_msg.pdu.submit_sm.destination_port = 0x8888;
|
|
smpp_msg.pdu.submit_sm.dest_addr_subunit = 0x02;
|
|
smpp_msg.pdu.submit_sm.sar_msg_ref_num = 0x7700;
|
|
smpp_msg.pdu.submit_sm.sar_total_segments = 0x01;
|
|
smpp_msg.pdu.submit_sm.sar_segment_seqnum = 0x01;
|
|
smpp_msg.pdu.submit_sm.more_messages_to_send = 0x01;
|
|
smpp_msg.pdu.submit_sm.payload_type = 0x00;
|
|
strcpy(smpp_msg.pdu.submit_sm.message_payload, "messae in submit sm optional");
|
|
smpp_msg.pdu.submit_sm.privacy_indicator = 0x03;
|
|
|
|
//strcpy(smpp_msg.pdu.submit_sm.callback_num, "F0453245");
|
|
smpp_msg.pdu.submit_sm.callback_num[0] = 0x01; //ASCII
|
|
smpp_msg.pdu.submit_sm.callback_num[1] = 0x02; //National
|
|
smpp_msg.pdu.submit_sm.callback_num[2] = 0x03; //Data
|
|
strcpy(smpp_msg.pdu.submit_sm.callback_num+3, "F0453245");
|
|
smpp_msg.pdu.submit_sm.callback_num_pres_ind = 0x06;
|
|
strcpy(smpp_msg.pdu.submit_sm.callback_num_atag, "callback_num_atag");
|
|
//strcpy(smpp_msg.pdu.submit_sm.source_subaddress, "123");
|
|
//smpp_msg.pdu.submit_sm.source_subaddress[0] = 0x88;
|
|
//strcpy(smpp_msg.pdu.submit_sm.source_subaddress+1,"123");
|
|
|
|
//smpp_msg.pdu.submit_sm.dest_subaddress[0] = 0x88;
|
|
//strcpy(smpp_msg.pdu.submit_sm.dest_subaddress+1, "789");
|
|
smpp_msg.pdu.submit_sm.user_response_code = 0x03;
|
|
smpp_msg.pdu.submit_sm.display_time = 0x02;
|
|
//smpp_msg.pdu.submit_sm.sms_signal = 0x03;
|
|
|
|
smpp_msg.pdu.submit_sm.ms_validity = 0x03;
|
|
smpp_msg.pdu.submit_sm.ms_msg_wait_facilities = 0x03;
|
|
smpp_msg.pdu.submit_sm.number_of_messages = 0x03;
|
|
smpp_msg.pdu.submit_sm.alert_on_message_delivery = 0x03;
|
|
|
|
smpp_msg.pdu.submit_sm.language_indicator = 0x01;
|
|
smpp_msg.pdu.submit_sm.its_reply_type = 0x03;
|
|
smpp_msg.pdu.submit_sm.its_session_info[0] = 0x01;
|
|
smpp_msg.pdu.submit_sm.its_session_info[1] = 0x53;
|
|
smpp_msg.pdu.submit_sm.ussd_service_op = 0x03;
|
|
|
|
break;
|
|
case 1: //send deliver sm
|
|
smpp_msg.message_type = 0x0F;
|
|
smpp_msg.optional_param_flag1 = 0x000167FF;
|
|
smpp_msg.optional_param_flag2 = 0x0;
|
|
|
|
//Mandatory parameters.
|
|
strcpy(smpp_msg.pdu.deliver_sm.service_type, "USSD");
|
|
smpp_msg.pdu.deliver_sm.source_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.deliver_sm.source_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.deliver_sm.source_addr, "172.18.166.1");
|
|
smpp_msg.pdu.deliver_sm.dest_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.deliver_sm.dest_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.deliver_sm.destination_addr, "13923482085");
|
|
smpp_msg.pdu.deliver_sm.esm_class = 0x00;
|
|
smpp_msg.pdu.deliver_sm.protocol_id = 0x0;
|
|
smpp_msg.pdu.deliver_sm.priority_flag = 0x3;
|
|
smpp_msg.pdu.deliver_sm.schedule_delivery_time = 0x0;
|
|
smpp_msg.pdu.deliver_sm.validity_period = 0x0;
|
|
smpp_msg.pdu.deliver_sm.registered_delivery = 0x12;
|
|
smpp_msg.pdu.deliver_sm.replace_if_present_flag = 0x01;
|
|
smpp_msg.pdu.deliver_sm.data_coding = 0x07;
|
|
smpp_msg.pdu.deliver_sm.sm_default_msg_id = 0x01;
|
|
smpp_msg.pdu.deliver_sm.sm_length = 0x0;
|
|
strcpy(smpp_msg.pdu.deliver_sm.short_message, "");
|
|
|
|
//Optional parameters.
|
|
smpp_msg.pdu.deliver_sm.user_message_reference = 0x00;
|
|
smpp_msg.pdu.deliver_sm.source_port = 0x6666;
|
|
smpp_msg.pdu.deliver_sm.destination_port = 0x8888;
|
|
smpp_msg.pdu.deliver_sm.sar_msg_ref_num = 0x7700;
|
|
|
|
smpp_msg.pdu.deliver_sm.sar_total_segments = 0x01;
|
|
smpp_msg.pdu.deliver_sm.sar_segment_seqnum = 0x01;
|
|
smpp_msg.pdu.deliver_sm.user_response_code = 0x03;
|
|
smpp_msg.pdu.deliver_sm.privacy_indicator = 0x03;
|
|
|
|
smpp_msg.pdu.deliver_sm.payload_type = 0x00;
|
|
strcpy(smpp_msg.pdu.deliver_sm.message_payload, "messae in deliver sm optional");
|
|
smpp_msg.pdu.deliver_sm.callback_num[0] = 0x01; //ASCII
|
|
smpp_msg.pdu.deliver_sm.callback_num[1] = 0x02; //National
|
|
smpp_msg.pdu.deliver_sm.callback_num[2] = 0x03; //Data
|
|
strcpy(smpp_msg.pdu.deliver_sm.callback_num+3, "F0453245");
|
|
//smpp_msg.pdu.deliver_sm.source_subaddress[0] = 0xA0;
|
|
//smpp_msg.pdu.deliver_sm.source_subaddress[1] = 0x01;
|
|
//strcpy(smpp_msg.pdu.deliver_sm.source_subaddress+1, "123");
|
|
|
|
//smpp_msg.pdu.deliver_sm.dest_subaddress[0] = 0xA0;
|
|
//smpp_msg.pdu.deliver_sm.dest_subaddress[1] = 0x01;
|
|
//strcpy(smpp_msg.pdu.deliver_sm.dest_subaddress+1, "321");
|
|
smpp_msg.pdu.deliver_sm.language_indicator = 0x01;
|
|
smpp_msg.pdu.deliver_sm.its_session_info[0] = 0x01;
|
|
smpp_msg.pdu.deliver_sm.its_session_info[1] = 0x53;
|
|
//smpp_msg.pdu.deliver_sm.network_error_code[0] = 0x03;
|
|
//smpp_msg.pdu.deliver_sm.network_error_code[1] = 0x03;
|
|
//smpp_msg.pdu.deliver_sm.network_error_code[2] = 0x00;
|
|
|
|
smpp_msg.pdu.deliver_sm.message_state = 0x01;
|
|
//strcpy(smpp_msg.pdu.deliver_sm.receipted_message_id, "receipted message id in deliver sm");
|
|
break;
|
|
case 2: //data_sm
|
|
smpp_msg.message_type = 0x11;
|
|
smpp_msg.optional_param_flag1 = 0xB3EBFFFF;
|
|
smpp_msg.optional_param_flag2 = 0x0000003F;
|
|
//smpp_msg.optional_param_flag1 = 0x0C000000;
|
|
//smpp_msg.optional_param_flag2 = 0x0;
|
|
|
|
//Mandatory parameters.
|
|
strcpy(smpp_msg.pdu.data_sm.service_type, "USSD");
|
|
smpp_msg.pdu.data_sm.source_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.data_sm.source_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.data_sm.source_addr, "172.18.166.1");
|
|
smpp_msg.pdu.data_sm.dest_addr_ton = 0x2; //National
|
|
smpp_msg.pdu.data_sm.dest_addr_npi = 0x1; //ISDN
|
|
strcpy(smpp_msg.pdu.data_sm.destination_addr, "13923482085");
|
|
smpp_msg.pdu.data_sm.esm_class = 0x00;
|
|
smpp_msg.pdu.data_sm.registered_delivery = 0x11;
|
|
smpp_msg.pdu.data_sm.data_coding = 0x07;
|
|
|
|
//Optional parameters.
|
|
smpp_msg.pdu.data_sm.source_port = 0x6666;
|
|
smpp_msg.pdu.data_sm.source_addr_subunit = 0x01;
|
|
smpp_msg.pdu.data_sm.source_network_type = 0x01;
|
|
smpp_msg.pdu.data_sm.source_bearer_type = 0x03;
|
|
|
|
smpp_msg.pdu.data_sm.source_telematics_id = 0x0003;
|
|
smpp_msg.pdu.data_sm.destination_port = 0x8888;
|
|
smpp_msg.pdu.data_sm.dest_addr_subunit = 0x03;
|
|
smpp_msg.pdu.data_sm.dest_network_type = 0x03;
|
|
|
|
smpp_msg.pdu.data_sm.dest_bearer_type = 0x03;
|
|
smpp_msg.pdu.data_sm.dest_telematics_id = 0x0003;
|
|
smpp_msg.pdu.data_sm.sar_msg_ref_num = 0x7700;
|
|
smpp_msg.pdu.data_sm.sar_total_segments = 0x01;
|
|
|
|
smpp_msg.pdu.data_sm.sar_segment_seqnum = 0x01;
|
|
smpp_msg.pdu.data_sm.more_messages_to_send = 0x01;
|
|
smpp_msg.pdu.data_sm.qos_time_to_live = 0x000000FF;
|
|
smpp_msg.pdu.data_sm.payload_type = 0x00;
|
|
|
|
strcpy(smpp_msg.pdu.data_sm.message_payload, "smpp message in data sm optional");
|
|
smpp_msg.pdu.data_sm.set_dpf = 0x01;
|
|
//strcpy(smpp_msg.pdu.data_sm.receipted_message_id, "receipted message id");
|
|
smpp_msg.pdu.data_sm.message_state = 0x01;
|
|
|
|
//smpp_msg.pdu.data_sm.network_error_code[0] = 0x03;
|
|
//smpp_msg.pdu.data_sm.network_error_code[1] = 0x03;
|
|
//smpp_msg.pdu.data_sm.network_error_code[2] = 0x00;
|
|
smpp_msg.pdu.data_sm.user_message_reference = 0x00;
|
|
smpp_msg.pdu.data_sm.privacy_indicator = 0x03;
|
|
smpp_msg.pdu.data_sm.callback_num[0] = 0x01;
|
|
smpp_msg.pdu.data_sm.callback_num[1] = 0x02;
|
|
smpp_msg.pdu.data_sm.callback_num[2] = 0x03;
|
|
strcpy(smpp_msg.pdu.data_sm.callback_num+3, "call back num");
|
|
|
|
smpp_msg.pdu.data_sm.callback_num_pres_ind = 0x06;
|
|
strcpy(smpp_msg.pdu.data_sm.callback_num_atag, "callback num atag in data sm");
|
|
smpp_msg.pdu.data_sm.source_subaddress[0] = 0xA0;
|
|
smpp_msg.pdu.data_sm.source_subaddress[1] = 0x01;
|
|
//strcpy(smpp_msg.pdu.data_sm.source_subaddress+1, "123");
|
|
smpp_msg.pdu.data_sm.dest_subaddress[0] = 0xA0;
|
|
smpp_msg.pdu.data_sm.dest_subaddress[1] = 0x01;
|
|
//strcpy(smpp_msg.pdu.data_sm.dest_subaddress+1, "321");
|
|
|
|
smpp_msg.pdu.data_sm.user_response_code = 0x03;
|
|
smpp_msg.pdu.data_sm.display_time = 0x02;
|
|
//smpp_msg.pdu.data_sm.sms_signal = 0x03;
|
|
smpp_msg.pdu.data_sm.ms_validity = 0x03;
|
|
|
|
smpp_msg.pdu.data_sm.ms_msg_wait_facilities = 0x03;
|
|
smpp_msg.pdu.data_sm.number_of_messages = 0x03;
|
|
smpp_msg.pdu.data_sm.alert_on_message_delivery = 0x03;
|
|
smpp_msg.pdu.data_sm.language_indicator = 0x01;
|
|
|
|
smpp_msg.pdu.data_sm.its_reply_type = 0x03;
|
|
smpp_msg.pdu.data_sm.its_session_info[0] = 0x01;
|
|
smpp_msg.pdu.data_sm.its_session_info[1] = 0x53;
|
|
break;
|
|
}
|
|
|
|
smpp_send(linkNo, &smpp_msg, dataLen);
|
|
}
|