开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
smsc_sema.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：49k
源码类别：

手机WAP编程

开发平台：

WINDOWS

smsc_sema.c：源码内容
  2.  /*
  3.  * smsc_sema.c - implement sms2000 protocal by using X25 access
  4.  * the data communication layer is implemented by using X28 protocol
  5.  * 
  6.  * Code implement submit invoke, status invoke, deliver invoke session
  7.  * there is no internal db for storing delivered and undelivered message
  8.  * 
  9.  * IA5 is most common line coding scheme. 
  10.  * smsc_sema support only IA5 encoding, hex and binary line encoding is not
  11.  * supported.
  12.  * 
  13.  * smsc_sema support IA5 and GSM Data Code Scheme for delivered invoke message
  14.  * smsc_sema support only IA5 Data Code Scheme for submit invoke message
  15.  *  
  16.  * Reference : SMS2000 Version 4.0 Open Interface Specification
  17.  *             Open Source WAP Gateway Architecture Design 
  18.  *             ESTI GSM 03.40
  19.  *
  20.  * Hao Shi 2000
  21.  */
  23. #include <errno.h>
  24. #include <stdarg.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <unistd.h>
  29. #include <fcntl.h>
  30. #include <termios.h>
  32. #include <sys/time.h>
  33. #include <sys/types.h>
  34. #include <sys/socket.h>
  35. #include <sys/param.h>
  38. #include <netinet/in.h>
  39. #include <netdb.h>
  41. #include "gwlib/gwlib.h"
  42. #include "smsc.h"
  43. #include "smsc_p.h"
  44. #include "alt_charsets.h"
  45. #include "smsc_sema.h"
  46. #include "sms.h"
  48. #ifndef CRTSCTS
  49. #define CRTSCTS 0
  50. #endif
  53. static unsigned char sema_counter[4] = "0000";
  54. static int sema_wait_report = 1;
  55. static int x28_data_mode = X28_COMMAND_MODE;
  57. SMSCenter * sema_open(char* smscnua, char* homenua, 
  58.       char* serialdevice, int waitreport)
  59. {
  60. SMSCenter *smsc;
  61. int nret = -1;
  63. smsc = smscenter_construct();
  64. if(smsc == NULL)
  65.   goto error;
  67. sprintf(smsc->name, "SEMA:X28:"); 
  69. smsc->type = SMSC_TYPE_SEMA_X28;
  70. smsc->sema_smscnua = gw_strdup(smscnua);
  71. smsc->sema_homenua = gw_strdup(homenua);
  72. smsc->sema_serialdevice = gw_strdup(serialdevice);
  73. sema_wait_report = waitreport;
  75. smsc->sema_mt = sema_msglist_new();
  76. if(smsc->sema_mt == NULL) goto error;
  78. smsc->sema_mo = sema_msglist_new();
  79. if(smsc->sema_mo == NULL) goto error;
  81. /* Open the device properly. Remember to set the
  82.    access codes correctly. */
  83. debug("smsc.sema", 0, "sema_open: open datalink");
  84. smsc->sema_fd = X28_open_data_link(smsc->sema_serialdevice);
  85. if(smsc->sema_fd == -1) goto error;
  87. /*  test the outgoing callX28 to smsc center */
  88.         debug("smsc.sema", 0, "sema_open: test send link");
  89. nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);
  90. if(nret < 1){
  91.   sleep(2);
  92.   nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);  
  93.   if(nret < 1)
  94.     goto error;
  95. }
  96. X28_close_send_link(smsc->sema_fd);
  97. return smsc;
  99. error:
  100. error(0, "sema_open: could not open");
  101. smscenter_destruct(smsc);
  102. return NULL;
  103. }
  106. int sema_reopen(SMSCenter *smsc)
  107. {
  108.     int nret = 0;
  110.     debug("smsc.sema", 0, "reopening the connection");
  112.     /*deallocate*/
  113.     sema_msglist_free(smsc->sema_mt);
  114.     sema_msglist_free(smsc->sema_mo);
  115.     /*reallocate*/
  116.     smsc->sema_mt = sema_msglist_new();
  117.     if(smsc->sema_mt == NULL) goto error;
  118.     smsc->sema_mo = sema_msglist_new();
  119.     if(smsc->sema_mo == NULL) goto error;
  120.     memset(smsc->buffer,0,sizeof(smsc->buffer));
  122.     /* Open the device properly. Remember to set the
  123.      access codes correctly. */
  124.     smsc->sema_fd = X28_reopen_data_link(smsc->sema_fd, smsc->sema_serialdevice);
  125.     if(smsc->sema_fd == -1){
  126. error(0,"sema_reopen_data_link: device file error");
  127. goto error;
  128.     }
  129.     /*test outgoing call to the smsc */
  130.     nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);
  131.     if(nret < 1){
  132. error(0,"test send data link failed");
  133. goto error;
  134.     }
  135.     X28_close_send_link(smsc->sema_fd);
  136.     return 0;
  137. error:
  138.     error(0, "sema_reopen_data_link: failed");
  139.     return -1;
  140.   
  141. }
  143. int sema_close(SMSCenter *smsc)
  144. {
  145.     if(smsc->sema_fd > 0)
  146. close(smsc->sema_fd);
  147.     /*deallocate*/
  148.     sema_msglist_free(smsc->sema_mt);
  149.     sema_msglist_free(smsc->sema_mo);
  150.     return 0;
  151. }
  154. int sema_submit_msg(SMSCenter *smsc, Msg *msg)
  155. {
  156.         int nret = 0;
  157.         struct sema_msg *lmsg = NULL;
  158. struct sm_submit_invoke *submit_sm = NULL;
  159. char x28sender[2] = "A3";
  160.         
  161. /* Validate msg */
  162. if(smsc == NULL){
  163.     error(0,"sema_submit_msg: SMSC is empty");
  164.     goto error;
  165. }
  166. if(msg == NULL){
  167.     error(0, "sema_submit_msg: Msg is empty");
  168.     goto error;
  169. }
  171. if(msg_type(msg) != sms) {
  172.     error(0, "sema_submit_sms: Msg is WRONG TYPE");
  173.     goto error;
  174. }
  175. /*  user data header is not supported in sm2000 X25 access
  176.     if(msg->sms.coding == DC_7BIT){
  177.     error(0, "sema_submit_sms: submit invoke support in IA5 encoding(8 bits chars)");
  178.     goto error;
  179.     }
  181.     if(octstr_len(msg->sms.udhdata)){
  182.     error(0, "sema_submit_sms: submit invoke not support in IA5 encoding ");
  183.     goto error;
  184.     }
  185. */
  186. lmsg = sema_msg_new();
  188. submit_sm = gw_malloc(sizeof(struct sm_submit_invoke));
  189. memset(submit_sm, 0, sizeof(struct sm_submit_invoke));
  191. lmsg->type = 'S';
  192. lmsg->encodetype = LINE_ENCODE_IA5;
  194. /* set operation reference */
  195. increment_counter();
  196. memcpy(lmsg->optref,sema_counter,4);
  197. /*set sme reference number*/
  198. increment_counter();
  199. memcpy(submit_sm->smerefnum, sema_counter, 4);
  200. /*we send as not key type*/
  201. submit_sm->smereftype= 2; /*key type is 1*/
  202. /*we set prority as normal*/
  203. submit_sm->priority = 1; /*0 is high*/ 
  204. /*set valid period type as relative*/
  205. submit_sm->validperiodtype = 2; /* 1 is absolute */
  206. /*time*/
  207. submit_sm->validperiodrela = 1; /* from 0 to 143 , fomula is (V+1)*5 min*/
  208. /*send msg without 00 header*/
  209. submit_sm->msisdnlen= octstr_len(msg->sms.receiver);
  210. submit_sm->msisdn = octstr_copy(msg->sms.receiver,0,submit_sm->msisdnlen);
  211. /* X25 access will always append sender during data transfer */
  212. submit_sm->origaddlen= 2; /* we need only to orignate address type */
  213. submit_sm->origadd = octstr_create_from_data(x28sender,2);
  214. /*data encoding scheme ,support only IA5 in current version*/
  215. submit_sm->DCS = 15; /*gsm is 0 ,IA5 is 15*/
  216. /*protocal ,support only default value  0 in current version*/ 
  217. submit_sm->protocal = 0;
  218. /*replypath*/
  219. submit_sm->replypath= 0; /*gateway do not pay for reply*/
  220. /*status report*/
  221. if(sema_wait_report > 0)
  222.     submit_sm->statusreportrequest =4; /* deliver success, in bin form 00000100*/
  223. else
  224.     submit_sm->statusreportrequest = 0;/* no report */
  225. /* we support submit invoke only in IA5 line encoding*/
  226. submit_sm->textsizeoctect = submit_sm->textsizeseptet =
  227. octstr_len(msg->sms.msgdata);
  228. /*copy msg buffer*/
  229. submit_sm->shortmsg = octstr_copy(msg->sms.msgdata,
  230.   0, submit_sm->textsizeoctect);
  232. memset(submit_sm->smscrefnum,0,sizeof(submit_sm->smscrefnum));
  233.         /*pack the message body in 2kmsg*/
  234. lmsg->msgbody = (void**)(&submit_sm);
  235. nret = sema_msg_session_mt(smsc, lmsg);
  237. gw_free(submit_sm);
  238. submit_sm = NULL;
  239. sema_msg_free(lmsg);
  240. lmsg = NULL;
  243. if(nret == SESSION_MT_RECEIVE_SUCCESS){
  244.     debug("smsc.sema", 0, "sema_submit_msg: message is successfully delivered");
  245.     return 1; /*success*/
  246. }
  247. else if(nret == SESSION_MT_RECEIVE_TIMEOUT){
  248.     info(0, "sema_submit msg: session time out without return");
  249.     return 0;
  250. }
  251. else if(nret == SESSION_MT_RECEIVE_ERR){
  252.     info(0, "sema_submit msg: smsc say submit failed!");
  253.     return 0;
  254. }
  256. return 1;
  258. error:
  259. if(submit_sm)
  260.     gw_free(submit_sm);
  261. if(lmsg)
  262.     sema_msg_free(lmsg);
  263. return -1;
  264. }
  267. int sema_receive_msg(SMSCenter *smsc, Msg **msg)
  268. {
  270.     struct sema_msg *rmsg = NULL;
  271.     struct sm_deliver_invoke *recieve_sm = NULL;
  272.  
  273.     while(sema_msglist_pop(smsc->sema_mo, &rmsg) == 1 ) {
  274.   
  275. *msg = msg_create(sms);
  276. if(*msg==NULL) goto error;
  277.     
  278. recieve_sm = (struct sm_deliver_invoke*) (*(rmsg->msgbody));
  279. if(recieve_sm==NULL) goto error;
  280.           
  281. /* as IA5(8 bit character) is the default line encoding used by X28
  282.  * and we do not support other line encoding scheme like binary or
  283.  * hex encoding
  284.  */
  285. (*msg)->sms.coding = DC_8BIT;
  286. /* OIS in X28 implementation does not include udh field */
  288. (*msg)->sms.sender = octstr_create_from_data(
  289.     octstr_get_cstr(recieve_sm->origadd) +2,
  290.     octstr_len(recieve_sm->origadd)-2);  
  291. (*msg)->sms.receiver = octstr_create_from_data(
  292.     octstr_get_cstr(recieve_sm->destadd) +2,
  293.     octstr_len(recieve_sm->destadd)-2);
  294.   
  295. (*msg)->sms.msgdata = octstr_duplicate(recieve_sm->shortmsg);
  296. (*msg)->sms.udhdata = octstr_create("");
  297. gw_free(recieve_sm);
  298. sema_msg_free(rmsg);
  299. rmsg = NULL;
  300.     }
  301.     return 1;
  303. error:
  304.     error(0, "sema_receive_msg: can not create Smart Msg");
  305.     return -1;
  306. }
  309. int sema_pending_smsmessage(SMSCenter *smsc)
  310. {
  312.     char data[1024];
  313.     int ret = 0;
  314.     char clrbuff[]="CLR";
  315.     char errbuff[]="ERR";
  316.     /* struct sema_msg* smsg = NULL;*/
  318.   /* Receive raw data */
  319.     ret = X28_data_read(smsc->sema_fd, smsc->buffer);
  320.     if(ret == -1) {
  321. ret = X28_reopen_data_link(smsc->sema_fd, smsc->sema_serialdevice);
  322. if(ret == -1) goto error;
  323. return 0;
  324.     } 
  326.     /* Interpret the raw data */
  327.     memset(data,0,sizeof(data));
  328.     while(X28_msg_pop(smsc->buffer, data) == 0 ) {
  329. if(strlen(data) > 0){
  330.     if(strstr(data,clrbuff) != NULL ||
  331.        strstr(data,errbuff) != NULL){
  332. debug("smsc.sema", 0, "sema_pending_msg: Radio Pad Command line-%s",data);
  333.     }
  334.     else{   
  335.       
  336. ret = sema_msg_session_mo(smsc, data);
  337. if(ret == -1) goto error;
  338.     }
  339.     memset(data,0,sizeof(data));
  340. }
  341.     }
  343.     /* Signal that we got a MO message if mo list is not empty*/
  344.     if(smsc->sema_mo->first != NULL){
  345. return 1;
  346.     }
  349.     return 0;
  351. error:
  352.     error(0,"sema_pending message: device file error");
  353.     return -1;
  354. }
  358. static sema_msg* sema_msg_new(void)
  359. {
  360.     struct sema_msg *msg = NULL;
  361.     msg = gw_malloc(sizeof(struct sema_msg));
  362.     memset(msg, 0, sizeof(struct sema_msg));
  363.     return msg;
  364. }
  366. static int sema_msg_free(sema_msg *msg) {
  367.     if(msg == NULL) return 0;
  368.     gw_free(msg);
  369.     return 1;
  370. }
  372. static sema_msglist* sema_msglist_new(void) {
  374.     struct sema_msglist *mlist = NULL;
  375.     mlist = gw_malloc(sizeof(struct sema_msglist));
  376.     memset(mlist, 0, sizeof(struct sema_msglist));
  377.   
  378.     mlist->first = NULL;
  379.     mlist->last = NULL;
  380.     mlist->count = 0;
  381.     return mlist;
  382. }
  384. static void sema_msglist_free(sema_msglist *mlist) {
  386.     struct sema_msg *pmsg = NULL;
  387.     if(mlist == NULL) return; 
  388.     while( sema_msglist_pop(mlist, &pmsg) == 1 )  {
  389. if(pmsg==NULL) break;
  390. sema_msg_free(pmsg);
  391. pmsg = NULL;
  392.     }
  393.     gw_free(mlist);
  394.     mlist->count = 0;
  395. }
  397. static int sema_msglist_push(sema_msglist *plist, sema_msg *pmsg) {
  399.     struct sema_msg * lmsg = NULL;
  400.     if(plist == NULL) {
  401. info(0, "msglist_push: NULL msg list");
  402. goto error;
  403.     }
  404.     if(pmsg == NULL) {
  405. info(0, "msglist_push: NULL input");
  406. goto error;
  407.     }
  408.     /* If list is completely empty. */
  409.     if( plist->first == NULL ) {
  410. plist->last = pmsg;
  411. plist->first = pmsg;
  412. pmsg->prev = NULL;
  413. pmsg->next = NULL;
  414.     }
  415.     else{
  416. lmsg=plist->last;
  417. lmsg->next=pmsg;
  418. pmsg->prev=lmsg;
  419. pmsg->next=NULL;
  420. plist->last=pmsg;
  421.     }
  422.     plist->count += 1;
  423.     return 1;
  425. error:
  426.     error(0, "msglist_push: error");
  427.     return 0;
  429. }
  431. static int sema_msglist_pop(sema_msglist *plist, sema_msg **msg) {
  433.    if(plist == NULL) {
  434. info(0, "msglist_pop: NULL list");
  435. goto no_msg;
  436.     }
  437.     if(plist->first == NULL) {
  438. goto no_msg;
  439.     }
  441.     *msg = plist->first;
  442.     if(plist->last == *msg) {
  443. plist->first = NULL;
  444. (*msg)->prev = NULL;
  445. plist->last = NULL;
  446.     } 
  447.     else {
  448. plist->first = (*msg)->next;
  449. plist->first->prev = NULL; 
  450. if(plist->first->next == NULL) 
  451.     plist->last = plist->first;
  452.     }
  453.     plist->count -= 1;
  454.     return 1;
  456. no_msg:
  457.     return 0;
  458. }
  462. static int X28_open_data_link(char* device){
  463.     int fd = -1, iret;
  464.     struct termios tios;
  465.     info(0,"open serial device %s",device);
  466.     fd = open(device, O_RDWR|O_NONBLOCK|O_NOCTTY);
  467.     if(fd==-1) {
  468. error(errno, "sema_open_data_link: error open(2)ing the character device <%s>",
  469.       device);
  470. if(errno == EACCES)
  471.     error(0, "sema_open_data_link: user have no right to access the serial device");
  472. return -1;
  473.     }
  475.     tcgetattr(fd, &tios);
  476.     cfsetospeed(&tios, B4800);  /* check radio pad parameter*/
  477.     cfsetispeed(&tios, B4800);
  478.     kannel_cfmakeraw(&tios);
  479.     tios.c_iflag |= IGNBRK|IGNPAR|INPCK|ISTRIP;
  480.     tios.c_cflag |= (CSIZE|HUPCL | CREAD | CRTSCTS);
  481.     tios.c_cflag ^= PARODD;
  482.     tios.c_cflag |=CS7;
  483.     iret = tcsetattr(fd, TCSANOW, &tios);
  484.     if(iret == -1){
  485. error(errno,"sema_open_data_link: fail to set termios attribute");
  486. goto error;
  487.     }
  488.     tcflush(fd, TCIOFLUSH);
  489.     return fd;
  490.   
  491. error:
  492.     return -1;
  493. }
  495. static int X28_reopen_data_link(int oldpadfd ,char* device){
  496.     int nret = 0;
  497.     if(oldpadfd > 0){
  498. nret= close(oldpadfd);
  499. if(nret == -1){
  500.     error(errno,"sema_reopen_data_link: close device file failed!!");
  501. }
  502.     }
  503.     sleep(1);
  504.     return X28_open_data_link(device);
  505. }
  508. static int X28_close_send_link(int padfd)
  509. {
  510.     unsigned char discnntbuff[5];
  511.     unsigned char readbuff[1024];
  512.     unsigned char finishconfirm[]="CLR CONF";
  513.     int nret = 0, readall = 0;
  514.     time_t tstart;
  515.     time(&tstart);
  517.     sprintf(discnntbuff,"%cCLRr",0x10);
  518.     memset(readbuff,0,sizeof(readbuff));
  520.     /* what ever is the close return, data mode is unreliable now*/
  521.     x28_data_mode = X28_COMMAND_MODE;
  523.     if(padfd <= 0)
  524. goto datalink_error;
  525.     while((time(NULL) - tstart) < INTERNAL_DISCONNECT_TIMEVAL){
  526. nret =write(padfd, discnntbuff, 5);
  527. if(nret == -1){
  528.     if(errno == EAGAIN || errno ==EINTR) continue;
  529.     else{
  530. goto datalink_error;
  531.     }
  532. }
  533. sleep(1); /*wait 1 senconds for virtual link break*/
  534. nret=read(padfd, readbuff+readall,128);
  535. if(nret == -1){
  536.     if(errno == EAGAIN || errno ==EINTR) continue;
  537.     else{
  538. goto datalink_error;
  539.     }
  540. }
  541. if(nret >0){
  542.     readall += nret;
  543.     if(strstr(readbuff,finishconfirm))
  544. return 1;
  545. }
  546.     }
  547.     return 0;
  548. datalink_error:
  549.     error(errno,"sema_close_send_link, device file error");
  550.     return -1;
  551. }
  555. static int X28_open_send_link(int padfd, char *nua) {
  557.     char readbuff[1024]; 
  558.     char writebuff[129];
  559.     char smscbuff[129];
  560.     int readall = 0, readonce = 0, writeonce = 0, writeall = 0, i = 0;
  561.     char X28prompt[]="*rn";
  562.     time_t timestart;
  563.   
  564.     debug("smsc.sema", 0, "sema_open send link: call smsc  <%s> for <%i> seconds",
  565.   nua, (int)INTERNAL_CONNECT_TIMEVAL);
  567.     /*  type few <cr> to invoke DTE */
  568.     writebuff[0] = 'r';       
  569.     memset(readbuff,0,sizeof(readbuff));     
  570.     for(i = 0; i <= 3; i++)
  571.     {
  572. readonce = writeonce = -1;
  573. writeonce = write(padfd, writebuff, 1);
  574. if(writeonce < 1){
  575.     if(errno == EINTR || errno == EAGAIN) continue;
  576.     else{
  577. goto datalink_error;
  578.     }
  579. }
  580. usleep(1000); /* wait for prompt */
  581. readonce = read(padfd, &readbuff[readall],1024);
  582. if(readonce == -1){
  583.     if(errno == EINTR || errno == EAGAIN) continue;
  584.     else{
  585. goto datalink_error;
  586.     }
  587. }
  588. else
  589.     readall += readonce;
  590.     }
  591.     if(strstr(readbuff, X28prompt) == NULL){
  592. warning(0,"X28_open_send_link: can not read command prompt, abort");
  593. return 0;
  594.     }
  597.     /* second, connect to the smsc now */
  598.     memset(writebuff,0,sizeof(writebuff));
  599.     memset(readbuff,0,sizeof(readbuff));  
  600.     writeall = readall = 0;
  601.     sprintf(writebuff, "%sr", nua);
  602.     sprintf(smscbuff, "%s COM",nua);
  603.   
  604.     while((size_t) writeall < strlen(writebuff)){
  605. writeonce = -1;
  606. writeonce = write(padfd, writebuff+writeall, strlen(writebuff)-writeall);
  607. if(writeonce == -1){
  608.     if(errno == EINTR || errno == EAGAIN)
  609. continue;
  610.     else
  611. goto datalink_error;
  612. }
  613. if(writeonce > 0)
  614.     writeall +=writeonce;
  615.     }
  616.     tcdrain(padfd); 
  617.     usleep(1000*1000);/* wait for smsc answer */
  619.     time(&timestart);
  620.     while(time(NULL) - timestart < INTERNAL_CONNECT_TIMEVAL){
  621. if((size_t) readall >= sizeof(readbuff))
  622.     goto error_overflow;
  623. /* We read 1 char a time */
  624. readonce = read(padfd, &readbuff[readall], 1);
  625. if(readonce == -1) {
  626.     if(errno == EINTR || errno == EAGAIN) continue;
  627.     else
  628. goto datalink_error;
  629. }
  630. if(readonce > 0)
  631.     readall += readonce;
  632. /* Search for reponse line. */
  633. if(readall > 2 &&
  634.    readbuff[readall-1] == 'n' && 
  635.    readbuff[readall-2] == 'r') {
  636.     if(strstr(readbuff, smscbuff)) {
  637. debug("smsc.sema", 0,
  638.       "sema_open send link: smsc respond, virtual link established");
  639. x28_data_mode = X28_MT_DATA_MODE; 
  640. return 1;
  641.     }
  642. } 
  643. usleep(1000);
  644.     }
  645.     info(0,"sema_open_send_link: connecting time out");
  646.     return 0;
  647. error_overflow:
  648.     warning(0, "sema_open_send_link: command buffer overflow");
  649.     return 0;
  650. datalink_error:
  651.     error(errno,"sema_open_send_link: device file error");
  652.     return -1;
  653. }
  657. static int X28_data_read(int padfd, char *cbuffer) {
  658.     char *p = NULL;
  659.     int ret,  len;
  660.     fd_set read_fd;
  661.     struct timeval tv, tvinit;
  662.     size_t readall;
  663.      
  664.     tvinit.tv_sec = 0;
  665.     tvinit.tv_usec = 1000;
  666.      
  667.     readall = 0;
  668.     for (;;) {
  669. FD_ZERO(&read_fd);
  670. FD_SET(padfd, &read_fd);
  671. tv = tvinit;
  672. ret = select(padfd + 1, &read_fd, NULL, NULL, &tv);
  673. if (ret == -1) {
  674.     if(errno==EINTR) goto got_data;
  675.     if(errno==EAGAIN) goto got_data;
  676.     error(errno, "Error doing select for fad");
  677.     return -1;
  678. } else if (ret == 0)
  679.     goto got_data;
  680. len = strlen(cbuffer);
  681. ret = read(padfd,
  682.    cbuffer + len,
  683.    256);    
  684. if (ret == -1) {
  685.             error(errno," read device file");
  686.     return -1;
  687. }
  688. if (ret == 0)
  689.     goto eof;
  690.        
  691. readall += ret;
  692. if ((size_t) len >  sizeof(cbuffer)- 256) {
  693.     p = gw_realloc(cbuffer, sizeof(cbuffer) * 2);
  694.     memset(p+len,0,sizeof(cbuffer)*2 - len);
  695.     cbuffer = p;
  696. }
  697. if(readall > 0)
  698.     break;
  699.     }
  700.      
  701. eof:
  702.     if(readall > 0)
  703. ret = 1;
  704.     goto unblock;
  705.      
  706. got_data:
  707.     ret = 0;
  708.     goto unblock;
  710. unblock:
  711.     return ret;  
  713. }
  715. static int X28_data_send(int padfd, char *cbuffer,int sentonce) {
  716.     int len = 0, pos = 0,writeonce = 0,writeall = 0;
  717.  
  718.     tcdrain(padfd);
  719.     len = strlen(cbuffer);
  720.     while(len > 0){
  721. if(len < sentonce) {
  722.     writeonce = write(padfd, cbuffer+pos, len);
  723. }
  724. else
  725.     writeonce = write(padfd, cbuffer+pos, sentonce);
  726.  
  727. if (writeonce == -1) {
  728.     if(errno == EINTR || errno == EINTR)
  729. continue;
  730.     else{
  731. goto error;
  732.     }
  733. }
  734. if(writeonce > 0){
  735.     len -= writeonce;
  736.     pos += writeonce;
  737.     writeall = pos;
  738. }
  739.     }
  740.     tcdrain(padfd);
  741.     return writeall;
  743. error:
  744.     error(errno,"sema_send data error: device file erro");
  745.     return -1;
  746. }
  748. static int X28_msg_pop(char *from, char *to)
  749. {
  750.     char* Rbuff =NULL;
  751.     char* RRbuff = NULL;
  752.     char mobuff[] ="COMrn";
  753.     char mobuffend[] = "r";
  754.     char prompbuff[] = "*r";
  755.     int len = 0, Llen= 0, Rlen = 0,RRlen = 0;
  757.     len = strlen(from);
  758.     if(len <=0) goto no_msg;
  760.     /* trim off rabbish header */
  761.     while(*from == 'r' || *from == 'n'){
  762. len = strlen(from);
  763. if(len > 1){
  764.     memmove(from, from +1, len-1);
  765.     memset(from+(len-1), 0, 1);
  766. }
  767. else{
  768.     memset(from,0,len);
  769.     return -1;
  770. }
  771.     }   
  773.     len = strlen(from); 
  774.     /*all kinds of useful infomation contains r*/
  775.     if((Rbuff=memchr(from,'r',len)) == NULL)
  776. goto no_msg;
  778.  
  779.     /*check if it is a command prompt *rn */
  780.     if((Rbuff -from) > 0 && *(Rbuff -1) == '*'){
  781. if(strlen(Rbuff) < 2) goto no_msg; /*n is not coming yet*/
  782.      
  783. if(Rbuff -from > 4){ /* command info */
  784.     Rlen = Rbuff -1 -from;
  785.     memcpy(to,from,Rlen);
  786. }
  787. x28_data_mode = X28_COMMAND_MODE;
  788. if(strlen(Rbuff+1) > 1){
  789.     Rlen = strlen(Rbuff +2);
  790.     memmove(from, Rbuff +2, Rlen);
  791.     memset(from+Rlen, 0, len-Rlen);
  792. }
  793. else
  794.     memset(from, 0,len);
  795.     }/* check mo msg , format X121address+COMrn+msg+r*/
  796.     else if((Rbuff-from) > 3 &&  strstr(Rbuff-4,mobuff)!= NULL){
  797. if(strlen(Rbuff) < 3 ||
  798.    (RRbuff = strstr(Rbuff + 2, mobuffend)) == NULL)
  799.     goto no_msg; /*the msg+r  is still coming*/
  801. RRlen = RRbuff - (Rbuff+2);
  802. if(RRlen > 4){ /* msg header is 4 byte always+msg content*/ 
  803.     memcpy(to, Rbuff +2 , RRlen);
  804.     x28_data_mode = X28_MO_DATA_MODE;
  805. }
  807. if(strlen(RRbuff) > 1){
  808.     Rlen = strlen(RRbuff +1);
  809.     memmove(from, RRbuff+1 ,Rlen);
  810.     memset(from+Rlen,0,len -Rlen);
  811. }
  812. else
  813.     memset(from,0,len);
  814.     }
  815.     else{/* it can be mt reply */
  816. if(Rbuff  - from > 0){ 
  817.     Llen = Rbuff - from;
  818.     memcpy(to, from, Llen);
  819. }    
  820. if(strlen(Rbuff) > 1){
  821.     Rlen = strlen(Rbuff+1);
  822.     memmove(from,Rbuff+1,Rlen);
  823.     memset(from+Rlen,0,len-Rlen);
  824. }
  825. else
  826.     memset(from,0,len);
  827.     }
  829.     /* check rest line for link state: command mode or data mode */
  830.     if(strstr(from,prompbuff) != NULL)
  831. x28_data_mode = X28_COMMAND_MODE;
  833.     return 0;
  834. no_msg:
  835.     return -1;
  836. }
  840. static int sema_submit_result(SMSCenter *smsc, sema_msg* srcmsg, int result)
  841. {
  842.     char IA5buff[1024];
  843.     unsigned char oct1byte[1];
  844.     unsigned char ia5byte[2];
  845.     unsigned char cTr='t';
  846.     unsigned char cMr='m';
  847.     unsigned char ccontinuebyte = 'P', ccr = 'r';
  848.     int j = 0, iret;
  850.     memset(IA5buff,0,sizeof(IA5buff));
  851.     switch(srcmsg->type)
  852.     {
  853.     case 'M':
  854. memcpy(IA5buff,&cMr,1);/*msg type*/
  855. memcpy(IA5buff+1,&ccontinuebyte,1); /*continue bit*/
  856. memcpy(IA5buff+2,srcmsg->optref,4); /*operation reference*/
  857. write_variable_value(result,oct1byte);
  858. j=internal_char_hex_to_IA5(oct1byte[0],ia5byte);
  859. memcpy(IA5buff+6,ia5byte,j);
  860. memcpy(IA5buff+6+j,&ccr,1);/*result*/
  861. iret = X28_data_send(smsc->sema_fd,IA5buff,strlen(IA5buff));
  862. if(iret == -1) goto error;
  863. break;
  864.     case 'T':
  865. memcpy(IA5buff,&cTr,1);
  866. memcpy(IA5buff+1,&ccontinuebyte,1);
  867. memcpy(IA5buff+2,srcmsg->optref,4); 
  868. write_variable_value(result,oct1byte);
  869. j=internal_char_hex_to_IA5(oct1byte[0],ia5byte);
  870. memcpy(IA5buff+6,ia5byte,j);
  871. memcpy(IA5buff+6+j,&ccr,1);
  872. iret = X28_data_send(smsc->sema_fd,IA5buff,strlen(IA5buff));
  873. if(iret == -1) goto error;   
  874. break;
  875.     default:  
  876. return 0; /*unsupoorted result msg type*/
  877.     }
  878.     return 1;
  879. error:
  880.     error(0,"sk_submit_result: write to device file failed");
  881.     return -1;
  882. }
  884. static int sema_msg_session_mt(SMSCenter *smsc, sema_msg* pmsg){
  885.     struct msg_hash *segments = NULL;
  886.     struct sema_msg* mtrmsg = NULL;
  887.     struct sm_statusreport_invoke* report_invoke = NULL;
  888.     struct sm_submit_result* submit_result = NULL;
  889.     struct sm_submit_invoke* submit_invoke = NULL;
  890.     struct sm_deliver_invoke* deliver_invoke = NULL;
  892.     char data[1024], IA5buff[256], IA5chars[1024], mochars[10*1024];
  893.     unsigned char ccontinuebyte, ccr = 'r';
  894.     unsigned char cerr[] = "ERR",cclr[] = "CLR", tmp1[5] , tmp2[5];
  895.   
  896.     int  i, iseg = 0, ilen = 0,iret = 0, moret;
  897.     int isrcved = 0, iTrcved = 0, decoderesult = 0;
  898.     time_t tstart;
  900.     submit_invoke=(struct sm_submit_invoke*)(*(pmsg->msgbody));
  901.     if(submit_invoke == NULL) goto error;
  903.     /*encode first*/
  904.     memset(IA5chars,0,sizeof(IA5chars));
  906.     if(sema_encode_msg(pmsg, IA5chars) < 1) goto encode_error;
  908.     /*divide segments, we send buffer no more than 128 byte once*/
  909.     iseg = strlen(IA5chars)/121 + 1;
  910.     segments = gw_malloc(iseg * sizeof(struct msg_hash));
  911.     if(segments == NULL) goto error;
  914.     /*first segments*/
  915.     if(strlen(IA5chars) < 121)
  916. ilen = strlen(IA5chars);
  917.     else
  918. ilen = 121;
  919.     segments[0].content = octstr_create_from_data(&(pmsg->type), 1);/*msg type, in hex*/
  920.     ccontinuebyte = pack_continous_byte(pmsg->encodetype, 1, iseg -1);
  921.     octstr_insert_data(segments[0].content, 1, 
  922.        &ccontinuebyte, 1);  /*continue char, in hex*/
  923.     octstr_insert_data(segments[0].content,
  924.        2, pmsg->optref, 4); /*operation reference, in hex*/
  925.     octstr_insert_data(segments[0].content, 6,
  926.        IA5chars, ilen);
  927.     octstr_insert_data(segments[0].content,
  928.        octstr_len(segments[0].content), &ccr, 1); /*<cr>*/
  929.  
  930.     /*rest segments*/
  931.     for( i = 1; i < iseg; i++){
  932. if(strlen(IA5chars) - i*121 < 121)
  933.     ilen = strlen(IA5chars) - i*121;
  934. else
  935.     ilen =121;
  936. segments[i].content= octstr_create_from_data(&(pmsg->type), 1); 
  937. ccontinuebyte = pack_continous_byte(pmsg->encodetype, 0, iseg -i-1);
  938. octstr_insert_data(segments[i].content, 1, &ccontinuebyte, 1); 
  939. octstr_insert_data(segments[i].content, 2, pmsg->optref, 4); 
  940. octstr_insert_data(segments[i].content, 6, 
  941.    IA5chars + i*121, ilen);
  942. octstr_insert_data(segments[i].content,
  943.    octstr_len(segments[i].content), &ccr, 1); 
  944.     }
  946.     if(x28_data_mode != X28_MT_DATA_MODE){
  947. /* do not trust any existing data mode*/    
  948. X28_close_send_link(smsc->sema_fd); 
  949. /*open send link*/
  950. if((iret = X28_open_send_link(smsc->sema_fd,smsc->sema_smscnua)) < 1){
  951.     if(iret == -1){
  952. iret = X28_reopen_data_link(smsc->sema_fd, smsc->sema_serialdevice);
  953. if(iret == -1){
  954.     goto error;
  955. }
  956.     }
  957.     X28_close_send_link(smsc->sema_fd); 
  958.     sleep(1);
  959.     iret = X28_open_send_link(smsc->sema_fd,smsc->sema_smscnua);
  960.     if(iret < 1)
  961. goto sendlink_error;
  962. }
  963.     }
  964.     /*deliver buff*/
  965.     for(i = 0; i < iseg; i++){
  966. memset(IA5buff,0,sizeof(IA5buff));
  967. memcpy(IA5buff,octstr_get_cstr(segments[i].content),
  968.        octstr_len(segments[i].content));
  970. iret =X28_data_send(smsc->sema_fd,IA5buff,strlen(IA5buff));
  971. if(iret == -1)
  972.     goto error;
  973. octstr_destroy(segments[i].content);
  974.     }
  975.     gw_free(segments);
  977.     /*wait result and report return*/
  978.     mtrmsg = sema_msg_new();
  979.     memset(mochars,0,sizeof(mochars));
  981.     time(&tstart);
  982.     while(time(NULL) -tstart < INTERNAL_SESSION_MT_TIMEVAL){
  983. iret = X28_data_read(smsc->sema_fd, smsc->buffer);
  984. if(iret == -1)
  985.     goto error;
  987. /* Interpret the raw data */
  988. memset(data,0,sizeof(data));
  989. while(X28_msg_pop(smsc->buffer, data) == 0 ) {
  990.     if(strlen(data) > 0){
  991. if(strstr(data,cerr) != NULL ||
  992.    strstr(data,cclr) != NULL){
  993.   debug("smsc.sema", 0, "sema_mt_session: Radio Pad Command line-%s",data);
  994.     goto sendlink_error;
  995. }
  996. /* decode msg*/      
  997. decoderesult = sema_decode_msg(&mtrmsg,data);  
  998. if(decoderesult >= 0){
  999.     if(mtrmsg->type == 's'){ /*submit result*/
  1000.  
  1001. submit_result = (struct sm_submit_result*)(*mtrmsg->msgbody);
  1002. if(submit_result == NULL) goto error;
  1003. /* check result operation number is what we send */
  1004. memset(tmp1,0,5); memset(tmp2,0,5);
  1005. memcpy(tmp1,mtrmsg->optref,4);
  1006. memcpy(tmp2, pmsg->optref,4);
  1007. if(strstr(tmp1,tmp2) != NULL){
  1008.     isrcved = 1;
  1009.     memcpy(submit_invoke->smscrefnum, submit_result->smscrefnum,4);
  1010. }
  1011. if(isrcved == 1 &&
  1012.    submit_result->smeresult != 0){  
  1013.     gw_free(submit_result);
  1014.     goto smsc_say_fail;  
  1015. }
  1016. gw_free(submit_result);
  1018.     } 
  1019.     else if(mtrmsg->type == 'T'){ /*report invoke*/
  1021. report_invoke=(struct sm_statusreport_invoke*)(*mtrmsg->msgbody);
  1022. if(report_invoke == NULL) goto error;
  1023. /*check if report reference number is what we expect*/
  1024. memset(tmp1,0,sizeof(tmp1)); memset(tmp2,0,sizeof(tmp2));
  1025. memcpy(tmp1,report_invoke->smscrefnum,4);
  1026. memcpy(tmp2,submit_invoke->smscrefnum,4);
  1027. if(strstr(tmp1, tmp2) != NULL){
  1028.     iTrcved = 1;
  1029. }
  1030. decoderesult = 0; 
  1031. iret = sema_submit_result(smsc, mtrmsg, decoderesult);
  1032. if(iret == -1) goto error;
  1033. if(iTrcved == 1 &&
  1034.    report_invoke->status != 3){ /*3 means ,msg delivered*/
  1035.     info(0,"sema_mt_session: submit invoke failed with report value-%i",report_invoke->status);
  1036.     gw_free(report_invoke);
  1037.     goto smsc_say_fail;
  1038. }
  1039. gw_free(report_invoke);
  1041.     }
  1042.     else if(mtrmsg->type == 'M'){/* deliver invoke*/
  1043.   
  1044. /* we do not deal with deliver in mt session*/ 
  1045. decoderesult = 0;
  1046. iret = sema_submit_result(smsc, mtrmsg, decoderesult);
  1047. if(iret == -1) goto error;
  1048. deliver_invoke =(struct sm_deliver_invoke*)(*mtrmsg->msgbody);
  1049. if(deliver_invoke != NULL){
  1050.     gw_free(deliver_invoke);
  1051.     /*append buffer back to  smsc->buffer*/
  1052.     ilen=strlen(mochars);
  1053.     memcpy(mochars+ilen,data,strlen(data));
  1054.     ilen=strlen(mochars);
  1055.     memcpy(mochars+ilen,&ccr,1);
  1056. }
  1057. time(&tstart);
  1058.     }
  1059.     /* clean msg for next read*/
  1060.     memset(mtrmsg,0,sizeof(struct sema_msg));
  1061. }
  1062. /* clean buffer for next useful info*/
  1063. memset(data,0,sizeof(data));
  1064. if(sema_wait_report == 0 && isrcved == 1)
  1065. {
  1066.     info(0,"sema_mt_session: submit invoke deliver successfully to smsc");
  1067.     goto mo_success;
  1068. }
  1069. if(sema_wait_report > 0 &&
  1070.    isrcved == 1 && iTrcved == 1)
  1071. {
  1072.     info(0,"sema_mt_session: submit invoke deliver sucessfully to msisdn");
  1073.     goto mo_success;
  1074. }
  1075.     }
  1076. }
  1077.     }
  1079. /* mo_timeout: */
  1080.       info(0,"sema_mt_session: time out without receive all expected return");
  1081.       moret = SESSION_MT_RECEIVE_TIMEOUT;
  1082.       goto mo_return;
  1083. mo_success:
  1084.     moret = SESSION_MT_RECEIVE_SUCCESS;
  1085.     goto mo_return;
  1086. smsc_say_fail:
  1087.     info(0,"sema_mt_session: smsc says message deliver failed!");
  1088.     moret = SESSION_MT_RECEIVE_ERR;
  1089.     goto mo_return;
  1090. mo_return:
  1091.     X28_close_send_link(smsc->sema_fd);
  1092.     /* we have to close here, otherwise smsc will wait for a long time
  1093.        untill it find out nothing is coming */
  1094.     sema_msg_free(mtrmsg);
  1095.     ilen = strlen(mochars);
  1096.     i =  strlen(smsc->buffer);
  1097.     if(ilen > 0){
  1098. memmove( smsc->buffer+ilen,smsc->buffer,i);
  1099. memcpy(smsc->buffer, mochars,ilen);
  1100.     }
  1101.     return moret;      
  1102. sendlink_error:
  1103.     info(0,"sema_mt_session: X28 data link has broken");
  1104.     if(mtrmsg != NULL)
  1105. sema_msg_free(mtrmsg);
  1106.     return 0;
  1107. encode_error:
  1108.     info(0,"sema_mt_session: Msg encode error");
  1109.     return 0;
  1110. error:
  1111.     error(0,"sema_mt session: memory allocation error or device file error");
  1112.     return -1;
  1114. }
  1117. static int sema_msg_session_mo(SMSCenter *smsc, char* cbuff){
  1118.   
  1119.     struct sema_msg *rmsg = NULL;
  1120.     int iret = 0, retresult = 0;
  1122.     struct sm_deliver_invoke* deliver_invoke = NULL;
  1123.     struct sm_statusreport_invoke* report_invoke = NULL;
  1124.  
  1125.     rmsg = sema_msg_new();
  1127.     iret = sema_decode_msg(&rmsg,cbuff);
  1128.     if(iret == - 1) goto msg_error;/* decode error */
  1130.     if(x28_data_mode == X28_COMMAND_MODE){
  1131. /* do not trust any existing data mode*/
  1133. /* XXX this should be fixed? -rpr */
  1135. X28_close_send_link(smsc->sema_fd); 
  1136. /*open send link*/
  1137. if(X28_open_send_link(smsc->sema_fd,smsc->sema_smscnua) < 1){
  1138.     info(0,"sema_mo_session: can not establish send link");
  1139.     return 0;
  1140. }   
  1141.     }
  1143.     if(rmsg->type == 'M'){  /* deliver invoke */
  1144. retresult = 0;   /* deliver invoke */  
  1145. iret = sema_submit_result(smsc, rmsg, retresult); 
  1146. if(iret == -1) goto error;
  1147. deliver_invoke= (struct sm_deliver_invoke*) (*rmsg->msgbody);
  1148. if(deliver_invoke == NULL) goto msg_error;
  1149. sema_msglist_push(smsc->sema_mo, rmsg);  
  1150. return 1;
  1151.     }
  1152.     else if(rmsg->type == 'T'){ /* status report */
  1153. retresult = 0;  /* let msg through */
  1154. sema_submit_result(smsc, rmsg, retresult);
  1155. if(iret == -1) goto error;
  1156. report_invoke = (struct sm_statusreport_invoke*)(*rmsg->msgbody);
  1157. if(report_invoke != NULL)  
  1158.     gw_free(report_invoke);
  1159.     }
  1160.     else{ /* add your additional support here*/
  1161.     }
  1162.     sema_msg_free(rmsg);
  1163.     return 1;
  1164.   
  1165. msg_error:
  1166.     sema_msg_free(rmsg);
  1167.     error(0,"sema_mo session: Msg decode failed");
  1168.     return 0;
  1169. error:  
  1170.     error(0,"sema_mo session: device file error or memory allocated problem!");
  1171.     return -1;
  1172. }
  1176. static int sema_decode_msg(sema_msg **desmsg, char* octsrc) {
  1177.     struct sm_deliver_invoke *receive_sm = NULL;
  1178.     struct sm_statusreport_invoke* receive_report = NULL;
  1179.     struct sm_submit_result* submit_result = NULL;
  1181.     unsigned char tmp[1024],tmpgsm[1024];
  1182.     int octetlen, iret, iusedbyte;
  1183.     int imsgtopseg = 0, imsgfollownum = 0, imsgencodetype = 0;
  1184.     unsigned char cmsgtype, cmsgcontinuebyte;
  1186.     /* message type */
  1187.     if(strlen(octsrc) <= 4) goto no_msg;
  1189.     /* check if we support this type */
  1190.     cmsgtype = *octsrc;
  1191.     if(cmsgtype != 's'  /* invoke reseult */
  1192.        && cmsgtype != 'M'   /* deliver invoke */
  1193.        && cmsgtype != 'T'){   /* report invoke */
  1194. info(0,"sema_decode: msg type not support");
  1195. goto error_msg;
  1196.     }
  1198.     /*check if continue bit is correct */
  1199.     cmsgcontinuebyte = *(octsrc+1);
  1200.     iret = unpack_continous_byte(cmsgcontinuebyte,
  1201.  &imsgencodetype,&imsgtopseg, &imsgfollownum);
  1203.     if(iret == -1){
  1204. info(0,"sema_decode: msg continue bit can not be interpret");
  1205. goto error_msg;
  1206.     }
  1208.     /*status report and submit result will always be 1 segments
  1209.       for deliver invoke, if smsc can not send all the data in one packet,
  1210.       text data will be truncated ,so it's also 1 packet*/
  1212.     if(imsgtopseg == 0){
  1213. info(0, "sema_decode: can not interpret more than one segments msg");
  1214. goto error_msg;
  1215.     }
  1217.     (*desmsg)->type = cmsgtype;
  1218.     (*desmsg)->continuebyte = cmsgcontinuebyte;
  1219.     (*desmsg)->encodetype = imsgencodetype;
  1221.     /*operation reference*/
  1223.     memcpy((*desmsg)->optref, octsrc +2, 4);
  1224.     octsrc += 6;
  1225.     iusedbyte = 0;
  1226.  
  1227.     switch(cmsgtype){
  1228.     case 's': /* submit invoke result */
  1229. submit_result = gw_malloc(sizeof(struct sm_submit_result)); 
  1230. memset(submit_result,0,sizeof(struct sm_submit_result));
  1232. /* result */ 
  1233. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1234. if(iusedbyte < 1) goto error_submit;
  1235. octetlen = 1;
  1236. submit_result->smeresult = get_variable_value(tmp, &octetlen);
  1237. if(submit_result->smeresult == SM_RESULT_SUCCESS)
  1238. {
  1239.     /*smsc reference number*/
  1240.     octsrc += iusedbyte;
  1241.     iusedbyte = line_scan_IA5_hex(octsrc, 4,tmp);
  1242.     if(iusedbyte <1) goto error_submit;
  1243.     memcpy(submit_result->smscrefnum, tmp, 4);
  1244.     /*accept time*/
  1245.     octsrc += iusedbyte;  
  1246.     iusedbyte = line_scan_IA5_hex(octsrc, 14,tmp);
  1247.     if(iusedbyte < 1) goto error_submit;
  1248.     memcpy(submit_result->accepttime, tmp, 4);
  1249. }
  1250. (*desmsg)->msgbody = (void**)&submit_result;
  1251. break;
  1252.     case 'M': 
  1253. /* deliver invoke*/
  1254. receive_sm = gw_malloc(sizeof(struct sm_deliver_invoke));
  1255. memset(receive_sm, 0, sizeof(struct sm_deliver_invoke));
  1256. /*deliver destination address length*/
  1257. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1258. if(iusedbyte < 1) goto error_deliver;
  1259. octetlen = 1;
  1260. receive_sm->destaddlen = get_variable_value(tmp, &octetlen);
  1261. /*deliver destination address*/
  1262. octsrc +=iusedbyte;    
  1263. iusedbyte = line_scan_IA5_hex(octsrc,receive_sm->destaddlen,tmp);
  1264. if(iusedbyte < 1) goto error_deliver;
  1265. receive_sm->destadd= octstr_create_from_data(tmp,  receive_sm->destaddlen);
  1266. /*smsc reference number*/
  1267. octsrc +=iusedbyte;
  1268. iusedbyte = line_scan_IA5_hex(octsrc, 4,tmp);
  1269. if(iusedbyte < 1) goto error_deliver;
  1270. memcpy(receive_sm->smscrefnum, tmp, 4);
  1271. /*originate address length*/
  1272. octsrc +=iusedbyte;
  1273. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1274. if(iusedbyte < 1) goto error_deliver;
  1275. octetlen = 1;
  1276. receive_sm->origaddlen = get_variable_value(tmp, &octetlen);
  1277. /*originate address*/
  1278. octsrc +=iusedbyte;
  1279. iusedbyte = line_scan_IA5_hex(octsrc, receive_sm->origaddlen, tmp);
  1280. if(iusedbyte < 1) goto error_deliver;
  1281. receive_sm->origadd= octstr_create_from_data(tmp,receive_sm->origaddlen);
  1282. /* data code scheme */ 
  1283. octsrc +=iusedbyte;
  1284. if(iusedbyte < 1) goto error_deliver;
  1285. iusedbyte = line_scan_IA5_hex(octsrc, 1,tmp);
  1286. octetlen = 1;
  1287. receive_sm->DCS = get_variable_value(tmp, &octetlen);
  1288. if(receive_sm->DCS != ENCODE_IA5 && receive_sm->DCS !=ENCODE_GSM){
  1289.     info(0, "sema_decode, Data encoding scheme not support");
  1290.     goto error_deliver;
  1291. }
  1292. /* protocol */ 
  1293. octsrc +=iusedbyte;
  1294. iusedbyte = line_scan_IA5_hex(octsrc, 1,tmp);
  1295. if(iusedbyte < 1) goto error_deliver;
  1296. octetlen = 1;
  1297. receive_sm->protocal = get_variable_value(tmp, &octetlen);
  1298. /* reply path */
  1299. octsrc +=iusedbyte;
  1300. iusedbyte = line_scan_IA5_hex(octsrc, 1,tmp);
  1301. if(iusedbyte < 1) goto error_deliver;
  1302. octetlen = 1;
  1303. receive_sm->replypath = get_variable_value(tmp, &octetlen);
  1304. /*text size in septect*/
  1305. octsrc +=iusedbyte;
  1306. iusedbyte = internal_char_IA5_to_hex(octsrc, tmp);
  1307. if(iusedbyte < 1) goto error_deliver;
  1308. receive_sm->textsizeseptet = tmp[0];
  1309. /*text size in octects*/
  1310. octsrc +=iusedbyte;
  1311. iusedbyte = internal_char_IA5_to_hex(octsrc, tmp);
  1312. if(iusedbyte < 1) goto error_deliver;
  1313. receive_sm->textsizeoctect = tmp[0];
  1314. octsrc+=iusedbyte;
  1316. /*message text*/
  1318. iusedbyte = 0;
  1319. memset(tmp,0,sizeof(tmp));
  1320. if(receive_sm->DCS == ENCODE_IA5 && receive_sm->textsizeoctect > 0) 
  1321. {
  1322.     iusedbyte = line_scan_IA5_hex(octsrc,receive_sm->textsizeoctect,tmp);    
  1323.     if(iusedbyte < 1) goto error_deliver;
  1324.     receive_sm->shortmsg =octstr_create_from_data( tmp,receive_sm->textsizeoctect);
  1325. }
  1326. else if(receive_sm->DCS == ENCODE_GSM &&  receive_sm->textsizeseptet > 0)
  1327. {
  1328.     memset(tmpgsm,0,sizeof(tmpgsm));
  1329.   
  1330.     iusedbyte = line_scan_IA5_hex(octsrc,receive_sm->textsizeoctect,tmp);
  1331.     if(iusedbyte < 1) goto error_deliver;
  1332.     line_scan_hex_GSM7(tmp,receive_sm->textsizeoctect,
  1333.        receive_sm->textsizeseptet, tmpgsm);
  1334.     receive_sm->shortmsg = octstr_create_from_data(tmpgsm,
  1335.    receive_sm->textsizeseptet);
  1337. }
  1338. else if(receive_sm->textsizeoctect <= 0)
  1339.   receive_sm->shortmsg = octstr_create("");
  1341. /*accepttime*/
  1342. octsrc +=iusedbyte;
  1343. iusedbyte = line_scan_IA5_hex(octsrc,14,tmp);
  1344. if(iusedbyte < 1) goto error_deliver;
  1345. memcpy(receive_sm->accepttime, tmp,14);
  1346. /*valid time*/
  1347. octsrc +=iusedbyte;
  1348. iusedbyte = line_scan_IA5_hex(octsrc,14,tmp);
  1349. if(iusedbyte < 1) goto error_deliver;
  1350. memcpy(receive_sm->invoketime, tmp,14);
  1351. (*desmsg)->msgbody = (void**)&receive_sm;
  1352. break;
  1353.     case 'T': 
  1354. /* status report invoke */
  1355. receive_report = gw_malloc(sizeof(struct sm_statusreport_invoke)); 
  1356. memset(receive_report,0,sizeof(struct sm_statusreport_invoke));
  1357. /*deliver msisdn address length*/
  1358. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1359. if(iusedbyte < 1) goto error_receive;
  1360. octetlen = 1;
  1361. receive_report->msisdnlen = get_variable_value(tmp, &octetlen);
  1362. /*msisdn*/
  1363. octsrc += iusedbyte;    
  1364. iusedbyte = line_scan_IA5_hex(octsrc, receive_report->msisdnlen, tmp);
  1365. if(iusedbyte < 1) goto error_receive;
  1366. receive_report->msisdn = octstr_create_from_data( tmp,receive_report->msisdnlen);
  1367. /*sme reference type*/
  1368. octsrc += iusedbyte;
  1369. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1370. if(iusedbyte < 1) goto error_receive;
  1371. octetlen = 1;
  1372. receive_report->smetype = get_variable_value(tmp, &octetlen);
  1373. /*sme reference number */
  1374. octsrc += iusedbyte;    
  1375. iusedbyte = line_scan_IA5_hex(octsrc,4, tmp);
  1376. if(iusedbyte < 1) goto error_receive;
  1377. memcpy(receive_report->smerefnum ,tmp, 4);
  1378. /*smsc reference number */
  1379. octsrc += iusedbyte;
  1380. iusedbyte = line_scan_IA5_hex(octsrc,4, tmp);
  1381. if(iusedbyte < 1) goto error_receive;
  1382. memcpy(receive_report->smscrefnum ,tmp, 4);
  1383. /*accepted time*/ 
  1384. octsrc += iusedbyte;    
  1385. iusedbyte = line_scan_IA5_hex(octsrc,14, tmp);
  1386. if(iusedbyte < 1) goto error_receive;
  1387. memcpy(receive_report->accepttime ,tmp, 4);
  1388. /*status*/
  1389. octsrc += iusedbyte;    
  1390. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1391. if(iusedbyte < 1) goto error_receive;
  1392. octetlen = 1; 
  1393. receive_report->status = get_variable_value(tmp, &octetlen);
  1394. octsrc += iusedbyte;
  1395. if(receive_report->status != 6) /*6 means unable to deliver , but retry*/
  1396. {
  1397.     iusedbyte = line_scan_IA5_hex(octsrc,14, tmp);
  1398.     if(iusedbyte < 1) goto error_receive;
  1399.     memcpy(receive_report->completetime ,tmp, 14);
  1400. }
  1401. else
  1402. {
  1403.     iusedbyte = line_scan_IA5_hex(octsrc,14, tmp);
  1404.     if(iusedbyte < 1) goto error_receive;
  1405.     memcpy(receive_report->intermediatime ,tmp, 14);
  1406. }
  1407. if(receive_report->status == 6 || receive_report->status == 1) /*unable to deliver ,both case */
  1408. {       
  1409.     octsrc += iusedbyte;
  1410.     iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1411.     if(iusedbyte < 1) goto error_receive;
  1412.     octetlen = 1;
  1413.     receive_report->failreason = get_variable_value(tmp, &octetlen);
  1414. }
  1415. /*deliver orignate address length*/
  1416. octsrc += iusedbyte;
  1417. iusedbyte = line_scan_IA5_hex(octsrc, 1, tmp);
  1418. if(iusedbyte < 1) goto error_receive;
  1419. octetlen = 1;
  1420. receive_report->origaddlen = get_variable_value(tmp, &octetlen);
  1421. /*orignate address*/
  1422. octsrc += iusedbyte;
  1423. iusedbyte = line_scan_IA5_hex(octsrc, receive_report->origaddlen, tmp);
  1424. if(iusedbyte < 1) goto error_receive;
  1425. receive_report->origadd = octstr_create_from_data(tmp,  receive_report->msisdnlen);
  1426. /* invoke time */
  1427. octsrc += iusedbyte;     
  1428. iusedbyte = line_scan_IA5_hex(octsrc,14, tmp);
  1429. if(iusedbyte < 1){
  1430.     goto error_receive;
  1431. }
  1432. memcpy(receive_report->invoketime ,tmp, 14);
  1433. (*desmsg)->msgbody = (void**)&receive_report;
  1434. break;
  1435.     }
  1436.     return 1;
  1438. no_msg:
  1439.     info(0,"sema_decode: msg in empty");
  1440.     return 0;
  1441. error_receive:
  1442.     gw_free(receive_report);
  1443.     goto error_msg;
  1444. error_submit:
  1445.     gw_free(submit_result);
  1446.     goto error_msg;
  1447. error_deliver:
  1448.     gw_free(receive_sm);
  1449.     goto error_msg;
  1450. error_msg:
  1451.     info(0,"sema_decode:msg parameter is not recognized or unsupported");
  1452.     return 0;
  1453. }
  1456. static int sema_encode_msg(sema_msg* pmsg, char* str) {
  1457.     struct sm_submit_invoke *submit_sm = NULL;
  1458.     Octstr *IA5msg = NULL;
  1459.     int tSize = 0;
  1460.     unsigned char oc1byte[10];
  1461.     IA5msg = octstr_create("");
  1462.     switch(pmsg->type)
  1463.     {
  1464.     case 'S':
  1465. submit_sm = (struct sm_submit_invoke *)(*(pmsg->msgbody)); 
  1466. write_variable_value(submit_sm->msisdnlen, oc1byte); /*msisdn len*/
  1467. line_append_hex_IA5(IA5msg, oc1byte,1);
  1468. line_append_hex_IA5(IA5msg, 
  1469.     octstr_get_cstr(submit_sm->msisdn),
  1470.     octstr_len(submit_sm->msisdn)); /*msisdn*/
  1471. write_variable_value(submit_sm->smereftype, oc1byte);/*smetype*/
  1472. line_append_hex_IA5(IA5msg, oc1byte,1);
  1473. line_append_hex_IA5(IA5msg, submit_sm->smerefnum,4);/*sme reference*/
  1474. write_variable_value(submit_sm->priority, oc1byte);/*priority*/
  1475. line_append_hex_IA5(IA5msg, oc1byte,1);
  1476. write_variable_value(submit_sm->origaddlen, oc1byte); /*orignating address length*/
  1477. line_append_hex_IA5(IA5msg, oc1byte,1);
  1478. line_append_hex_IA5(IA5msg, 
  1479.     octstr_get_cstr(submit_sm->origadd),
  1480.     octstr_len(submit_sm->origadd)); /*orignating address*/
  1481. write_variable_value(submit_sm->validperiodtype, oc1byte); /*valid period type*/
  1482. line_append_hex_IA5(IA5msg, oc1byte,1);
  1483. write_variable_value(submit_sm->validperiodrela, oc1byte); /*relative period*/
  1484. line_append_hex_IA5(IA5msg, oc1byte,1);
  1485. write_variable_value(submit_sm->DCS, oc1byte);/*data code scheme*/
  1486. line_append_hex_IA5(IA5msg, oc1byte,1);
  1487. write_variable_value(submit_sm->statusreportrequest, oc1byte);/*request report*/
  1488. line_append_hex_IA5(IA5msg, oc1byte,1);
  1489. write_variable_value(submit_sm->protocal, oc1byte);/*protocal id*/
  1490. line_append_hex_IA5(IA5msg, oc1byte, 1);
  1491. write_variable_value(submit_sm->replypath, oc1byte);/*use reply path*/
  1492. line_append_hex_IA5(IA5msg, oc1byte, 1);
  1494.             /*text size in 7 bits char*/
  1495.        tSize = internal_char_hex_to_IA5(submit_sm->textsizeseptet,oc1byte);
  1496. octstr_insert_data(IA5msg, octstr_len(IA5msg), oc1byte, tSize);
  1498.             /*text size in 8 bits char*/
  1499. tSize = internal_char_hex_to_IA5(submit_sm->textsizeoctect,oc1byte);  
  1500.   octstr_insert_data(IA5msg, octstr_len(IA5msg), oc1byte, tSize);
  1502. line_append_hex_IA5(IA5msg,       
  1503.     octstr_get_cstr(submit_sm->shortmsg),
  1504.     submit_sm->textsizeoctect); /*msg text*/
  1505. memcpy(str,octstr_get_cstr(IA5msg),octstr_len(IA5msg));
  1506. octstr_destroy(IA5msg);
  1507. return 1;
  1508.     }
  1509.     return 0;
  1510. }
  1513. static int line_scan_hex_GSM7(unsigned char* from, 
  1514.       int octects ,int spetets, unsigned char* to)
  1515. {
  1516.     char* cin2 =NULL;
  1517.     unsigned char c;
  1518.     char cin7[8];
  1519.     int i, pos, value;
  1521.     int lenin2=octects*8;
  1522.     cin2 = gw_malloc(lenin2);
  1524.     memset(cin2,48,lenin2); /*make many zeros*/
  1525.     /*tranverse the octects first, so ABC -> CBA(in bin form)*/
  1526.     for(i = 0; i < octects; i ++)
  1527.     {
  1528. c = *(from + i);
  1529.       
  1530. if(c & 1) 
  1531.     cin2[(octects-1-i)*8 +7] = 49;
  1532. if(c & 2) 
  1533.     cin2[(octects-1-i)*8 +6] = 49;
  1534. if(c & 4) 
  1535.     cin2[(octects-1-i)*8 +5] = 49;
  1536. if(c & 8) 
  1537.     cin2[(octects-1-i)*8 +4] = 49;
  1538. if(c & 16) 
  1539.     cin2[(octects-1-i)*8 +3] = 49;
  1540. if(c & 32) 
  1541.     cin2[(octects-1-i)*8 +2] = 49;
  1542. if(c & 64) 
  1543.     cin2[(octects-1-i)*8 +1] = 49;
  1544. if(c & 128) 
  1545.     cin2[(octects-1-i)*8] = 49;
  1546.     }
  1547.   
  1548.     i= 1;
  1549.     while( i <= spetets ){
  1550. pos=lenin2 -1 -(i*7 -1);
  1551. memset(cin7,0,sizeof(cin7));
  1552. memcpy(cin7, cin2 + pos, 7);
  1553. value = 0;
  1555. if(cin7[6] == '1')
  1556.     value += 1;
  1557. if(cin7[5] == '1')
  1558.     value += 2;
  1559. if(cin7[4] == '1')
  1560.     value += 4;
  1561. if(cin7[3] == '1')
  1562.     value += 8;
  1563. if(cin7[2] == '1')
  1564.     value += 16;
  1565. if(cin7[1] == '1')
  1566.     value += 32;
  1567. if(cin7[0] == '1')
  1568.     value += 64;
  1569.   
  1570. to[i-1]=internal_char_hex_to_gsm(value);
  1571. i +=1;
  1572.     }
  1573.     return i;
  1574.   
  1575. }
  1577. /* check SMS2000 Version 4.0 B.4.2.3 */
  1578. static int line_append_hex_IA5(Octstr* des, unsigned char* src, int len)
  1579. {
  1581.     unsigned char IA5char[3];
  1582.     unsigned char tmp[1024];
  1583.     int j=0;
  1584.     int i=0, iall=0;
  1585.     for(i=0; i<len; i++)
  1586.     {
  1587. memset(IA5char, 0, sizeof(IA5char));
  1588. j=internal_char_hex_to_IA5(*(src+i),IA5char);
  1589. if(j >0){
  1590.     memcpy(tmp+iall,IA5char,j);
  1591.     iall += j;
  1592. }
  1593.     }
  1594.     octstr_insert_data(des,octstr_len(des),tmp,iall);
  1595.     return iall;
  1596. }
  1599. /* check SMS2000 Version 4.0 B.4.2.3 */
  1600. static int line_scan_IA5_hex(unsigned char* from, 
  1601.      int hexnum, unsigned char* to)
  1602. {
  1603.     unsigned char cha[1];
  1604.     int cn =0, cnall = 0, i = 0;
  1605.     char *tmpfrom = NULL;
  1606.     tmpfrom = from;
  1607.     for(i = 0; i< hexnum; i++)
  1608.     {
  1609. cn=internal_char_IA5_to_hex(tmpfrom, cha);
  1610. if(cn >0)
  1611. {
  1612.     memcpy(to+i,cha,1);
  1613.     tmpfrom += cn;
  1614.     cnall += cn;
  1615. }
  1616. else
  1617.     return -1;
  1618.     }
  1619.     return cnall;
  1620. }
  1623. static unsigned char internal_char_hex_to_gsm(unsigned char from)
  1624. {
  1625.     switch (from){
  1626.     case 0x00: return '@';
  1627.     case 0x01: return '