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

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

手机WAP编程

开发平台：

WINDOWS

smsc_at.c：源码内容
  1. /*
  2.  * smsc_at.c - implement interface to wireless modems using AT commands
  3.  *
  4.  * Yann Muller, Nick Clarey - 3G Lab, 2001.
  5.  * 
  6.  * Ericsson code by Chris Blown 30/01/2001 - Hinterlands Aust.
  7.  *
  8.  * Make sure your kannel configuration file contains the following lines
  9.  * to be able to use the AT SMSC:
  10.  *     group = smsc
  11.  *     smsc = at
  12.  *     modemtype = wavecom | premicell | siemens | siemens-tc35 | falcom |
  13.  *                 nokiaphone | ericsson
  14.  *     device = /dev/xxx 
  15.  */
  18. #include <errno.h>
  19. #include <stdarg.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <unistd.h>
  24. #include <fcntl.h>
  25. #include <ctype.h>
  26. #include <termios.h>
  27. #include <sys/time.h>
  28. #include <sys/types.h>
  29. #include <sys/socket.h>
  30. #include <netinet/in.h>
  31. #include <netdb.h>
  32. #include <sys/ioctl.h>
  33. #include <time.h>
  35. #include "gwlib/gwlib.h"
  36. #include "gwlib/charset.h"
  37. #include "smsc.h"
  38. #include "smsc_p.h"
  39. #include "sms.h"
  41. #ifndef CRTSCTS
  42. #define CRTSCTS 0
  43. #endif
  45. /* The number of times to attempt to send a message should sending fail */
  46. #define RETRY_SEND 3
  48. /******************************************************************************
  49.  * Prototypes for private functions
  50.  */
  51. static int at_data_read(int fd, Octstr *ostr);
  52. static int send_modem_command(int fd, char *cmd, int multiline);
  53. static int pdu_extract(SMSCenter *smsc, Octstr **ostr);
  54. static Msg *pdu_decode(Octstr *data);
  55. static Msg *pdu_decode_deliver_sm(Octstr *data);
  56. static int pdu_encode(Msg *msg, unsigned char *pdu, SMSCenter *smsc);
  57. static Octstr *convertpdu(Octstr *pdutext);
  58. static int hexchar(int hexc);
  59. static int encode7bituncompressed(Octstr *input, unsigned char *encoded, int offset);
  60. static int encode8bituncompressed(Octstr *input, unsigned char *encoded);
  61. static void decode7bituncompressed(Octstr *input, int len, Octstr *decoded, int offset);
  62. static int numtext(int num);
  64. /******************************************************************************
  65.  * Types of GSM modems (as used in kannel.conf: at_type=xxxx)
  66.  */
  67. #define WAVECOM         "wavecom"
  68. #define PREMICELL       "premicell"
  69. #define SIEMENS         "siemens"
  70. #define SIEMENS_TC35 "siemens-tc35"
  71. #define FALCOM          "falcom"
  72. #define NOKIAPHONE      "nokiaphone"
  73. #define ERICSSON        "ericsson"
  75. /******************************************************************************
  76.  * Message types defines
  77.  */
  78. #define AT_DELIVER_SM   0
  79. #define AT_SUBMIT_SM    1
  81. /******************************************************************************
  82.  * type of phone number defines
  83.  */
  84. #define PNT_UNKNOWN     0
  85. #define PNT_INTER       1
  86. #define PNT_NATIONAL    2
  88. /******************************************************************************
  89.  * Open the connection
  90.  *
  91.  * returns the file descriptor (fd) if ok, -1 on failure
  92.  */
  93. static int at_open_connection(SMSCenter *smsc) {
  94.         int fd = -1;
  95.         struct termios tios;
  96.         int ret;
  97.         
  98.         fd = open(smsc->at_serialdevice, O_RDWR|O_NONBLOCK|O_NOCTTY);
  99.         if(fd == -1) {
  100.                 error(errno, "at_open_data_link: error opening the character device <%s>",
  101.                       smsc->at_serialdevice);
  102.                 return -1;
  103.         }
  105.         tcgetattr(fd, &tios);
  106.         if((strcmp(smsc->at_modemtype, SIEMENS) == 0) 
  107.    || (strcmp(smsc->at_modemtype, SIEMENS_TC35) == 0)
  108.            || (strcmp(smsc->at_modemtype, NOKIAPHONE) == 0)) {
  109.                 cfsetospeed(&tios, B19200);  /* check radio pad parameter*/
  110.                 cfsetispeed(&tios, B19200);
  111.         } else {
  112.                 cfsetospeed(&tios, B9600);  /* check radio pad parameter*/
  113.                 cfsetispeed(&tios, B9600);
  114.         }
  115.         kannel_cfmakeraw(&tios);
  116.         /* parameters:
  117.          * IGNBRK, IGNPAR: ignore BREAK and PARITY errors
  118.          * INPCK: enable parity check
  119.          * CSIZE: for CS8
  120.          * HUPCL: hang up on close
  121.          * CREAD: enable receiver
  122.          * CRTSCTS: enable flow control */
  123.         tios.c_iflag |= IGNBRK | IGNPAR | INPCK;
  124.         tios.c_cflag |= CSIZE | HUPCL | CREAD | CRTSCTS;
  125.         if (strcmp(smsc->at_modemtype, NOKIAPHONE) == 0)
  126.                 tios.c_cflag ^= PARODD;
  127.         tios.c_cflag |=CS8;
  128.         ret = tcsetattr(fd, TCSANOW, &tios); /* apply changes now */
  129.         if(ret == -1){
  130.                 error(errno,"at_data_link: fail to set termios attribute");
  131.                 goto error;
  132.         }
  133.         tcflush(fd, TCIOFLUSH);
  134.         return fd;
  135.   
  136.  error:
  137.         return -1;
  138. }
  140. /******************************************************************************
  141.  * Open the (Virtual) SMSCenter
  142.  */
  143. SMSCenter *at_open(char *serialdevice, char *modemtype, char *pin,
  144.                    char *validityperiod, int alt_dcs) 
  145. {
  146.         SMSCenter *smsc;
  147.         char setpin[20];
  148.         int ret;
  149.         
  150.         smsc = smscenter_construct();
  151.         if(smsc == NULL)
  152.                 goto error;
  154.         smsc->type = SMSC_TYPE_AT;
  155.         smsc->at_serialdevice = gw_strdup(serialdevice);
  156.         if (validityperiod != NULL)
  157.                 smsc->at_validityperiod = gw_strdup(validityperiod);
  158.         smsc->at_modemtype = gw_strdup(modemtype);
  159.         if(pin)
  160.                 smsc->at_pin = gw_strdup(pin);
  161.         smsc->at_received = list_create();
  162.         smsc->at_inbuffer = octstr_create("");
  163. smsc->at_alt_dcs = alt_dcs;
  164.         
  165.         smsc->at_fd = at_open_connection(smsc);
  166.         if (smsc->at_fd < 0)
  167.                 goto error;
  169.         /* Nokia 7110 and 6210 need some time between opening
  170.          * the connection and sending the first AT commands */
  171.         if (strcmp(smsc->at_modemtype, NOKIAPHONE) == 0) 
  172.                 sleep(1);
  174. /* lets initialize the modem to a safe state */
  175.         send_modem_command(smsc->at_fd, "AT", 0);
  176.         send_modem_command(smsc->at_fd, "AT&F", 0);
  177.         send_modem_command(smsc->at_fd, "AT", 0);
  179.         /* Turn Echo off on the modem: we don't need it */
  180.         if(send_modem_command(smsc->at_fd, "ATE0", 0) == -1)
  181.   {
  182.   /* ok that was the first command we tried. */
  183.                 goto error;
  184. }
  185. /* Let's collect some information from modem */
  186. if(send_modem_command(smsc->at_fd, "ATI", 0) == -1)
  187.     goto error;
  188. sleep(1);
  189. if(send_modem_command(smsc->at_fd, "ATI1", 0) == -1)
  190.     goto error;
  191. sleep(1);
  192. if(send_modem_command(smsc->at_fd, "ATI2", 0) == -1)
  193.     goto error;
  194. sleep(1);
  195. if(send_modem_command(smsc->at_fd, "ATI3", 0) == -1)
  196.     goto error;
  197. sleep(1);
  198. if(send_modem_command(smsc->at_fd, "ATI4", 0) == -1)
  199.     goto error;
  200. sleep(1);
  202.         /* Check does the modem require a PIN and, if so, send it
  203.          * This is not supported by the Nokia Premicell */
  204.         if(strcmp(smsc->at_modemtype, PREMICELL) != 0) {
  205.                 ret = send_modem_command(smsc->at_fd, "AT+CPIN?", 0); 
  206.                 if(ret == -1)
  207.                         goto error;
  208.                 if(ret == -2) {
  209.                         if(smsc->at_pin == NULL)
  210.                                 goto error;
  211.                         sprintf(setpin, "AT+CPIN=%s", smsc->at_pin);
  212.                         if(send_modem_command(smsc->at_fd, setpin, 0) == -1)
  213.                                 goto error;
  214.                 }
  215.         }
  217.         /* Set the modem to PDU mode and autodisplay of new messages */
  218.         if(send_modem_command(smsc->at_fd, "AT+CMGF=0", 0) == -1)
  219.                 goto error;
  221. sleep(1);
  223.         /* The Ericsson GM12 modem requires different new message 
  224.          * indication options from the other modems */ 
  225.         if(strcmp(smsc->at_modemtype, ERICSSON) == 0) {
  226.                 if(send_modem_command(smsc->at_fd, "AT+CNMI=3,2,0,0", 0) == -1)
  227.                         goto error;
  228.         }
  229.         else if(strcmp(smsc->at_modemtype, SIEMENS_TC35) == 0) {
  230.                 if(send_modem_command(smsc->at_fd, "AT+CSMS=1", 0) == -1)
  231.                         goto error;
  232.                 if(send_modem_command(smsc->at_fd, "AT+CNMI=1,2,0,0,1",0)== -1)
  233. goto error;
  234. }
  235.         else {
  236.                 if(send_modem_command(smsc->at_fd, "AT+CNMI=1,2,0,0,0", 0) == -1)
  237.                         goto error;
  238.         }
  239.                 
  240.         sprintf(smsc->name, "AT: %s", smsc->at_serialdevice); 
  241.         
  242.         info(0, "AT SMSC successfully opened.");
  244.         return smsc;
  245.   
  246.  error:
  247.         return NULL;
  248. }
  250. /******************************************************************************
  251.  * Re-Open the AT (Virtual) SMSCenter
  252.  */
  253. int at_reopen(SMSCenter *smsc) {
  254.         /* Do we really have an open connection to start with? */
  255.         if (smsc->at_fd == -1) {
  256.                 info(0, "trying to close already closed AT, ignoring");
  257.         }
  259.         /* If we do, then try to close the file descriptor */
  260.         else if (close(smsc->at_fd) == -1) {
  261.                 /* This situation could occur as a result of errors not being reported until
  262.                    the serial connection is closed. Supposing we do get here, we
  263.                    should reset the at_fd value to -1 to stop infinitely retrying the close. We
  264.                    also need to printing out the error message reported, just in case it's
  265.                    significant.
  266.                 */
  267.                 smsc->at_fd = -1;
  268.                 error(errno, "Attempt to close connection to modem `%s' failed. Forcing reset.",
  269.                       smsc->at_serialdevice);
  270.         }
  272.         /* Reopen the connection. Note that the at_open_connection call returns
  273.            a file descriptor, which we should set in the smsc structure */
  274.         smsc->at_fd = at_open_connection(smsc);
  276.         /* Supposing that failed */
  277.         if (smsc->at_fd == -1) {
  278.                 error(0, "Attempt to open connection to modem '%s' failed.",
  279.                       smsc->at_serialdevice);
  280.                 /* Give up */
  281.                 return -1;
  282.         }
  284.         /* Report success */
  285.         return 0;
  286. }
  288. /******************************************************************************
  289.  * Close the SMSCenter
  290.  */
  291. int at_close(SMSCenter *smsc) {
  292.         /* Do we really have an open connection to start with? */
  293.         if (smsc->at_fd == -1) {
  294.                 info(0, "trying to close already closed AT, ignoring");
  295.         }
  297.         /* If we do, then try to close the file descriptor */
  298.         else if (close(smsc->at_fd) == -1) {
  299.                 error(errno, "Attempt to close connection to modem `%s' failed. Forcing reset.",
  300.                       smsc->at_serialdevice);
  301.         }
  302.         
  303.         /* Our file descriptor can now be safely declared closed */
  304.         smsc->at_fd = -1;
  305.         
  306.         /* Deallocate any miscellany */
  307.         smscenter_destruct(smsc);
  309.         /* Report success */
  310.         return 0;
  311. }
  313. /******************************************************************************
  314.  * Check for pending messages
  315.  */
  316. int at_pending_smsmessage(SMSCenter *smsc) {
  317.         Octstr *pdu = NULL;
  318.         int ret=0;
  319.         Msg *msg = NULL;
  321.         /* Receive raw data */
  322.         ret = at_data_read(smsc->at_fd, smsc->at_inbuffer);
  323.         if(ret == -1) {
  324.                 ret = at_reopen(smsc);
  325.                 if(ret == -1) goto error;
  326.                 return 0;
  327.         } 
  329.         ret = 0;
  330.         while( pdu_extract(smsc, &pdu) == 1) {
  331.                 msg = pdu_decode(pdu);
  332.                 if(msg != NULL) {
  333.                         list_append(smsc->at_received, (void *)msg);
  334.                         ret = 1;
  335.                 }
  336.                 octstr_destroy(pdu);
  337.         }
  338.         if(list_len(smsc->at_received) > 0)
  339.                 ret = 1;
  340.         return ret; 
  342.  error:
  343.         error(errno,"at_pending message: device error");
  344.         return -1;
  345. }
  347. /******************************************************************************
  348.  * Send a message
  349.  */
  350. int at_submit_msg(SMSCenter *smsc, Msg *msg) {
  351.         unsigned char command[500], pdu[500];
  352.         int ret = -1; 
  353.         char sc[3];
  354.         int retries = RETRY_SEND;
  356.         /* Some modem types need a '00' prepended to the PDU
  357.          * to indicate to use the default SC.
  358.          * NB: This extra padding is not counted in the CMGS byte count */
  360.         sc[0] = '';
  361.         if((strcmp(smsc->at_modemtype, WAVECOM ) == 0) || 
  362.            (strcmp(smsc->at_modemtype, SIEMENS ) == 0) ||
  363.            (strcmp(smsc->at_modemtype, SIEMENS_TC35 ) == 0) ||
  364.            (strcmp(smsc->at_modemtype, NOKIAPHONE ) == 0) ||
  365.            (strcmp(smsc->at_modemtype, ERICSSON ) == 0))
  366.                 strcpy(sc, "00");
  367.         
  368.         if(msg_type(msg)==sms) {
  369.                 pdu_encode(msg, &pdu[0], smsc);            
  370.                 sprintf(command, "AT+CMGS=%d", strlen(pdu)/2);
  371.                 if(send_modem_command(smsc->at_fd, command, 1) == 0)
  372.                 {
  373.                         sprintf(command, "%s%s%c", sc, pdu, 26);
  374.                         ret = send_modem_command(smsc->at_fd, command, 0);
  375.                         debug("AT", 0, "send command status: %d", ret);
  376.                         while (ret != 0 && retries > 0) {
  377. sprintf(command, "AT+CMGS=%d", strlen(pdu)/2);
  378. if(! send_modem_command(smsc->at_fd, command, 1) == 0)
  379.     break;
  380.                                sprintf(command, "%s%s%c", sc, pdu, 26);
  381.                                ret = send_modem_command(smsc->at_fd, command, 0);
  382.                                debug("AT", 0, "send command status: %d", ret);
  383.                                retries--;
  384.                         }
  385. if (retries<0){
  386.   debug("AT", 0, "AT: Retries exceeded nSMS send failure :");
  387.   debug("AT", 0, "Phone number: %s", octstr_get_cstr(msg->sms.receiver));
  388.   debug("AT", 0, "SMS data: %s", octstr_get_cstr(msg->sms.msgdata));
  389. }
  391.                 }
  392.         }
  393.         return ret;
  394. }
  396. /******************************************************************************
  397.  * There are messages to read!
  398.  */
  399. int at_receive_msg(SMSCenter *smsc, Msg **msg) {
  401.         *msg = list_consume(smsc->at_received);
  402.         if(*msg == NULL)
  403.                 goto error;
  404.                 
  405.         return 1;
  406.         
  407.  error:
  408.         return -1;
  409. }
  411. /******************************************************************************
  412.  * Reads from the modem
  413.  */
  414. static int at_data_read(int fd, Octstr *ostr) {
  415.         int ret;
  416.         fd_set read_fd;
  417.         struct timeval tv;
  418.         size_t readall;
  419.         char cbuffer[257];
  421.      
  422.         tv.tv_sec = 0;
  423.         tv.tv_usec = 1000;
  424.      
  425.         readall = 0;
  426.         for (;;) {
  427.                 memset(&cbuffer, 0, sizeof(cbuffer));
  428.         
  429.                 FD_ZERO(&read_fd);
  430.                 FD_SET(fd, &read_fd);
  431.                 ret = select(fd + 1, &read_fd, NULL, NULL, &tv);
  432.                 if (ret == -1) {
  433.                         if(errno==EINTR) goto got_data;
  434.                         if(errno==EAGAIN) goto got_data;
  435.                         error(errno, "Error doing select for fd");
  436.                         goto error;
  437.                 } else if (ret == 0)
  438.                         goto got_data;
  439.                 ret = read(fd, cbuffer, 256);
  440.                 if (ret == -1) {
  441.                         goto error;
  442.                 }
  443.                 if (ret == 0)
  444.                         goto eof;
  446.                 octstr_append_data(ostr, cbuffer, strlen(cbuffer));
  447.                 if(ret > 0)
  448.                         break;
  449.         }
  450.      
  451.  eof:
  452.         ret = 1;
  453.         goto unblock;
  454.      
  455.  got_data:
  456.         ret = 0;
  457.         goto unblock;
  459.  error:
  460.         error(errno," read device file");
  461.         ret = -1;
  462.         goto unblock;
  463.      
  464.  unblock:
  465.         return ret;  
  467. }
  469. /******************************************************************************
  470.  * Send an AT command to the modem
  471.  * returns 0 if OK, -1 on failure, -2 on SIM PIN needed.
  472.  * Set multiline to 1 if the command will expect more data to be sent.
  473.  */
  474. static int send_modem_command(int fd, char *cmd, int multiline) {
  475.         Octstr *ostr;
  476.         int ret, i;
  478.         ostr = octstr_create("");
  480.         /* debug */
  481.         debug("bb.smsc.at", 0, "AT: Command: %s", cmd);
  482.         
  483.         /* DEBUG !!! - pretend to send but just return success (0)*/
  484.         /* return 0; */
  485.         
  486.         /* send the command */  
  487.         write(fd, cmd, strlen(cmd));
  488.         write(fd, "r", 1);
  490.         /* We don't want to wait forever -
  491.          * This is not perfect but OK for now */
  492.         for( i=0; i<1000; i++) {
  493.                 ret = at_data_read(fd, ostr);
  494.                 /* debug */
  495.                 /*
  496.                   if(octstr_len(ostr)) {
  497.                   printf("Read from modem: ");
  498.                   for(i=0; i<octstr_len(ostr); i++) {
  499.                   if(octstr_get_char(ostr, i) <32)
  500.                   printf("[%02x] ", octstr_get_char(ostr, i));
  501.                   else
  502.                   printf("%c ", octstr_get_char(ostr, i));
  503.                   }
  504.                   printf("n");
  505.                   }*/
  506.                 
  507.                 if(ret == -1)
  508.                         goto error;
  510.                 ret = octstr_search(ostr, 
  511.                                     octstr_imm("SIM PIN"), 0);
  512.                 if(ret != -1) {
  513. ret = -2;
  514.                         goto error;
  515.                 }
  516.                 if(multiline)
  517.                         ret = octstr_search(ostr, 
  518.                                             octstr_imm(">"), 
  519.                                             0);
  520.                 else {
  521.                         ret = octstr_search(ostr, 
  522.                                             octstr_imm("OK"), 
  523.                                             0);
  524.                         if(ret == -1)
  525.                                 ret = octstr_search(ostr, 
  526.                                                     octstr_imm("READY"), 0);
  527.                         if(ret == -1)
  528.                                 ret = octstr_search(ostr,
  529.                                                     octstr_imm("CMGS"), 0);
  530.                 }
  531.                 if(ret != -1) {
  532. ret = 0;
  533.                         goto error;
  534.                 }
  535.                 ret = octstr_search(ostr, 
  536.                                     octstr_imm("ERROR"), 0);
  537.                 if(ret != -1) {
  538. ret = -1;
  539. goto error;
  540.                 }
  541.         }
  542. ret = -1;
  543. goto error;
  544.         
  545.  error:
  546. for (i=0; i< octstr_len(ostr); i++) {
  547.     if (octstr_get_char(ostr, i) < 32)
  548. octstr_set_char(ostr, i, ' ');
  549. }
  550. octstr_strip_blanks(ostr);
  552. debug("AT", 0, "Read from modem: '%s'",octstr_get_cstr(ostr) );
  554.         octstr_destroy(ostr);
  555.         return ret;
  556. }
  558. /******************************************************************************
  559.  * Extract the first PDU in the string
  560.  */
  561. static int pdu_extract(SMSCenter *smsc, Octstr **pdu) {
  562.         Octstr *buffer;
  563.         long len = 0;
  564.         int pos = 0;
  565.         int tmp;
  567.         buffer = smsc->at_inbuffer;
  568.         
  569.         /* find the beginning of a message from the modem*/     
  570.         pos = octstr_search(buffer, octstr_imm("+CMT:"), 0);
  571.         if(pos == -1) 
  572.                 goto nomsg;
  573.         pos += 5;
  574.         pos = octstr_search(buffer, octstr_imm(","), pos);
  575.         if(pos == -1)
  576.                 goto nomsg;
  577.         pos++;
  579.         /* The message length is after the comma */
  580.         pos = octstr_parse_long(&len, buffer, pos, 10);
  581.         if(pos == -1)
  582.                 goto nomsg;
  584.         /* skip the spaces and line return */
  585.         while( isspace(octstr_get_char(buffer, pos)))
  586.                 pos++;
  587.         
  588.         /* skip the SMSC address on some modem types */
  589.         if((strcmp(smsc->at_modemtype, WAVECOM) == 0) ||
  590.            (strcmp(smsc->at_modemtype, SIEMENS) == 0) ||
  591.            (strcmp(smsc->at_modemtype, ERICSSON) == 0) ||
  592.            (strcmp(smsc->at_modemtype, NOKIAPHONE) == 0) ) {
  593.                 tmp = hexchar(octstr_get_char(buffer, pos))*16
  594.                         + hexchar(octstr_get_char(buffer, pos+1));
  595.                 if (tmp < 0)
  596.                         goto nomsg;
  597.                 tmp = 2 + tmp * 2;
  598.                 pos += tmp;
  599.         }
  600.         
  601.         /* check if the buffer is long enough to contain the full message */
  602.         if( octstr_len(buffer) < len * 2 + pos)
  603.                 goto nomsg;
  604.         
  605.         /* copy the PDU then remove it from the input buffer*/
  606.         *pdu = octstr_copy(buffer, pos, len*2);
  607.         octstr_delete(buffer, 0, pos+len*2);
  609.         return 1;
  611.  nomsg:
  612.         return 0;
  613. }
  615. /******************************************************************************
  616.  * Decode a raw PDU into a Msg
  617.  */
  618. static Msg *pdu_decode(Octstr *data) {
  619.         int type;
  620.         Msg *msg = NULL;
  622.         /* Get the PDU type */
  623.         type = octstr_get_char(data, 1) & 3;
  624.         
  625.         switch(type) {
  627.         case AT_DELIVER_SM:
  628.                 msg = pdu_decode_deliver_sm(data);
  629.                 break;
  631.                 /* Add other message types here: */
  632.         
  633.         }
  635.         return msg;
  636. }
  638. /******************************************************************************
  639.  * Decode a DELIVER PDU
  640.  */
  641. static Msg *pdu_decode_deliver_sm(Octstr *data) {
  642.         int len, pos, i;
  643.         char origaddr[21];
  644.         int udhi, dcs, udhlen;
  645.         Octstr *origin = NULL;
  646.         Octstr *udh = NULL;
  647.         Octstr *text = NULL, *tmpstr;
  648.         Octstr *pdu = NULL;
  649.         Msg *message = NULL;
  650.         struct universaltime mtime;     /* time structure */
  651.         long stime;             /* time in seconds */
  653.         /* Note: some parts of the PDU are not decoded because they are
  654.          * not needed for the Msg type. */
  656.         /* convert the pdu to binary format for ease of processing */
  657.         pdu = convertpdu(data);
  658.         
  659.         /* UDH Indicator */
  660.         udhi = (octstr_get_char(pdu, 0) & 64) >> 6;
  662.         /* originating address */
  663.         len = octstr_get_char(pdu, 1);
  664.         pos = 3;
  665.         for(i=0; i<len; i+=2, pos++) {
  666.                 origaddr[i] = (octstr_get_char(pdu, pos) & 15) + 48 ;
  667.                 origaddr[i+1] = (octstr_get_char(pdu, pos) >> 4) + 48;
  668.         }
  669.         origaddr[i] = '';
  670.         origin = octstr_create_from_data(origaddr, len);
  672.         /* skip the PID for now */
  673.         pos++;
  675.         /* DCS */
  676. dcs = octstr_get_char(pdu, pos); 
  677.         pos++;
  678.         
  679.         /* get the timestamp */
  680.         mtime.year   = octstr_get_char(pdu, pos) + 1900; pos++;
  681.         mtime.month  = octstr_get_char(pdu, pos); pos++;
  682.         mtime.day    = octstr_get_char(pdu, pos); pos++;
  683.         mtime.hour   = octstr_get_char(pdu, pos); pos++;
  684.         mtime.minute = octstr_get_char(pdu, pos); pos++;
  685.         mtime.second = octstr_get_char(pdu, pos); pos++;
  686.         /* time zone: */
  687.         /* XXX handle negative time zones */
  688.         mtime.hour  += octstr_get_char(pdu, pos); pos++;
  689.         stime = date_convert_universal(&mtime);
  690.         
  691.         /* get data length */
  692.         len = octstr_get_char(pdu, pos);
  693.         pos++;
  695.         /* if there is a UDH */
  696.      udhlen = 0;
  697.         if(udhi) {
  698.                 udhlen = octstr_get_char(pdu, pos);
  699.                 pos++;
  700.                 udh = octstr_copy(pdu, pos, udhlen);
  701.                 pos += udhlen;
  702.                 len -= udhlen +1;
  703.         }
  705.         /* build the message */         
  706.         message = msg_create(sms);
  707. if (!dcs_to_fields(&message, dcs)) {
  708.     /* XXX Should reject this message ? */
  709.     debug("AT", 0, "Invalid DCS");
  710.     dcs_to_fields(&message, 0);
  711. }
  713.         /* deal with the user data -- 7 or 8 bit encoded */     
  714.         tmpstr = octstr_copy(pdu,pos,len);
  715.         if(message->sms.coding == DC_8BIT || message->sms.coding == DC_UCS2) {
  716.                 text = octstr_duplicate(tmpstr);
  717.         } else {
  718.                 int offset=0;
  719.                 text = octstr_create("");
  720.                 if (udhi && message->sms.coding == DC_7BIT) {
  721.                         int nbits;
  722.                         nbits = (udhlen + 1)*8;
  723.                         offset = (((nbits/7)+1)*7-nbits)%7;     /* Fill bits for UDH to septet boundary */
  724.                 }
  725.                 decode7bituncompressed(tmpstr, len, text, offset);
  726.         }
  728.         message->sms.sender = origin;
  729.         /* Put a dummy address in the receiver for now (SMSC requires one) */
  730.         message->sms.receiver = octstr_create_from_data("1234", 4);
  731.         /*message->sms.receiver = destination;*/
  732.         if (udhi) {
  733.                 message->sms.udhdata = udh;
  734.         }
  735.         message->sms.msgdata = text;
  736.         message->sms.time = stime;
  738.         /* cleanup */
  739.         octstr_destroy(pdu);
  740.         octstr_destroy(tmpstr);
  741.         
  742.         return message;
  743. }
  745. /******************************************************************************
  746.  * Encode a Msg into a PDU
  747.  */
  748. static int pdu_encode(Msg *msg, unsigned char *pdu, SMSCenter *smsc) {
  749.         int pos = 0, i,len, setvalidity=0;
  750.         int ntype = PNT_UNKNOWN; /* number type default */
  751.         int nstartpos = 0;       /* offset for the phone number */
  752.         int dcs;  /* data coding scheme (GSM 03.38) */
  753.         
  754.         /* The message is encoded directly in the text representation of 
  755.          * the hex values that will be sent to the modem.
  756.          * Each octet is coded with two characters. */
  757.         
  758.         /* message type SUBMIT
  759.          *    01010001 = 0x51 indicating add. UDH, TP-VP(Rel) & MSG_SUBMIT
  760.          * or 00010001 = 0x11 for just TP-VP(Rel) & MSG_SUBMIT */
  762.         pdu[pos] = octstr_len(msg->sms.udhdata) ? numtext(5) : numtext(1);
  763.         pos++;
  764.         pdu[pos] = numtext(AT_SUBMIT_SM);
  765.         pos++;
  766.         
  767.         /* message reference (0 for now) */
  768.         pdu[pos] = numtext(0);
  769.         pos++;
  770.         pdu[pos] = numtext(0);
  771.         pos++;
  772.         
  773.         /* destination address */
  774.         octstr_strip_blanks(msg->sms.receiver); /* strip blanks before length calculation */
  775.         len = octstr_len(msg->sms.receiver);
  777.         /* Check for international numbers
  778.          * number starting with '+' or '00' are international,
  779.          * others are national. */
  780.         if (strncmp(octstr_get_cstr(msg->sms.receiver), "+", 1) == 0) {
  781.                 debug("AT", 0, "international starting with + (%s)",octstr_get_cstr(msg->sms.receiver) );
  782.                 nstartpos++;
  783.                 ntype = PNT_INTER; /* international */
  784.         } else if (strncmp(octstr_get_cstr(msg->sms.receiver), "00", 2) == 0) {
  785.                 debug("AT", 0, "international starting with 00 (%s)",octstr_get_cstr(msg->sms.receiver) );
  786.                 nstartpos += 2;
  787.                 ntype = PNT_INTER; /* international */
  788.         }
  789.         
  790.         /* address length */
  791.         pdu[pos] = numtext(((len - nstartpos) & 240) >> 4);
  792.         pos++;
  793.         pdu[pos] = numtext((len - nstartpos) & 15);
  794.         pos++;
  795.                         
  796.         /* Type of number */
  797.         pdu[pos] = numtext(8 + ntype);
  798.         pos++;
  799.         /* numbering plan: ISDN/Telephone numbering plan */
  800.         pdu[pos] = numtext(1);
  801.         pos++;
  802.         
  803.         /* make sure there is no blank in the phone number and encode
  804.          * an even number of digits */
  805.         octstr_strip_blanks(msg->sms.receiver);
  806.         for(i=nstartpos; i<len; i+=2) {
  807.                 if (i+1 < len) {
  808.                         pdu[pos] = octstr_get_char(msg->sms.receiver, i+1);
  809.                 } else {
  810.                         pdu[pos] = numtext (15);
  811.                 }
  812.                 pos++;
  813.                 pdu[pos] = octstr_get_char(msg->sms.receiver, i);
  814.                 pos++;
  815.         }
  816.         
  817.         /* protocol identifier */
  818.         /* 0x00 implicit */
  819.         pdu[pos] = numtext(0);
  820.         pos++;
  821.         pdu[pos] = numtext(0);
  822.         pos++;
  823.         
  824.         /* data coding scheme */
  825. dcs = fields_to_dcs(msg, smsc->at_alt_dcs);
  826.         pdu[pos] = numtext(dcs >> 4);
  827.         pos++;
  828.         pdu[pos] = numtext(dcs % 16);
  829.         pos++;
  831.         /* Validity-Period (TP-VP)
  832.          * see GSM 03.40 section 9.2.3.12
  833.          * defaults to 24 hours = 167 if not set */
  834. if ( msg->sms.validity) {
  835.     if (msg->sms.validity > 635040)
  836. setvalidity = 255;
  837.     if (msg->sms.validity >= 50400 && msg->sms.validity <= 635040)
  838. setvalidity = (msg->sms.validity - 1) / 7 / 24 / 60 + 192 + 1;
  839.     if (msg->sms.validity > 43200 && msg->sms.validity < 50400)
  840. setvalidity = 197;
  841.     if (msg->sms.validity >= 2880 && msg->sms.validity <= 43200)
  842. setvalidity = (msg->sms.validity - 1) / 24 / 60 + 166 + 1;
  843.     if (msg->sms.validity > 1440 && msg->sms.validity < 2880)
  844. setvalidity = 168;
  845.     if (msg->sms.validity >= 750 && msg->sms.validity <= 1440)
  846. setvalidity = (msg->sms.validity - 720 - 1) / 30 + 143 + 1;
  847.     if (msg->sms.validity > 720 && msg->sms.validity < 750)
  848. setvalidity = 144;
  849.     if (msg->sms.validity >= 5 && msg->sms.validity <= 720)
  850. setvalidity = (msg->sms.validity - 1) / 5 - 1 + 1;
  851.     if (msg->sms.validity < 5)
  852. setvalidity = 0;
  853. } else 
  854.     setvalidity = (smsc->at_validityperiod != NULL ? atoi(smsc->at_validityperiod) : 167);
  855.         
  856.         if (setvalidity >= 0 && setvalidity <= 143)
  857.                 debug("AT", 0, "TP-Validity-Period: %d minutes", 
  858.                       (setvalidity+1)*5);
  859.         else if (setvalidity >= 144 && setvalidity <= 167)
  860.                 debug("AT", 0, "TP-Validity-Period: %3.1f hours", 
  861.                       ((float)(setvalidity-143)/2)+12);
  862.         else if (setvalidity >= 168 && setvalidity <= 196)
  863.                 debug("AT", 0, "TP-Validity-Period: %d days", 
  864.                       (setvalidity-166));
  865.         else 
  866.                 debug("AT", 0, "TP-Validity-Period: %d weeks", 
  867.                       (setvalidity-192));
  868.         pdu[pos] = numtext((setvalidity & 240) >> 4);
  869.         pos++;
  870.         pdu[pos] = numtext(setvalidity & 15);
  871.         pos++;
  873.         /* user data length - include length of UDH if it exists*/
  874.         len = octstr_len(msg->sms.msgdata);
  876.         if(octstr_len(msg->sms.udhdata)) {
  877.                 if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  878.     len += octstr_len(msg->sms.udhdata);
  879.                 } else {
  880.                         /* The reason we branch here is because UDH data length is determined
  881.                            in septets if we are in GSM coding, otherwise it's in octets. Adding 6
  882.                            will ensure that for an octet length of 0, we get septet length 0,
  883.                            and for octet length 1 we get septet length 2.*/
  884.                         len += (((8*octstr_len(msg->sms.udhdata)) + 6)/7);                
  885.         }
  886.         }
  888.         pdu[pos] = numtext((len & 240) >> 4);
  889.         pos++;
  890.         pdu[pos] = numtext(len & 15);
  891.         pos++;
  892.         
  893.         /* udh */
  894.         if(octstr_len(msg->sms.udhdata)) {
  895.                         pos += encode8bituncompressed(msg->sms.udhdata, &pdu[pos]);
  896.         }
  898.         /* user data */
  899.         /* if the data is too long, it is cut */
  900.         if(msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  901.                 pos += encode8bituncompressed(msg->sms.msgdata, &pdu[pos]);
  902.         } else {
  903.                 int offset=0;
  905.                 if (octstr_len(msg->sms.udhdata)) {                                   /* Have UDH */
  906.                         int nbits = octstr_len(msg->sms.udhdata)*8;     /* Includes UDH length byte */
  907.                         offset = (((nbits/7)+1)*7-nbits)%7;                     /* Fill bits */
  908.                 }
  909.                 pos += encode7bituncompressed(msg->sms.msgdata, &pdu[pos],offset);
  910.         }
  911.         pdu[pos] = 0;
  913.         return 0;
  914. }
  916. /******************************************************************************
  917.  * Converts the text representation of hexa to binary
  918.  */
  919. static Octstr *convertpdu(Octstr *pdutext) {
  920.         Octstr *pdu;
  921.         int i;
  922.         int len = octstr_len(pdutext);
  924.         pdu = octstr_create("");
  925.         for (i=0; i<len; i+=2) {
  926.                 octstr_append_char(pdu, hexchar(octstr_get_char(pdutext,i))*16 
  927.                                    + hexchar(octstr_get_char(pdutext,i+1)));
  928.         }
  929.         return pdu;
  930. }
  932. /**********************************************************************
  933.  * Encode 7bit uncompressed user data
  934.  */
  935. int ermask[8] = { 0, 1, 3, 7, 15, 31, 63, 127 };
  936. int elmask[8] = { 0, 64, 96, 112, 120, 124, 126, 127 };
  937. static int encode7bituncompressed(Octstr *input, unsigned char *encoded,int offset) {
  938.         unsigned char prevoctet, tmpenc;
  939.         int i;
  940.         int c = 1;
  941.         int r = 7;
  942.         int pos = 0;
  943.         int len;
  944.         unsigned char enc7bit[256];
  945.         int j,encpos = 0;
  947.         charset_latin1_to_gsm(input);
  948.         len = octstr_len(input);
  950.         /* prevoctet is set to the first character and we'll start the loop
  951.          * at the following char. */
  952.         prevoctet = octstr_get_char(input ,0);
  953.         for(i=1; i<octstr_len(input); i++) {
  954.                 /* a byte is encoded with what is left of the previous character
  955.                  * and filled with as much as possible of the current one. */
  956.                 tmpenc = prevoctet + ((octstr_get_char(input,i) & ermask[c]) << r);
  957.                 enc7bit[encpos] = tmpenc; encpos++;
  958.                 c = (c>6)? 1 : c+1;
  959.                 r = (r<2)? 7 : r-1;
  961.                 /* prevoctet becomes the part of the current octet that hasn't
  962.                  * been copied to 'encoded' or the next char if the current has
  963.                  * been completely copied already. */
  964.                 prevoctet = (octstr_get_char(input,i) & elmask[r]) >> (c-1);
  965.                 if(r == 7) {
  966.                         i++;
  967.                         prevoctet = octstr_get_char(input, i);
  968.                 }
  969.         }
  971.         /* if the length of the message is a multiple of 8 then we
  972.          * are finished. Otherwise prevoctet still contains part of a 
  973.          * character so we add it. */
  974.         if((len/8)*8 != len) {
  975.                 enc7bit[encpos] = prevoctet;encpos++;
  976.         }
  978.         /* Now shift the buffer by the offset */
  979.         if (offset > 0) {
  980.                 unsigned char nextdrop, lastdrop;
  982.           nextdrop = lastdrop = 0;
  983.                 for (i = 0; i < encpos; i++) {
  984.                         nextdrop = enc7bit[i] >> (8 - offset);          /* This drops off by shifting */
  985.                         if (i == 0)
  986.                                 enc7bit[i] = enc7bit[i] << offset;              /* This drops off by shifting */
  987.                         else
  988.                                 enc7bit[i] = (enc7bit[i] << offset) | lastdrop;
  989.                         lastdrop = nextdrop;
  990.                 }
  992.                 if (offset > ((len*7) % 8)) {
  993.                         enc7bit [i] = nextdrop;
  994.                         i++;
  995.                 }
  996.         }
  997.         else
  998.                 i = encpos;
  1000.         for (j = 0; j < i; j++) {
  1001.                 encoded[pos] = numtext((enc7bit [j] & 240) >> 4); pos++;
  1002.                 encoded[pos] = numtext(enc7bit [j] & 15); pos++;
  1003.         }
  1004.         return pos;
  1005.                 
  1006. }
  1008. /**********************************************************************
  1009.  * Encode 8bit uncompressed user data
  1010.  */
  1011. static int encode8bituncompressed(Octstr *input, unsigned char *encoded) {
  1012.         int len, i;
  1014.         len = octstr_len(input);
  1015.         
  1016.         for(i=0; i<len; i++) {
  1017.                 /* each character is encoded in its hex representation (2 chars) */
  1018.                 encoded[i*2] = numtext((octstr_get_char(input, i) & 240) >> 4);
  1019.                 encoded[i*2+1] = numtext(octstr_get_char(input, i) & 15);
  1020.         }
  1021.         return len*2;
  1022. }
  1024. /**********************************************************************
  1025.  * Decode 7bit uncompressed user data
  1026.  */
  1027. int rmask[8] = { 0, 1, 3, 7, 15, 31, 63, 127 };
  1028. int lmask[8] = { 0, 128, 192, 224, 240, 248, 252, 254 };
  1030. static void decode7bituncompressed(Octstr *input, int len, Octstr *decoded, int offset) {
  1031.         unsigned char septet, octet, prevoctet;
  1032.         int i;
  1033.         int r = 1;
  1034.         int c = 7;
  1035.         int pos = 0;
  1036.         
  1037.         /* Shift the buffer offset bits to the left */
  1038.         if (offset > 0) {
  1039.                 unsigned char *ip;
  1040.                 for (i = 0, ip = octstr_get_cstr(input); i < octstr_len(input); i++) {
  1041.                         if (i == octstr_len(input) - 1)
  1042.                                 *ip = *ip >> offset;
  1043.                         else
  1044.                                 *ip = (*ip >> offset) | (*(ip + 1) << (8 - offset));
  1045.                         ip++;
  1046.                 }
  1047.         }
  1048.         octet = octstr_get_char(input, pos);
  1049.         prevoctet = 0;
  1050.         for(i=0; i<len; i++) {
  1051.                 septet = ((octet & rmask[c]) << (r-1)) + prevoctet;
  1052.                 octstr_append_char(decoded, septet);
  1054.                 prevoctet = (octet & lmask[r]) >> c;
  1055.         
  1056.                 /* When r=7 we have a full character in prevoctet*/
  1057.                 if((r==7) && (i<len-1)){
  1058.                         i++;
  1059.                         octstr_append_char(decoded, prevoctet);
  1060.                         prevoctet = 0;
  1061.                 }
  1063.                 r = (r>6)? 1 : r+1;
  1064.                 c = (c<2)? 7 : c-1;
  1066.                 pos++;
  1067.                 octet = octstr_get_char(input, pos);
  1068.         }
  1069.         charset_gsm_to_latin1(decoded);
  1070. }
  1072. /**********************************************************************
  1073.  * Code a half-byte to its text hexa representation
  1074.  */
  1075. static int numtext(int num) {
  1076.         return (num > 9) ? (num+55) : (num+48);
  1077. }
  1080. /**********************************************************************
  1081.  * Get the numeric value of the text hex
  1082.  */
  1083. static int hexchar(int hexc) {
  1084.         hexc = toupper(hexc) - 48;
  1085.         return (hexc>9) ? hexc-7 : hexc;
  1086. }