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

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

手机WAP编程

开发平台：

WINDOWS

smsc_at2.c：源码内容
  1. /*
  2.  * smsc_at2.c
  3.  * 
  4.  * New driver for serial connected AT based
  5.  * devices.
  6.  * 4.9.2001
  7.  * Andreas Fink <afink@smsrelay.com>
  8.  * 
  9.  */
  11. #include <errno.h>
  12. #include <stdarg.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <unistd.h>
  17. #include <fcntl.h>
  18. #include <ctype.h>
  19. #include <termios.h>
  20. #include <sys/time.h>
  21. #include <sys/types.h>
  22. #include <sys/socket.h>
  23. #include <netinet/in.h>
  24. #include <netdb.h>
  25. #include <sys/ioctl.h>
  26. #include <time.h>
  27. #include <math.h>
  29. #include "gwlib/gwlib.h"
  30. #include "gwlib/charset.h"
  31. #include "smscconn.h"
  32. #include "smscconn_p.h"
  33. #include "bb_smscconn_cb.h"
  34. #include "msg.h"
  35. #include "sms.h"
  36. #include "dlr.h"
  37. #include "smsc_at2.h"
  39. static int at2_open_device1(PrivAT2data *privdata)
  40. {
  41.     info(0, "AT2[%s]: opening device", octstr_get_cstr(privdata->name));
  42.     privdata->fd = open(octstr_get_cstr(privdata->device), 
  43.                         O_RDWR | O_NONBLOCK | O_NOCTTY);
  44.     if (privdata->fd == -1) {
  45.         error(errno, "AT2[%s]: open failed! ERRNO=%d", octstr_get_cstr(privdata->name), errno);
  46.         privdata->fd = -1;
  47.         return -1;
  48.     }
  49.     debug("bb.smsc.at2", 0, "AT2[%s]: device opened", octstr_get_cstr(privdata->name));
  51.     return 0;
  52. }
  55. int at2_open_device(PrivAT2data *privdata)
  56. {
  57.     struct termios tios;
  58.     int ret;
  60.     if ((ret = at2_open_device1(privdata)) != 0)
  61.         return ret;
  63.     tcgetattr(privdata->fd, &tios);
  65.     kannel_cfmakeraw(&tios);
  66.                       
  67.     tios.c_iflag |= IGNBRK; /* ignore break & parity errors */
  68.     tios.c_iflag &= ~INPCK; /* INPCK: disable parity check */
  69.     tios.c_cflag |= HUPCL; /* hangup on close */
  70.     tios.c_cflag |= CREAD; /* enable receiver */
  71.     tios.c_cflag &= ~CSIZE; /* set to 8 bit */
  72.     tios.c_cflag |= CS8;
  73.     tios.c_oflag &= ~ONLCR; /* no NL to CR-NL mapping outgoing */
  74.     tios.c_iflag |= IGNPAR; /* ignore parity */
  75.     tios.c_iflag &= ~INPCK;
  76.     tios.c_cflag |= CRTSCTS; /* enable hardware flow control */
  77.     tios.c_cc[VSUSP] = 0; /* otherwhise we can not send CTRL Z */
  79.     /*
  80.     if ( ModemTypes[privdata->modemid].enable_parity )
  81.      tios.c_cflag ^= PARODD;
  82.     */
  84.     ret = tcsetattr(privdata->fd, TCSANOW, &tios); /* apply changes now */
  85.     if (ret == -1) {
  86.         error(errno, "AT2[%s]: at_data_link: fail to set termios attribute",
  87.               octstr_get_cstr(privdata->name));
  88.     }
  89.     tcflush(privdata->fd, TCIOFLUSH);
  90.          
  91.     /* 
  92.      * Nokia 7110 and 6210 need some time between opening
  93.      * the connection and sending the first AT commands 
  94.      */
  95.     if (privdata->modem->need_sleep)
  96.         sleep(1);
  97.     debug("bb.smsc.at2", 0, "AT2[%s]: device opened", octstr_get_cstr(privdata->name));
  98.     return 0;
  99. }
  102. void at2_close_device(PrivAT2data *privdata)
  103. {
  104.     info(0, "AT2[%s]: closing device", octstr_get_cstr(privdata->name));
  105.     close(privdata->fd);
  106.     privdata->fd = -1;
  107. }
  110. void at2_read_buffer(PrivAT2data *privdata)
  111. {
  112.     char buf[MAX_READ + 1];
  113.     int s, ret;
  114.     int count;
  115.     fd_set read_fd;
  116.     struct timeval tv;
  118.     if (privdata->fd == -1) {
  119.         error(errno, "AT2[%s]: at2_read_buffer: fd = -1. Can not read", 
  120.               octstr_get_cstr(privdata->name));
  121.         return ;
  122.     }
  123.     count = MAX_READ;
  125. #ifdef SSIZE_MAX
  126.     if (count > SSIZE_MAX)
  127.         count = SSIZE_MAX;
  128. #endif
  130.     tv.tv_sec = 0;
  131.     tv.tv_usec = 1000;
  133.     FD_ZERO(&read_fd);
  134.     FD_SET(privdata->fd, &read_fd);
  135.     ret = select(privdata->fd + 1, &read_fd, NULL, NULL, &tv);
  136.     if (ret == -1) {
  137.         if (!(errno == EINTR || errno == EAGAIN))
  138.             error(errno, "AT2[%s]: error on select", octstr_get_cstr(privdata->name));
  139.         return;
  140.     }
  142.     s = read(privdata->fd, buf, count);
  143.     if (s > 0)
  144.         octstr_append_data(privdata->ilb, buf, s);
  145. }
  148. Octstr *at2_wait_line(PrivAT2data *privdata, time_t timeout, int gt_flag)
  149. {
  150.     Octstr *line;
  151.     time_t end_time;
  152.     time_t cur_time;
  154.     time(&end_time);
  155.     if (timeout == 0)
  156.         timeout = 3;
  157.     end_time += timeout;
  159.     if (privdata->lines != NULL)
  160.         octstr_destroy(privdata->lines);
  161.     privdata->lines = octstr_create("");
  162.     while (time(&cur_time) <= end_time) {
  163.         line = at2_read_line(privdata, gt_flag);
  164.         if (line)
  165.             return line;
  166.     }
  167.     return NULL;
  168. }
  171. Octstr *at2_read_line(PrivAT2data *privdata, int gt_flag)
  172. {
  173.     int eol;
  174.     int gtloc;
  175.     int len;
  176.     Octstr *line;
  177.     Octstr *buf2;
  178.     int i;
  180.     at2_read_buffer(privdata);
  182.     len = octstr_len(privdata->ilb);
  183.     if (len == 0)
  184.         return NULL;
  186.     if (gt_flag)
  187.         /* looking for > if needed */
  188.         gtloc = octstr_search_char(privdata->ilb, '>', 0); 
  189.     else
  190.         gtloc = -1;
  192.     /*   
  193.     if (gt_flag && (gtloc != -1))
  194.         debug("bb.smsc.at2", 0, "in at2_read_line with gt_flag=1, gtloc=%d, ilb=%s",
  195.               gtloc, octstr_get_cstr(privdata->ilb));
  196.     */
  198.     eol = octstr_search_char(privdata->ilb, 'r', 0); /* looking for CR */
  200.     if ( (gtloc != -1) && ( (eol == -1) || (eol > gtloc) ) )
  201.         eol = gtloc;
  203.     if (eol == -1)
  204.         return NULL;
  206.     line = octstr_copy(privdata->ilb, 0, eol);
  207.     buf2 = octstr_copy(privdata->ilb, eol + 1, len);
  208.     octstr_destroy(privdata->ilb);
  209.     privdata->ilb = buf2;
  211.     /* remove any non printable chars (including linefeed for example) */
  212.     for (i = 0; i < octstr_len(line); i++) {
  213.         if (octstr_get_char(line, i) < 32)
  214.             octstr_set_char(line, i, ' ');
  215.     }
  216.     octstr_strip_blanks(line);
  218.     /* empty line, skipping */
  219.     if ((strcmp(octstr_get_cstr(line), "") == 0) && ( gt_flag == 0)) 
  220.     {
  221.         octstr_destroy(line);
  222.         return NULL;
  223.     }
  224.     if ((gt_flag) && (gtloc != -1)) {
  225.         /* got to re-add it again as the parser needs to see it */
  226.         octstr_append_cstr(line, ">"); 
  227.     }
  228.     debug("bb.smsc.at2", 0, "AT2[%s]: <-- %s", octstr_get_cstr(privdata->name), 
  229.           octstr_get_cstr(line));
  230.     return line;
  231. }
  234. int at2_write_line(PrivAT2data *privdata, char *line)
  235. {
  236.     int count;
  237.     int s = 0;
  238.     int write_count = 0;
  239.     Octstr *linestr = NULL;
  241.     linestr = octstr_format("%sr", line);
  243.     debug("bb.smsc.at2", 0, "AT2[%s]: --> %s^M", octstr_get_cstr(privdata->name), line);
  245.     count = octstr_len(linestr);
  246.     while (1) {
  247. errno = 0;
  248. s = write(privdata->fd, octstr_get_cstr(linestr), count);
  249. if (s < 0 && errno == EAGAIN && write_count < RETRY_SEND) {
  250.     gwthread_sleep(1);
  251.     ++write_count;
  252. } else
  253.     break;
  254.     };
  255.     O_DESTROY(linestr);
  256.     if (s < 0) {
  257.         debug("bb.smsc.at2", 0, "AT2[%s]: write failed with errno %d", 
  258.               octstr_get_cstr(privdata->name), errno);
  259.         return s;
  260.     }
  261.     tcdrain(privdata->fd);
  262.     gwthread_sleep((double) (privdata->modem == NULL ? 
  263.         100 : privdata->modem->sendline_sleep) / 1000);
  264.     return s;
  265. }
  268. int at2_write_ctrlz(PrivAT2data *privdata)
  269. {
  270.     int s;
  271.     char *ctrlz = "32" ;
  272.     int write_count = 0;
  273.     
  274.     debug("bb.smsc.at2", 0, "AT2[%s]: --> ^Z", octstr_get_cstr(privdata->name));
  275.     while (1) {
  276. errno = 0;
  277. s = write(privdata->fd, ctrlz, 1);
  278. if (s < 0 && errno == EAGAIN && write_count < RETRY_SEND) {
  279.     gwthread_sleep(1);
  280.     ++write_count;
  281. } else
  282.     break;
  283.     };
  284.     if (s < 0) {
  285.         debug("bb.smsc.at2", 0, "AT2[%s]: write failed with errno %d", 
  286.               octstr_get_cstr(privdata->name), errno);
  287.         return s;
  288.     }
  289.     tcdrain(privdata->fd);
  290.     gwthread_sleep((double) privdata->modem->sendline_sleep / 1000);
  291.     return s;
  292. }
  293.       
  295. int at2_write(PrivAT2data *privdata, char *line)
  296. {
  297.     int count;
  298.     int s;
  300.     count = strlen(line);
  301.     debug("bb.smsc.at2", 0, "AT2[%s]: --> %s", octstr_get_cstr(privdata->name), line);
  302.     s = write(privdata->fd, line, count);
  303.     tcdrain(privdata->fd);
  304.     return s;
  305. }
  308. void at2_flush_buffer(PrivAT2data *privdata)
  309. {
  310.     at2_read_buffer(privdata);
  311.     octstr_destroy(privdata->ilb);
  312.     privdata->ilb = octstr_create("");
  313. }
  316. int at2_init_device(PrivAT2data *privdata)
  317. {
  318.     int res;
  319.     int ret;
  320.     Octstr *setpin;
  322.     info(0, "AT2[%s]: init device", octstr_get_cstr(privdata->name));
  324.     at2_set_speed(privdata, privdata->speed);
  325.     res = at2_send_modem_command(privdata, "AT", 0, 0);
  326.     if (res == -1) {
  327.         /* 
  328.          * first try failed, maybe we need another one 
  329.          * after just having changed the speed 
  330.          */
  331.         res = at2_send_modem_command(privdata, "AT", 0, 0);
  332.     }
  333.     if (res == -1) {
  334.         error(0, "AT2[%s]: no answer from modem", octstr_get_cstr(privdata->name));
  335.         return -1;
  336.     }
  338.     at2_flush_buffer(privdata);
  340.     if (at2_send_modem_command(privdata, "AT&F", 0, 0) == -1)
  341.         return -1;
  343.     if (at2_send_modem_command(privdata, "ATE0", 0, 0) == -1)
  344.         return -1;
  346.     at2_flush_buffer(privdata);
  348.     /* enable hardware handshake */
  349.     if (octstr_len(privdata->modem->enable_hwhs)) {
  350.         if (at2_send_modem_command(privdata, 
  351.             octstr_get_cstr(privdata->modem->enable_hwhs), 0, 0) == -1)
  352.             info(0, "AT2[%s]: cannot enable hardware handshake", 
  353.                  octstr_get_cstr(privdata->name));
  354.     }
  356.     /*
  357.      * Check does the modem require a PIN and, if so, send it.
  358.      * This is not supported by the Nokia Premicell 
  359.      */
  360.     if (!privdata->modem->no_pin) {
  361.         ret = at2_send_modem_command(privdata, "AT+CPIN?", 10, 0);
  363.         if (!privdata->pin_ready) {
  364.             if (ret == 2) {
  365.                 if (privdata->pin == NULL)
  366.                     return -1;
  367.                 setpin = octstr_format("AT+CPIN=%s", octstr_get_cstr(privdata->pin));
  368.                 ret = at2_send_modem_command(privdata, octstr_get_cstr(setpin), 0, 0);
  369.                 octstr_destroy(setpin);
  370.                 if (ret != 0 )
  371.                     return -1;
  372.             } else if (ret == -1)
  373.                 return -1;
  374.         }
  376.         /* 
  377.          * we have to wait until +CPIN: READY appears before issuing
  378.          * the next command. 10 sec should be suficient 
  379.          */
  380.         if (!privdata->pin_ready) {
  381.             at2_wait_modem_command(privdata, 10, 0, NULL);
  382.             if (!privdata->pin_ready) {
  383.                 at2_send_modem_command(privdata, "AT+CPIN?", 10, 0);
  384.                 if (!privdata->pin_ready) {
  385.                     return -1; /* give up */
  386.                 }
  387.             }
  388.         }
  389.     }
  390.     /* 
  391.      * Set the GSM SMS message center address if supplied 
  392.      */
  393.     if (octstr_len(privdata->sms_center)) {
  394.         Octstr *temp;
  395.         temp = octstr_create("AT+CSCA=");
  396.         octstr_append_char(temp, 34);
  397.         octstr_append(temp, privdata->sms_center);
  398.         octstr_append_char(temp, 34);
  399.         /* 
  400.          * XXX If some modem don't process the +, remove it and add ",145"
  401.          * and ",129" to national numbers
  402.          */
  403.         ret = at2_send_modem_command(privdata, octstr_get_cstr(temp), 0, 0);
  404.         octstr_destroy(temp);
  405.         if (ret == -1)
  406.             return -1;
  407.         if (ret > 0) {
  408.             info(0, "AT2[%s]: Cannot set SMS message center, continuing", 
  409.                  octstr_get_cstr(privdata->name));
  410.         }
  411.     }
  413.     /* Set the modem to PDU mode and autodisplay of new messages */
  414.     ret = at2_send_modem_command(privdata, "AT+CMGF=0", 0, 0);
  415.     if (ret != 0 )
  416.         return -1;
  418.     /* lets see if it supports GSM SMS 2+ mode */
  419.     ret = at2_send_modem_command(privdata, "AT+CSMS=?", 0, 0);
  420.     if (ret != 0) {
  421.         /* if it doesnt even understand the command, I'm sure it wont support it */
  422.         privdata->phase2plus = 0; 
  423.     } else {
  424.         /* we have to take a part a string like +CSMS: (0,1,128) */
  425.         Octstr *ts;
  426.         int i;
  427.         List *vals;
  429.         ts = privdata->lines;
  430.         privdata->lines = NULL;
  432.         i = octstr_search_char(ts, '(', 0);
  433.         if (i > 0) {
  434.             octstr_delete(ts, 0, i + 1);
  435.         }
  436.         i = octstr_search_char(ts, ')', 0);
  437.         if (i > 0) {
  438.             octstr_truncate(ts, i);
  439.         }
  440.         vals = octstr_split(ts, octstr_imm(","));
  441.         octstr_destroy(ts);
  442.         ts = list_search(vals, octstr_imm("1"), (void*) octstr_item_match);
  443.         if (ts)
  444.             privdata->phase2plus = 1;
  445.         list_destroy(vals, octstr_destroy_item);
  446.     }
  447.     if (privdata->phase2plus) {
  448.         info(0, "AT2[%s]: Phase 2+ is supported", octstr_get_cstr(privdata->name));
  449.         ret = at2_send_modem_command(privdata, "AT+CSMS=1", 0, 0);
  450.         if (ret != 0)
  451.             return -1;
  452.     }
  454.     /* send init string */
  455.     ret = at2_send_modem_command(privdata, octstr_get_cstr(privdata->modem->init_string), 0, 0);
  456.     if (ret != 0)
  457.         return -1;
  459.     if (privdata->sms_memory_poll_interval && privdata->modem->message_storage) {
  460.         /* set message storage location for "SIM buffering" using the CPMS command */
  461.         Octstr *temp;
  462.         temp = octstr_create("AT+CPMS=");
  463.         octstr_append_char(temp, 34);
  464.         octstr_append(temp, privdata->modem->message_storage);
  465.         octstr_append_char(temp, 34);
  466.         ret = at2_send_modem_command(privdata, octstr_get_cstr(temp), 0, 0);
  467.         octstr_destroy(temp);
  468.         if (ret != 0)
  469.             return -1;
  470.     }
  472.     info(0, "AT2[%s]: AT SMSC successfully opened.", octstr_get_cstr(privdata->name));
  473.     return 0;
  474. }
  477. int at2_send_modem_command(PrivAT2data *privdata, char *cmd, time_t timeout, int gt_flag)
  478. {
  479.     at2_write_line(privdata, cmd);
  480.     return at2_wait_modem_command(privdata, timeout, gt_flag, NULL);
  481. }
  484. int at2_wait_modem_command(PrivAT2data *privdata, time_t timeout, int gt_flag, 
  485.                            int *output)
  486. {
  487.     Octstr *line = NULL;
  488.     Octstr *line2 = NULL;
  489.     Octstr *pdu = NULL;
  490.     int ret;
  491.     time_t end_time;
  492.     time_t cur_time;
  493.     Msg *msg;
  494.     int len;
  495.     int cmgr_flag = 0;
  497.     time(&end_time);
  498.     if (timeout == 0)
  499.         timeout = 3;
  500.     end_time += timeout;
  502.     if (privdata->lines != NULL)
  503.         octstr_destroy(privdata->lines);
  504.     privdata->lines = octstr_create("");
  505.     while (time(&cur_time) <= end_time) {
  506.         O_DESTROY(line);
  507.         line = at2_read_line(privdata, gt_flag);
  508.         if (line) {
  509.             octstr_append(privdata->lines, line);
  510.             octstr_append_cstr(privdata->lines, "n");
  512.             if (octstr_search(line, octstr_imm("SIM PIN"), 0) != -1) {
  513.                 ret = 2;
  514.                 goto end;
  515.             }
  516.             if (octstr_search(line, octstr_imm("OK"), 0) != -1) {
  517.                 ret = 0;
  518.                 goto end;
  519.             }
  520.             if ((gt_flag ) && (octstr_search(line, octstr_imm(">"), 0) != -1)) {
  521.                 ret = 1;
  522.                 goto end;
  523.             }
  524.             if (octstr_search(line, octstr_imm("RING"), 0) != -1) {
  525.                 at2_write_line(privdata, "ATH0");
  526.                 continue;
  527.             }
  528.             if (octstr_search(line, octstr_imm("+CPIN: READY"), 0) != -1) {
  529.                 privdata->pin_ready = 1;
  530.                 continue;
  531.             }
  532.             if ( -1 != octstr_search(line, octstr_imm("+CMS ERROR"), 0)) {
  533.                 error(0, "AT2[%s]: CMS ERROR: %s", octstr_get_cstr(privdata->name), 
  534.                       octstr_get_cstr(line));
  535.                 ret = 1;
  536.                 goto end;
  537.             }
  538.             if (octstr_search(line, octstr_imm("+CMT:"), 0) != -1 ||
  539. octstr_search(line, octstr_imm("+CDS:"), 0) != -1 ||
  540.                 ((octstr_search(line, octstr_imm("+CMGR:"), 0) != -1) && (cmgr_flag = 1)) ) {
  541.                 line2 = at2_wait_line(privdata, 1, 0);
  543.                 if (line2 == NULL) {
  544.                     error(0, "AT2[%s]: got +CMT but waiting for next line timed out", 
  545.                           octstr_get_cstr(privdata->name));
  546.                 } else {
  547.                     octstr_append_cstr(line, "n");
  548.                     octstr_append(line, line2);
  549.                     O_DESTROY(line2);
  550.                     at2_pdu_extract(privdata, &pdu, line);
  552.                     if (pdu == NULL) {
  553.                         error(0, "AT2[%s]: got +CMT but pdu_extract failed", 
  554.                               octstr_get_cstr(privdata->name));
  555.                     } else {
  556.                         /* count message even if I can't decode it */
  557.                         if (output)
  558.                             ++(*output);
  559.                         msg = at2_pdu_decode(pdu, privdata);
  560.                         if (msg != NULL) {
  561.                             msg->sms.smsc_id = octstr_duplicate(privdata->conn->id);
  562.                             bb_smscconn_receive(privdata->conn, msg);
  563.                         }
  565.                         if (!cmgr_flag) {
  566.                             if (privdata->phase2plus)
  567.                                 at2_write_line(privdata, "AT+CNMA");
  568.                         }
  570.                         O_DESTROY(pdu);
  571.                     }
  572.                 }
  573.                 continue;
  574.             }
  575.             if ((octstr_search(line, octstr_imm("+CMGS:"),0) != -1) && (output)) {
  576. /* found response to a +CMGS command, read the message id and return it in output */
  577. long temp;
  578. if (octstr_parse_long(&temp, line, octstr_search(line, octstr_imm("+CMGS:"),0)+6,10) == -1)
  579.     error(0,"AT2[%s]: got +CMGS but failed to read message id", octstr_get_cstr(privdata->name));
  580. else
  581.     *output = temp;
  582.             }
  584.             if ( -1 != octstr_search(line, octstr_imm("ERROR"), 0)) {
  585.                 ret = -1;
  586.                 goto end;
  587.             }
  588.         }
  589.     }
  591.     len = octstr_len(privdata->ilb);
  592.     /*
  593.     error(0,"AT2[%s]: timeout. received <%s> until now, buffer size is %d, buf=%s",
  594.           octstr_get_cstr(privdata->name),
  595.           privdata->lines ? octstr_get_cstr(privdata->lines) : "<nothing>", len,
  596.           privdata->ilb ? octstr_get_cstr(privdata->ilb) : "<nothing>");
  597.     */
  598.     O_DESTROY(line);
  599.     O_DESTROY(line2);
  600.     O_DESTROY(pdu);
  601.     return -1; /* timeout */
  603. end:
  604.     octstr_append(privdata->lines, line);
  605.     octstr_append_cstr(privdata->lines, "n");
  606.     O_DESTROY(line);
  607.     O_DESTROY(line2);
  608.     O_DESTROY(pdu);
  609.     return ret;
  610. }
  613. void at2_read_sms_memory(PrivAT2data* privdata)
  614. {
  615.     char cmd[20];
  617.     /* get memory status */
  618.     if (at2_check_sms_memory(privdata) == -1) {
  619.         debug("bb.smsc.at2", 0, "AT2[%s]: memory check error", octstr_get_cstr(privdata->name));
  620.         return ;
  621.     }
  623.     if (privdata->sms_memory_usage) { 
  624.         /*
  625.          * that is - greater then 0, meaning there are some messages to fetch
  626.          * now - I used to just loop over the first input_mem_sms_used locations, 
  627.          * but it doesn't hold, since under load, messages may be received while 
  628.          * we're in the loop, and get stored in locations towards the end of the list, 
  629.          * thus creating 'holes' in the memory. 
  630.          * 
  631.          * There are two ways we can fix this : 
  632.          *   (a) Just read the last message location, delete it and return.
  633.          *       It's not a complete solution since holes can still be created if messages 
  634.          *       are recieved between the memory check and the delete command, 
  635.          *       and anyway - it will slow us down and won't hold well under pressure
  636.          *   (b) Just scan the entire memory each call, bottom to top. 
  637.          *       This will be slow too, but it'll be reliable.
  638.          *
  639.          * We can massivly improve performance by stopping after input_mem_sms_used messages
  640.          * have been read, but send_modem_command returns 0 for no message as well as for a 
  641.          * message read, and the only other way to implement it is by doing memory_check 
  642.          * after each read and stoping when input_mem_sms_used get to 0. This is slow 
  643.          * (modem commands take time) so we improve speed only if there are less then 10 
  644.          * messages in memory.
  645.          *
  646.          * I implemented the alternative - changed at2_wait_modem_command to return the 
  647.          * number of messages it collected.
  648.          */
  649.         int i;
  650.         int message_count = 0; /* cound number of messages collected */
  652.         debug("bb.smsc.at2", 0, "AT2[%s]: %d messages waiting in memory", 
  653.               octstr_get_cstr(privdata->name), privdata->sms_memory_usage);
  655.         /*
  656.          * loop till end of memory or collected enouch messages
  657.          */
  658.         for (i = 1; i <= privdata->sms_memory_capacity &&
  659.              message_count < privdata->sms_memory_usage; ++i) { 
  660.             int old_message_count = message_count;
  661.             sprintf(cmd, "AT+CMGR=%d", i);
  662.             /* read one message from memory */
  663.             at2_write_line(privdata, cmd);
  664.             if (at2_wait_modem_command(privdata, 0, 0, &message_count) != 0) {
  665.                 debug("bb.smsc.at2", 0, "AT2[%s]: failed to get message %d.", 
  666.                       octstr_get_cstr(privdata->name), i);
  667.                 continue; /* failed to read the message - skip to next message */
  668.             }
  670.             /* no need to delete if no message collected */
  671.             if (old_message_count == message_count) { 
  672.                 debug("bb.smsc.at2", 0, "AT2[%s]: not deleted.", 
  673.                       octstr_get_cstr(privdata->name));
  674.                 continue;
  675.             }
  677.             sprintf(cmd, "AT+CMGD=%d", i); /* delete the message we just read */
  678.             /* 
  679.              * 3 seconds is not enough with some modems if the message is large,
  680.              * so we'll give it 7 seconds 
  681.              */
  682.             if (at2_send_modem_command(privdata, cmd, 7, 0) != 0) {  
  683.                 /* 
  684.                  * failed to delete the message, we'll just ignore it for now, 
  685.                  * this is bad, since if the message really didn't get deleted
  686.                  * we'll see it next time around. 
  687.                  */                
  688.                 debug("bb.smsc.at2", 0, "AT2[%s]: failed to delete message %d.", 
  689.                       octstr_get_cstr(privdata->name), i);
  690.                 continue; 
  692.             }
  693.         }
  694.     }
  695.     /*
  696.     at2_send_modem_command(privdata, ModemTypes[privdata->modemid].init1, 0, 0);
  697.     */
  698. }
  701. int at2_check_sms_memory(PrivAT2data *privdata)
  702. {
  703.     long values[4]; /* array to put response data in */
  704.     int pos; /* position of parser in data stream */
  705.     int ret;
  706.     Octstr* search_cpms = NULL;
  708.     /* select memory type and get report */
  709.     if ((ret = at2_send_modem_command(privdata, "AT+CPMS?", 0, 0)) != 0) { 
  710.         debug("bb.smsc.at2.memory_check", 0, "failed to send mem select command to modem %d", ret);
  711.         return -1;
  712.     }
  714.     search_cpms = octstr_create("+CPMS:");
  716.     if ((pos = octstr_search(privdata->lines, search_cpms, 0)) != -1) {
  717.         /* got back a +CPMS response */
  718.         int index = 0; /* index in values array */
  719.         pos += 6; /* position of parser in the stream - start after header */
  721.         /* skip memory indication */
  722.         pos = octstr_search(privdata->lines, octstr_imm(","), pos) + 1; 
  724.         /* find all the values */
  725.         while (index < 4 && pos < octstr_len(privdata->lines) &&
  726.                (pos = octstr_parse_long(&values[index], privdata->lines, pos, 10)) != -1) { 
  727.             ++pos; /* skip number seperator */
  728.             ++index; /* increment array index */
  729.             if (index == 2)
  730.                 /* skip second memory indication */
  731.                 pos = octstr_search(privdata->lines, octstr_imm(","), pos) + 1; 
  732.         }
  734.         if (index < 4) { 
  735.             /* didn't get all memory data - I don't why, so I'll bail */
  736.             debug("bb.smsc.at2", 0, "AT2[%s]: couldn't parse all memory locations : %d:'%s'.",
  737.                   octstr_get_cstr(privdata->name), index, 
  738.                   &(octstr_get_cstr(privdata->lines)[pos]));
  739.             O_DESTROY(search_cpms);
  740.             return -1;
  741.         }
  743.         privdata->sms_memory_usage = values[0];
  744.         privdata->sms_memory_capacity = values[1];
  745.         /*
  746.         privdata->output_mem_sms_used = values[2];
  747.         privdata->output_mem_sms_capacity = values[3];
  748.         */
  750.         /* everything's cool */
  751.         ret = 0; 
  753.         /*  clear the buffer */
  754.         O_DESTROY(privdata->lines);
  756.     } else {
  757.         debug("bb.smsc.at2", 0, "AT2[%s]: no correct header for CPMS response.", 
  758.               octstr_get_cstr(privdata->name));
  760.         /* didn't get a +CPMS response - this is clearly an error */
  761.         ret = -1; 
  762.     }
  764.     O_DESTROY(search_cpms);
  765.     return ret;
  766. }
  769. void at2_set_speed(PrivAT2data *privdata, int bps)
  770. {
  771.     struct termios tios;
  772.     int ret;
  773.     int speed;
  775.     tcgetattr(privdata->fd, &tios);
  777.     switch (bps) {
  778.     case 300:
  779.         speed = B300;
  780.         break;
  781.     case 1200:
  782.         speed = B1200;
  783.         break;
  784.     case 2400:
  785.         speed = B2400;
  786.         break;
  787.     case 4800:
  788.         speed = B4800;
  789.         break;
  790.     case 9600:
  791.         speed = B9600;
  792.         break;
  793.     case 19200:
  794.         speed = B19200;
  795.         break;
  796.     case 38400:
  797.         speed = B38400;
  798.         break;
  799. #ifdef B57600
  800.     case 57600:
  801.         speed = B57600;
  802.         break;
  803. #endif
  804.     default:
  805.         speed = B9600;
  806.     }
  807.     cfsetospeed(&tios, speed);
  808.     cfsetispeed(&tios, speed);
  809.     ret = tcsetattr(privdata->fd, TCSANOW, &tios); /* apply changes now */
  810.     if (ret == -1) {
  811.         error(errno, "AT2[%s]: at_data_link: fail to set termios attribute",
  812.               octstr_get_cstr(privdata->name));
  813.     }
  814.     tcflush(privdata->fd, TCIOFLUSH);
  816.     info(0, "AT2[%s]: speed set to %d", octstr_get_cstr(privdata->name), bps);
  817. }
  820. void at2_device_thread(void *arg)
  821. {
  822.     SMSCConn *conn = arg;
  823.     PrivAT2data *privdata = conn->data;
  825.     int l, wait = 0;
  826.     long idle_timeout, memory_poll_timeout = 0;
  828.     conn->status = SMSCCONN_CONNECTING;
  830. reconnect:
  832.     do {
  833.         if (wait) {
  834.             if (conn->status == SMSCCONN_ACTIVE) {
  835.                 mutex_lock(conn->flow_mutex);
  836.                 conn->status = SMSCCONN_RECONNECTING;
  837.                 mutex_unlock(conn->flow_mutex);
  838.             }
  839.             info(0, "AT2[%s]: waiting for %d %s before trying to connect again", 
  840.                  octstr_get_cstr(privdata->name), (wait < 60 ? wait : wait / 60),
  841.                  (wait < 60 ? "seconds" : "minutes"));
  842.             gwthread_sleep(wait);
  843.             wait = wait > (privdata->retry ? 3600 : 600) ? 
  844.                 (privdata->retry ? 3600 : 600) : wait * 2;
  845.         } else
  846.             wait = 15;
  848.         /* If modems->speed is defined, try to use it, else autodetect */
  849.         if (privdata->speed == 0 && privdata->modem != NULL && 
  850.     privdata->modem->speed != 0) {
  852.     info(0, "AT2[%s]: trying to use speed <%ld> from modem definition", 
  853.          octstr_get_cstr(privdata->name), privdata->modem->speed);
  854.     if(0 == at2_test_speed(privdata, privdata->modem->speed)) { 
  855. privdata->speed = privdata->modem->speed;
  856. info(0, "AT2[%s]: speed is %ld", 
  857.      octstr_get_cstr(privdata->name), privdata->speed);
  858.     } else {
  859. info(0, "AT2[%s]: speed in modem definition don't work, will autodetect", 
  860.      octstr_get_cstr(privdata->name));
  861.     }
  862. }
  864.         if (privdata->speed == 0) {
  865.     if (at2_detect_speed(privdata) == -1) {
  866. if (!privdata->retry)
  867.     return;
  868. else
  869.     continue;
  870.             }
  871.         }
  873.         if (privdata->modem == NULL) {
  874.             if (at2_detect_modem_type(privdata) == -1) {
  875.                 if (!privdata->retry)
  876.                     return;
  877.                 else
  878.                     continue;
  879.             }
  880.         }
  882.         if (at2_open_device(privdata)) {
  883.             error(errno, "AT2[%s]: at2_device_thread: open_at2_device failed. Terminating", 
  884.                   octstr_get_cstr(privdata->name));
  885.             if (!privdata->retry)
  886.                 return;
  887.             else
  888.                 continue;
  889.         }
  891.         if (at2_init_device(privdata) != 0) {
  892.             error(0, "AT2[%s]: Opening failed. Terminating", octstr_get_cstr(privdata->name));
  893.             if (!privdata->retry) {
  894.                 privdata->shutdown = 1;
  895.                 //return;
  896.             } else
  897.                 continue;
  898.         }
  900.         /* If we got here, then the device is opened */
  901.         break;
  902.     } while (privdata->retry && !privdata->shutdown);
  904.     conn->status = SMSCCONN_ACTIVE;
  905.     bb_smscconn_connected(conn);
  907.     idle_timeout = 0;
  908.     while (!privdata->shutdown) {
  909.         l = list_len(privdata->outgoing_queue);
  910.         if (l > 0) {
  911.             at2_send_messages(privdata);
  912.             idle_timeout = time(NULL);
  913.         } else
  914.             at2_wait_modem_command(privdata, 1, 0, NULL);
  916.         if (privdata->keepalive &&
  917.             idle_timeout + privdata->keepalive < time(NULL)) {
  918.             if (at2_send_modem_command(privdata, 
  919.                 octstr_get_cstr(privdata->modem->keepalive_cmd), 5, 0) < 0) {
  920.                 at2_close_device(privdata);
  921.                 conn->status = SMSCCONN_RECONNECTING;
  922.                 wait = 15;
  923.                 goto reconnect;
  924.             }
  925.             idle_timeout = time(NULL);
  926.         }
  928.         if (privdata->sms_memory_poll_interval &&
  929.             memory_poll_timeout + privdata->sms_memory_poll_interval < time(NULL)) {
  930.             at2_read_sms_memory(privdata);
  931.             memory_poll_timeout = time(NULL);
  932.         }
  933.     }
  934.     at2_close_device(privdata);
  935.     conn->status = SMSCCONN_DISCONNECTED;
  936.     /* maybe some cleanup here? */
  937.     at2_destroy_modem(privdata->modem);
  938.     octstr_destroy(privdata->device);
  939.     octstr_destroy(privdata->ilb);
  940.     octstr_destroy(privdata->lines);
  941.     octstr_destroy(privdata->pin);
  942.     octstr_destroy(privdata->validityperiod);
  943.     octstr_destroy(privdata->my_number);
  944.     octstr_destroy(privdata->sms_center);
  945.     octstr_destroy(privdata->name);
  946.     octstr_destroy(privdata->configfile);
  947.     list_destroy(privdata->outgoing_queue, NULL);
  948.     gw_free(conn->data);
  949.     conn->data = NULL;
  950.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
  951.     conn->status = SMSCCONN_DEAD;
  952.     bb_smscconn_killed();
  953. }
  956. int at2_shutdown_cb(SMSCConn *conn, int finish_sending)
  957. {
  958.     PrivAT2data *privdata = conn->data;
  960.     debug("bb.sms", 0, "AT2[%s]: Shutting down SMSCConn, %s",
  961.           octstr_get_cstr(privdata->name),
  962.           finish_sending ? "slow" : "instant");
  964.     /* 
  965.      * Documentation claims this would have been done by smscconn.c,
  966.      * but isn't when this code is being written. 
  967.      */
  968.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
  969.     privdata->shutdown = 1; 
  970.     /* 
  971.      * Separate from why_killed to avoid locking, as
  972.      * why_killed may be changed from outside? 
  973.      */
  974.     if (finish_sending == 0) {
  975.         Msg *msg;
  976.         while ((msg = list_extract_first(privdata->outgoing_queue)) != NULL) {
  977.             bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN);
  978.         }
  979.     }
  980.     gwthread_wakeup(privdata->device_thread);
  981.     return 0;
  983. }
  986. long at2_queued_cb(SMSCConn *conn)
  987. {
  988.     long ret;
  989.     PrivAT2data *privdata = conn->data;
  991.     if (conn->status == SMSCCONN_DEAD) /* I'm dead, why would you care ? */
  992. return -1;
  994.     ret = list_len(privdata->outgoing_queue);
  996.     /* use internal queue as load, maybe something else later */
  998.     conn->load = ret;
  999.     return ret;
  1000. }
  1003. void at2_start_cb(SMSCConn *conn)
  1004. {
  1005.     PrivAT2data *privdata = conn->data;
  1007.     if (conn->status == SMSCCONN_DISCONNECTED)
  1008.         conn->status = SMSCCONN_ACTIVE;
  1009.     
  1010.     /* in case there are messages in the buffer already */
  1011.     gwthread_wakeup(privdata->device_thread);
  1012.     debug("smsc.at2", 0, "AT2[%s]: start called", octstr_get_cstr(privdata->name));
  1013. }
  1015. int at2_add_msg_cb(SMSCConn *conn, Msg *sms)
  1016. {
  1017.     PrivAT2data *privdata = conn->data;
  1018.     Msg *copy;
  1020.     copy = msg_duplicate(sms);
  1021.     list_produce(privdata->outgoing_queue, copy);
  1022.     gwthread_wakeup(privdata->device_thread);
  1023.     return 0;
  1024. }
  1027. int smsc_at2_create(SMSCConn *conn, CfgGroup *cfg)
  1028. {
  1029.     PrivAT2data *privdata;
  1030.     Octstr *modem_type_string;
  1032.     privdata = gw_malloc(sizeof(PrivAT2data));
  1033.     privdata->outgoing_queue = list_create();
  1035.     privdata->configfile = cfg_get_configfile(cfg);
  1037.     privdata->device = cfg_get(cfg, octstr_imm("device"));
  1038.     if (privdata->device == NULL) {
  1039.         error(0, "AT2[-]: 'device' missing in at2 configuration.");
  1040.         goto error;
  1041.     }
  1043.     privdata->name = cfg_get(cfg, octstr_imm("smsc-id"));
  1044.     if (privdata->name == NULL) {
  1045.         privdata->name = octstr_duplicate(privdata->device);
  1046.     }
  1048.     privdata->speed = 0;
  1049.     cfg_get_integer(&privdata->speed, cfg, octstr_imm("speed"));
  1051.     privdata->keepalive = 0;
  1052.     cfg_get_integer(&privdata->keepalive, cfg, octstr_imm("keepalive"));
  1054.     cfg_get_bool(&privdata->sms_memory_poll_interval, cfg, octstr_imm("sim-buffering"));
  1055.     if (privdata->sms_memory_poll_interval) {
  1056.         if (privdata->keepalive)
  1057.             privdata->sms_memory_poll_interval = privdata->keepalive;
  1058.         else
  1059.             privdata->sms_memory_poll_interval = AT2_DEFAULT_SMS_POLL_INTERVAL;
  1060.     }
  1062.     cfg_get_bool(&privdata->retry, cfg, octstr_imm("retry"));
  1063.     privdata->my_number = cfg_get(cfg, octstr_imm("my-number"));
  1064.     privdata->sms_center = cfg_get(cfg, octstr_imm("sms-center"));
  1065.     modem_type_string = cfg_get(cfg, octstr_imm("modemtype"));
  1067.     privdata->modem = NULL;
  1069.     if (modem_type_string != NULL) {
  1070.         if (octstr_compare(modem_type_string, octstr_imm("auto")) == 0 ||
  1071.             octstr_compare(modem_type_string, octstr_imm("autodetect")) == 0)
  1072.             O_DESTROY(modem_type_string);
  1073.     }
  1075.     if (octstr_len(modem_type_string) == 0) {
  1076.         info(0, "AT2[%s]: configuration doesn't show modemtype. will autodetect",
  1077.              octstr_get_cstr(privdata->name));
  1078.     } else {
  1079.         info(0, "AT2[%s]: configuration shows modemtype <%s>",
  1080.              octstr_get_cstr(privdata->name),
  1081.              octstr_get_cstr(modem_type_string));
  1082.         privdata->modem = at2_read_modems(privdata, privdata->configfile,
  1083.                                           modem_type_string, 0);
  1084.         if (privdata->modem == NULL) {
  1085.             info(0, "AT2[%s]: modemtype not found, revert to autodetect",
  1086.                  octstr_get_cstr(privdata->name));
  1087.         } else {
  1088.             info(0, "AT2[%s]: read modem definition for <%s>",
  1089.                  octstr_get_cstr(privdata->name),
  1090.                  octstr_get_cstr(privdata->modem->name));
  1091.         }
  1092.         O_DESTROY(modem_type_string);
  1093.     }
  1095.     privdata->ilb = octstr_create("");
  1096.     privdata->fd = -1;
  1097.     privdata->lines = NULL;
  1098.     privdata->pin = cfg_get(cfg, octstr_imm("pin"));
  1099.     privdata->pin_ready = 0;
  1100.     privdata->conn = conn;
  1101.     privdata->phase2plus = 0;
  1102.     privdata->validityperiod = cfg_get(cfg, octstr_imm("validityperiod"));
  1104.     cfg_get_bool(&privdata->alt_dcs, cfg, octstr_imm("alt-dcs"));
  1106.     conn->data = privdata;
  1107.     conn->name = octstr_format("AT2[%s]", octstr_get_cstr(privdata->name));
  1109.     privdata->shutdown = 0;
  1111.     conn->status = SMSCCONN_CONNECTING;
  1112.     conn->connect_time = time(NULL);
  1114.     if ((privdata->device_thread = gwthread_create(at2_device_thread, conn)) == -1) {
  1115.         privdata->shutdown = 1;
  1116.         goto error;
  1117.     }
  1119.     conn->shutdown = at2_shutdown_cb;
  1120.     conn->queued = at2_queued_cb;
  1121.     conn->start_conn = at2_start_cb;
  1122.     conn->send_msg = at2_add_msg_cb;
  1123.     return 0;
  1125. error:
  1126.     error(0, "AT2[%s]: Failed to create at2 smsc connection",
  1127.           octstr_len(privdata->name) ? octstr_get_cstr(privdata->name) : "");
  1128.     if (privdata != NULL) {
  1129.         list_destroy(privdata->outgoing_queue, NULL);
  1130.     }
  1131.     gw_free(privdata);
  1132.     conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
  1133.     conn->status = SMSCCONN_DEAD;
  1134.     info(0, "AT2[%s]: exiting", octstr_get_cstr(privdata->name));
  1135.     return -1;
  1136. }
  1139. int at2_pdu_extract(PrivAT2data *privdata, Octstr **pdu, Octstr *line)
  1140. {
  1141.     Octstr *buffer;
  1142.     long len = 0;
  1143.     int pos = 0;
  1144.     int tmp;
  1146.     buffer = octstr_duplicate(line);
  1147.     /* find the beginning of a message from the modem*/
  1149.     if ((pos = octstr_search(buffer, octstr_imm("+CDS:"), 0)) != -1) 
  1150. pos += 5;
  1151.     else {
  1152. if ((pos = octstr_search(buffer, octstr_imm("+CMT:"), 0)) != -1)
  1153.     pos += 5;
  1154. else if ((pos = octstr_search(buffer, octstr_imm("+CMGR:"), 0)) != -1) {
  1155.     /* skip status field in +CMGR response */
  1156.     if ((pos = octstr_search(buffer, octstr_imm(","), pos + 6)) != -1) 
  1157. pos++;
  1158.     else
  1159. goto nomsg;
  1160. } else
  1161.     goto nomsg;
  1163. /* skip the next comma in CMGR and CMT responses */
  1164. tmp = octstr_search(buffer, octstr_imm(","), pos);
  1165. if (! privdata->modem->broken && tmp == -1)
  1166.     goto nomsg;
  1167. if (tmp != -1)
  1168.     pos = tmp + 1;
  1169.     }
  1171.     /* read the message length */
  1172.     pos = octstr_parse_long(&len, buffer, pos, 10);
  1173.     if (pos == -1)
  1174.         goto nomsg;
  1176.     /* skip the spaces and line return */
  1177.     while (isspace(octstr_get_char(buffer, pos)))
  1178.         pos++;
  1180.     /* skip the SMSC address on some modem types */
  1181.     if (!privdata->modem->no_smsc) {
  1182.         tmp = at2_hexchar(octstr_get_char(buffer, pos)) * 16
  1183.               + at2_hexchar(octstr_get_char(buffer, pos + 1));
  1184.         if (tmp < 0)
  1185.             goto nomsg;
  1186.         tmp = 2 + tmp * 2;
  1187.         pos += tmp;
  1188.     }
  1190.     /* check if the buffer is long enough to contain the full message */
  1191.     if (!privdata->modem->broken && octstr_len(buffer) < len * 2 + pos)
  1192.         goto nomsg;
  1194.     if (privdata->modem->broken && octstr_len(buffer) < len * 2)
  1195.         goto nomsg;
  1197.     /* copy the PDU then remove it from the input buffer*/
  1198.     *pdu = octstr_copy(buffer, pos, len * 2);
  1200.     octstr_destroy(buffer);
  1201.     return 1;
  1203. nomsg:
  1204.     octstr_destroy(buffer);
  1205.     return 0;
  1206. }
  1209. int at2_hexchar(int hexc)
  1210. {
  1211.     hexc = toupper(hexc) - 48;
  1212.     return (hexc > 9) ? hexc - 7 : hexc;
  1213. }
  1216. Msg *at2_pdu_decode(Octstr *data, PrivAT2data *privdata)
  1217. {
  1218.     int type;
  1219.     Msg *msg = NULL;
  1221.     /* Get the PDU type */
  1222.     type = octstr_get_char(data, 1) & 3;
  1224.     switch (type) {
  1226.         case AT_DELIVER_SM:
  1227.             msg = at2_pdu_decode_deliver_sm(data, privdata);
  1228.             break;
  1229.         case AT_STATUS_REPORT_SM:
  1230.     msg = at2_pdu_decode_report_sm(data, privdata);
  1231.     break;
  1233.             /* Add other message types here: */
  1235.     }
  1237.     return msg;
  1238. }
  1241. Msg *at2_pdu_decode_deliver_sm(Octstr *data, PrivAT2data *privdata)
  1242. {
  1243.     int len, pos, i, ntype;
  1244.     int udhi, dcs, udhlen, pid;
  1245.     Octstr *origin = NULL;
  1246.     Octstr *udh = NULL;
  1247.     Octstr *text = NULL, *tmpstr;
  1248.     Octstr *pdu = NULL;
  1249.     Msg *message = NULL;
  1250.     struct universaltime mtime; /* time structure */
  1251.     long stime; /* time in seconds */
  1252.     int timezone; /* timezone in 15 minutes jumps from GMT */
  1254.     /* 
  1255.      * Note: some parts of the PDU are not decoded because they are
  1256.      * not needed for the Msg type. 
  1257.      */
  1259.     /* convert the pdu to binary format for ease of processing */
  1260.     pdu = at2_convertpdu(data);
  1262.     /* UDH Indicator */
  1263.     udhi = (octstr_get_char(pdu, 0) & 64) >> 6;
  1265.     /* originating address */
  1266.     len = octstr_get_char(pdu, 1);
  1267.     ntype = octstr_get_char(pdu, 2);
  1269.     pos = 3;
  1270.     if ((ntype & 0xD0) == 0xD0) {
  1271.         /* Alphanumeric sender */
  1272.         origin = octstr_create("");
  1273.         tmpstr = octstr_copy(pdu, 3, len);
  1274.         at2_decode7bituncompressed(tmpstr, (((len - 1) * 4 - 3) / 7) + 1, origin, 0);
  1275.         octstr_destroy(tmpstr);
  1276.         debug("bb.smsc.at2", 0, "AT2[%s]: Alphanumeric sender <%s>", 
  1277.               octstr_get_cstr(privdata->name), octstr_get_cstr(origin));
  1278.         pos += (len + 1) / 2;
  1279.     } else {
  1280.         origin = octstr_create("");
  1281.         if ((ntype & 0x90) == 0x90) {
  1282.             /* International number */
  1283.             octstr_append_char(origin, '+');
  1284.         }
  1285.         for (i = 0; i < len; i += 2, pos++) {
  1286.             octstr_append_char(origin, (octstr_get_char(pdu, pos) & 15) + 48);
  1287.             if (i + 1 < len)
  1288.                 octstr_append_char(origin, (octstr_get_char(pdu, pos) >> 4) + 48);
  1289.         }
  1290.         debug("bb.smsc.at2", 0, "AT2[%s]: Numeric sender %s <%s>", 
  1291.               octstr_get_cstr(privdata->name), ((ntype & 0x90) == 0x90 ? "(international)" : ""), 
  1292.               octstr_get_cstr(origin));
  1293.     }
  1295.     /* PID */
  1296.     pid = octstr_get_char(pdu, pos);
  1297.     pos++;
  1299.     /* DCS */
  1300.     dcs = octstr_get_char(pdu, pos);
  1301.     pos++;
  1303.     /* get the timestamp */
  1304.     mtime.year = swap_nibbles(octstr_get_char(pdu, pos));
  1305.     pos++;
  1306.     mtime.year += (mtime.year < 70 ? 2000 : 1900);
  1307.     mtime.month = swap_nibbles(octstr_get_char(pdu, pos)) ;
  1308.     pos++;
  1309.     mtime.day = swap_nibbles(octstr_get_char(pdu, pos));
  1310.     pos++;
  1311.     mtime.hour = swap_nibbles(octstr_get_char(pdu, pos));
  1312.     pos++;
  1313.     mtime.minute = swap_nibbles(octstr_get_char(pdu, pos));
  1314.     pos++;
  1315.     mtime.second = swap_nibbles(octstr_get_char(pdu, pos));
  1316.     pos++;
  1318.     /* 
  1319.      * time zone: 
  1320.      *
  1321.      * time zone is "swapped nibble", with the MSB as the sign (1 is negative).  
  1322.      */
  1323.     timezone = swap_nibbles(octstr_get_char(pdu, pos));
  1324.     pos++;
  1325.     timezone = ((timezone >> 7) ? -1 : 1) * (timezone & 127);
  1326.     /* 
  1327.      * Ok, that was the time zone as read from the PDU. Now how to interpert it? 
  1328.      * All the handsets I tested send the timestamp of their local time and the 
  1329.      * timezone as GMT+0. I assume that the timestamp is the handset's local time, 
  1330.      * so we need to apply the timezone in reverse to get GM time: 
  1331.      */
  1333.     /* 
  1334.      * time in PDU is handset's local time and timezone is handset's time zone 
  1335.      * difference from GMT 
  1336.      */
  1337.     mtime.hour -= timezone / 4;
  1338.     mtime.minute -= 15 * (timezone % 4);
  1340.     stime = date_convert_universal(&mtime);
  1342.     /* get data length */
  1343.     len = octstr_get_char(pdu, pos);
  1344.     pos++;
  1346.     /* if there is a UDH */
  1347.     udhlen = 0;
  1348.     if (udhi) {
  1349.         udhlen = octstr_get_char(pdu, pos);
  1350.         pos++;
  1351.         udh = octstr_copy(pdu, pos, udhlen);
  1352.         pos += udhlen;
  1353.         len -= udhlen + 1;
  1354.     }
  1356.     /* build the message */
  1357.     message = msg_create(sms);
  1358.     if (!dcs_to_fields(&message, dcs)) {
  1359.         /* XXX Should reject this message? */
  1360.         debug("bb.smsc.at2", 0, "AT2[%s]: Invalid DCS",
  1361.               octstr_get_cstr(privdata->name));
  1362.         dcs_to_fields(&message, 0);
  1363.     }
  1365.     message->sms.pid = pid;
  1367.     /* deal with the user data -- 7 or 8 bit encoded */
  1368.     tmpstr = octstr_copy(pdu, pos, len);
  1369.     if (message->sms.coding == DC_8BIT || message->sms.coding == DC_UCS2) {
  1370.         text = octstr_duplicate(tmpstr);
  1371.     } else {
  1372.         int offset = 0;
  1373.         text = octstr_create("");
  1374.         if (udhi && message->sms.coding == DC_7BIT) {
  1375.             int nbits;
  1376.             nbits = (udhlen + 1) * 8;
  1377.             /* fill bits for UDH to septet boundary */
  1378.             offset = (((nbits / 7) + 1) * 7 - nbits) % 7;     
  1379.         }
  1380.         at2_decode7bituncompressed(tmpstr, len, text, offset);
  1381.     }
  1383.     message->sms.sender = origin;
  1384.     if (octstr_len(privdata->my_number)) {
  1385.         message->sms.receiver = octstr_duplicate(privdata->my_number);
  1386.     } else {
  1387.         /* Put a dummy address in the receiver for now (SMSC requires one) */
  1388.         message->sms.receiver = octstr_create_from_data("1234", 4);
  1389.     }
  1390.     if (udhi) {
  1391.         message->sms.udhdata = udh;
  1392.     }
  1393.     message->sms.msgdata = text;
  1394.     message->sms.time = stime;
  1396.     /* cleanup */
  1397.     octstr_destroy(pdu);
  1398.     octstr_destroy(tmpstr);
  1400.     return message;
  1401. }
  1403. Msg *at2_pdu_decode_report_sm(Octstr *data, PrivAT2data *privdata)
  1404. {
  1405.    Msg* dlrmsg = NULL;
  1406.    Octstr *pdu, *msg_id, *tmpstr = NULL, *receiver = NULL;
  1407.    int type, tp_mr, len, ntype, pos;
  1409.     /*
  1410.      * parse the PDU.
  1411.      */
  1413.     /* convert the pdu to binary format for ease of processing */
  1414.     pdu = at2_convertpdu(data);
  1416.     /* Message reference */
  1417.     tp_mr = octstr_get_char(pdu,1);
  1418.     msg_id = octstr_format("%d",tp_mr);
  1419.     debug("bb.smsc.at2",0,"AT2[%s]: got STATUS-REPORT for message <%d>:", octstr_get_cstr(privdata->name), tp_mr);
  1420.     
  1421.     /* reciver address */
  1422.     len = octstr_get_char(pdu, 2);
  1423.     ntype = octstr_get_char(pdu, 3);
  1425.     pos = 4;
  1426.     if ((ntype & 0xD0) == 0xD0) {
  1427.         /* Alphanumeric sender */
  1428.         receiver = octstr_create("");
  1429.         tmpstr = octstr_copy(pdu, pos, (len+1)/2);
  1430.         at2_decode7bituncompressed(tmpstr, (((len - 1) * 4 - 3) / 7) + 1, receiver, 0);
  1431.         octstr_destroy(tmpstr);
  1432.         debug("bb.smsc.at2", 0, "AT2[%s]: Alphanumeric receiver <%s>",
  1433.               octstr_get_cstr(privdata->name), octstr_get_cstr(receiver));
  1434.         pos += (len + 1) / 2;
  1435.     } else {
  1436. int i;
  1437.         receiver = octstr_create("");
  1438.         if ((ntype & 0x90) == 0x90) {
  1439.             /* International number */
  1440.             octstr_append_char(receiver, '+');
  1441.         }
  1442.         for (i = 0; i < len; i += 2, pos++) {
  1443.             octstr_append_char(receiver, (octstr_get_char(pdu, pos) & 15) + 48);
  1444.             if (i + 1 < len)
  1445.                 octstr_append_char(receiver, (octstr_get_char(pdu, pos) >> 4) + 48);
  1446.         }
  1447.         debug("bb.smsc.at2", 0, "AT2[%s]: Numeric receiver %s <%s>",
  1448.               octstr_get_cstr(privdata->name), ((ntype & 0x90) == 0x90 ? "(international)" : ""),
  1449.               octstr_get_cstr(receiver));
  1450.     }
  1452.     pos += 14; /* skip time stamps for now */
  1454.     if ((type = octstr_get_char(pdu, pos)) == -1 ) {
  1455. error(1,"AT2[%s]: STATUS-REPORT pdu too short to have TP-Status field !",
  1456.     octstr_get_cstr(privdata->name));
  1457. goto error;
  1458.     }
  1460. /* check DLR type:
  1461.  * 3GPP TS 23.040 defines this a bit mapped field with lots of options
  1462.  * most of which are not really intersting to us, as we are only interested
  1463.  * in one of three conditions : failed, held in SC for delivery later, or delivered successfuly
  1464.  * and here's how I suggest to test it (read the 3GPP reference for further detailes) -
  1465.  * we'll test the 6th and 5th bits (7th bit when set making all other values 'reseved' so I want to test it).
  1466.  */
  1467.     type = type & 0xE0; /* filter out everything but the 7th, 6th and 5th bits */
  1468.     switch (type) {
  1469. case 0x00:
  1470.     /* 0 0 : success class */
  1471.     type = DLR_SUCCESS;
  1472.     tmpstr = octstr_create("Success/");
  1473.     break;
  1474. case 0x20:
  1475.     /* 0 1 : buffered class (temporary error) */
  1476.     type = DLR_BUFFERED;
  1477.     tmpstr = octstr_create("Buffered/");
  1478.     break;
  1479. case 0x40:
  1480. case 0x60:
  1481. default:
  1482.     /* 1 0 : failed class */
  1483.     /* 1 1 : failed class (actually, temporary error but timed out) */
  1484.     /* and any other value (can't think of any) is considered failure */
  1485.     type = DLR_FAIL;
  1486.     tmpstr = octstr_create("Failed/");
  1487.     break;
  1488.     }
  1489.     /* Actually, the above implementation is not correct, as the reference says that implementations should consider
  1490.      * any "reserved" values to be "failure", but most reserved values fall into one of the three categories. it will catch
  1491.      * "reserved" values where the first 3 MSBits are not set as "Success" which may not be correct. */
  1493.     if ((dlrmsg = dlr_find(octstr_get_cstr(privdata->conn->id),
  1494.     octstr_get_cstr(msg_id), octstr_get_cstr(receiver), type)) == NULL) {
  1495. debug("bb.smsc.at2",1,"AT2[%s]: Received delivery notification but can't find that ID in the DLR storage",
  1496.     octstr_get_cstr(privdata->name));
  1497.     goto error;
  1498.     }
  1500.     /* Beware DLR URL is now in msg->sms.dlr_url given by dlr_find() */
  1501.     dlrmsg->sms.msgdata = octstr_duplicate(tmpstr);
  1503. error:
  1504.     O_DESTROY(tmpstr);
  1505.     O_DESTROY(pdu);
  1506.     O_DESTROY(receiver);
  1507.     O_DESTROY(msg_id);
  1508.     return dlrmsg;
  1509. }
  1511. Octstr *at2_convertpdu(Octstr *pdutext)
  1512. {
  1513.     Octstr *pdu;
  1514.     int i;
  1515.     int len = octstr_len(pdutext);
  1517.     pdu = octstr_create("");
  1518.     for (i = 0; i < len; i += 2) {
  1519.         octstr_append_char(pdu, at2_hexchar(octstr_get_char(pdutext, i)) * 16
  1520.                            + at2_hexchar(octstr_get_char(pdutext, i + 1)));
  1521.     }
  1522.     return pdu;
  1523. }
  1526. int at2_rmask[8] = { 0, 1, 3, 7, 15, 31, 63, 127 };
  1527. int at2_lmask[8] = { 0, 128, 192, 224, 240, 248, 252, 254 };
  1529. void at2_decode7bituncompressed(Octstr *input, int len, Octstr *decoded, int offset)
  1530. {
  1531.     unsigned char septet, octet, prevoctet;
  1532.     int i;
  1533.     int r = 1;
  1534.     int c = 7;
  1535.     int pos = 0;
  1537.     /* Shift the buffer offset bits to the left */
  1538.     if (offset > 0) {
  1539.         unsigned char *ip;
  1540.         for (i = 0, ip = octstr_get_cstr(input); i < octstr_len(input); i++) {
  1541.             if (i == octstr_len(input) - 1)
  1542.                 *ip = *ip >> offset;
  1543.             else
  1544.                 *ip = (*ip >> offset) | (*(ip + 1) << (8 - offset));
  1545.             ip++;
  1546.         }
  1547.     }
  1548.     octet = octstr_get_char(input, pos);
  1549.     prevoctet = 0;
  1550.     for (i = 0; i < len; i++) {
  1551.         septet = ((octet & at2_rmask[c]) << (r - 1)) + prevoctet;
  1552.         octstr_append_char(decoded, septet);
  1554.         prevoctet = (octet & at2_lmask[r]) >> c;
  1556.         /* When r=7 we have a full character in prevoctet */
  1557.         if ((r == 7) && (i < len - 1)) {
  1558.             i++;
  1559.             octstr_append_char(decoded, prevoctet);
  1560.             prevoctet = 0;
  1561.         }
  1563.         r = (r > 6) ? 1 : r + 1;
  1564.         c = (c < 2) ? 7 : c - 1;
  1566.         pos++;
  1567.         octet = octstr_get_char(input, pos);
  1568.     }
  1569.     charset_gsm_to_latin1(decoded);
  1570. }
  1573. void at2_send_messages(PrivAT2data *privdata)
  1574. {
  1575.     Msg *msg;
  1577.     do {
  1578.         if (privdata->modem->enable_mms && 
  1579. list_len(privdata->outgoing_queue) > 1)
  1580.             at2_send_modem_command(privdata, "AT+CMMS=2", 0, 0);
  1582.         if ((msg = list_extract_first(privdata->outgoing_queue)))
  1583.             at2_send_one_message(privdata, msg);
  1584.     } while (msg);
  1585. }
  1588. void at2_send_one_message(PrivAT2data *privdata, Msg *msg)
  1589. {
  1590.     unsigned char command[500];
  1591.     int ret = -1;
  1592.     char sc[3];
  1593.     int retries = RETRY_SEND;
  1595.     if (octstr_len(privdata->my_number)) {
  1596.         octstr_destroy(msg->sms.sender);
  1597.         msg->sms.sender = octstr_duplicate(privdata->my_number);
  1598.     }
  1600.     /* 
  1601.      * The standard says you should be prepending the PDU with 00 to indicate 
  1602.      * to use the default SC. Some older modems dont expect this so it can be 
  1603.      * disabled 
  1604.      * NB: This extra padding is not counted in the CMGS byte count 
  1605.      */
  1606.     sc[0] = '';
  1608.     if (!privdata->modem->no_smsc)
  1609.         strcpy(sc, "00");
  1611.     if (msg_type(msg) == sms) {
  1612. Octstr* pdu;
  1614. if ((pdu = at2_pdu_encode(msg, privdata)) == NULL) {
  1615.     error(2, "AT2[%s]: Error encoding PDU!",octstr_get_cstr(privdata->name));
  1616.     return;
  1617. }
  1619.         ret = -99;
  1620.         retries = RETRY_SEND;
  1621.         while ((ret != 0) && (retries-- > 0)) {
  1622.     int msg_id = -1;
  1623.             /* 
  1624.              * send the initial command and then wait for > 
  1625.              */
  1626.             sprintf(command, "AT+CMGS=%ld", octstr_len(pdu) / 2);
  1627.             
  1628.             ret = at2_send_modem_command(privdata, command, 5, 1);
  1629.             debug("bb.smsc.at2", 0, "AT2[%s]: send command status: %d",
  1630.                   octstr_get_cstr(privdata->name), ret);
  1632.             if (ret != 1) /* > only! */
  1633.                 continue;
  1634.             /* 
  1635.              * ok the > has been see now so we can send the PDU now and a 
  1636.              * control Z but no CR or LF 
  1637.              */
  1638.             sprintf(command, "%s%s", sc, octstr_get_cstr(pdu));
  1639.             at2_write(privdata, command);
  1640.             at2_write_ctrlz(privdata);
  1641.             
  1642.             /* wait 20 secs for modem command */
  1643.             ret = at2_wait_modem_command(privdata, 20, 0, &msg_id);
  1644.             debug("bb.smsc.at2", 0, "AT2[%s]: send command status: %d",
  1645.                   octstr_get_cstr(privdata->name), ret);
  1646.             
  1647.             if (ret != 0) /* OK only */
  1648.                 continue;
  1650.     /* gen DLR_SMSC_SUCCESS */
  1651.     if (msg->sms.dlr_mask & DLR_SMSC_SUCCESS)
  1652.     {
  1653. Msg* dlrmsg;
  1655. dlrmsg = msg_create(sms);
  1656. dlrmsg->sms.id = msg->sms.id;
  1657.                 dlrmsg->sms.service = octstr_duplicate(msg->sms.service);
  1658.                 dlrmsg->sms.dlr_mask = DLR_SMSC_SUCCESS;
  1659.                 dlrmsg->sms.sms_type = report;
  1660.                 dlrmsg->sms.smsc_id = octstr_duplicate(privdata->conn->id);
  1661.                 dlrmsg->sms.sender = octstr_duplicate(msg->sms.receiver);
  1662.                 dlrmsg->sms.receiver = octstr_duplicate(msg->sms.sender);
  1663.                 dlrmsg->sms.msgdata = octstr_create("ACK");
  1664.                 dlrmsg->sms.dlr_url = octstr_duplicate(msg->sms.dlr_url);
  1665.                 time(&dlrmsg->sms.time);
  1667. debug("bb.smsc.at2",0,"AT2[%s]: sending DLR type ACK", octstr_get_cstr(privdata->name));
  1668. bb_smscconn_receive(privdata->conn, dlrmsg);
  1670.     }
  1672.     /* store DLR message if needed for SMSC generated delivery reports */
  1673.     if (msg->sms.dlr_mask & (DLR_SUCCESS | DLR_FAIL | DLR_BUFFERED)) {
  1674. if (msg_id == -1)
  1675.     error(0,"AT2[%s]: delivery notification requested, but I have no message ID!",
  1676. octstr_get_cstr(privdata->name));
  1677.  else {
  1678.             Octstr *dlrmsgid = octstr_format("%d", msg_id);
  1680.             dlr_add(octstr_get_cstr(privdata->conn->id),
  1681.                     octstr_get_cstr(dlrmsgid),
  1682.         octstr_get_cstr(msg->sms.sender),
  1683.         octstr_get_cstr(msg->sms.receiver),
  1684.         octstr_get_cstr(msg->sms.service),
  1685.         octstr_get_cstr(msg->sms.dlr_url),
  1686.         msg->sms.dlr_mask);
  1688.     O_DESTROY(dlrmsgid);
  1689. }
  1690.     }
  1692.             counter_increase(privdata->conn->sent);
  1693.             bb_smscconn_sent(privdata->conn, msg);
  1694.         }
  1696.         if (ret != 0) {
  1697.     /* gen DLR_SMSC_FAIL */
  1698.     if (msg->sms.dlr_mask & DLR_SMSC_FAIL) {
  1699. Msg* dlrmsg;
  1701. dlrmsg = msg_create(sms);
  1702.                 dlrmsg->sms.service = octstr_duplicate(msg->sms.service);
  1703.                 dlrmsg->sms.dlr_mask = DLR_SMSC_FAIL;
  1704.                 dlrmsg->sms.sms_type = report;
  1705.                 dlrmsg->sms.smsc_id = octstr_duplicate(privdata->conn->id);
  1706.                 dlrmsg->sms.sender = octstr_duplicate(msg->sms.receiver);
  1707.                 dlrmsg->sms.receiver = octstr_duplicate(msg->sms.sender);
  1708.                 dlrmsg->sms.msgdata = octstr_create("NACK");
  1709.                 dlrmsg->sms.dlr_url = octstr_duplicate(msg->sms.dlr_url);
  1710.                 time(&dlrmsg->sms.time);
  1712. debug("bb.smsc.at2",0,"AT2[%s]: sending DLR type NACK", octstr_get_cstr(privdata->name));
  1713. bb_smscconn_receive(privdata->conn, dlrmsg);
  1714.     }
  1716.             /*
  1717.              * no need to do counter_increase(privdata->conn->failed) here, 
  1718.              * since bb_smscconn_send_failed() will inc the counter on 
  1719.              * SMSCCONN_FAILED_MALFORMED
  1720.              */
  1721.             bb_smscconn_send_failed(privdata->conn, msg, SMSCCONN_FAILED_MALFORMED);
  1722.         }
  1724.         O_DESTROY(pdu);
  1725.     }
  1726. }
  1729. Octstr* at2_pdu_encode(Msg *msg, PrivAT2data *privdata)
  1730. {
  1731.     /*
  1732.      * Message coding is done as a binary octet string,
  1733.      * as per 3GPP TS 23.040 specification (GSM 03.40),
  1734.      */
  1735.     Octstr *pdu = NULL, *temp = NULL, *buffer = octstr_create("");
  1736.      
  1737.     int len, setvalidity = 0;
  1739.     /* 
  1740.      * message type SUBMIT , bit mapped :
  1741.      * bit7                            ..                                    bit0
  1742.      * TP-RP , TP-UDHI, TP-SRR, TP-VPF(4), TP-VPF(3), TP-RD, TP-MTI(1), TP-MTI(0)
  1743.      */
  1744.     octstr_append_char(buffer,
  1745. ((msg->sms.rpi ? 1 : 0) << 7) /* TP-RP */
  1746. | ((octstr_len(msg->sms.udhdata)  ? 1 : 0) << 6) /* TP-UDHI */
  1747. | (((msg->sms.dlr_mask & (DLR_SUCCESS | DLR_FAIL | DLR_BUFFERED)) ? 1 : 0) << 5) /* TP-SRR */
  1748. | 16 /* TP-VP(Rel)*/
  1749. | 1 /* TP-MTI: SUBMIT_SM */
  1750. );
  1752.     /* message reference (0 for now) */
  1753.     octstr_append_char(buffer, 0);
  1755.     /* destination address */
  1756.     if ((temp = at2_format_address_field(msg->sms.receiver)) == NULL)
  1757. goto error;
  1758.     octstr_append(buffer, temp);
  1759.     O_DESTROY(temp);
  1761.     octstr_append_char(buffer, msg->sms.pid); /* protocol identifier */
  1762.     octstr_append_char(buffer, fields_to_dcs(msg, /* data coding scheme */
  1763. (msg->sms.alt_dcs ? 2 - msg->sms.alt_dcs : privdata->alt_dcs)));
  1765.     /* 
  1766.      * Validity-Period (TP-VP)
  1767.      * see GSM 03.40 section 9.2.3.12
  1768.      * defaults to 24 hours = 167 if not set 
  1769.      */
  1770.     if ( msg->sms.validity) {
  1771.         if (msg->sms.validity > 635040)
  1772.             setvalidity = 255;
  1773.         if (msg->sms.validity >= 50400 && msg->sms.validity <= 635040)
  1774.             setvalidity = (msg->sms.validity - 1) / 7 / 24 / 60 + 192 + 1;
  1775.         if (msg->sms.validity > 43200 && msg->sms.validity < 50400)
  1776.             setvalidity = 197;
  1777.         if (msg->sms.validity >= 2880 && msg->sms.validity <= 43200)
  1778.             setvalidity = (msg->sms.validity - 1) / 24 / 60 + 166 + 1;
  1779.         if (msg->sms.validity > 1440 && msg->sms.validity < 2880)
  1780.             setvalidity = 168;
  1781.         if (msg->sms.validity >= 750 && msg->sms.validity <= 1440)
  1782.             setvalidity = (msg->sms.validity - 720 - 1) / 30 + 143 + 1;
  1783.         if (msg->sms.validity > 720 && msg->sms.validity < 750)
  1784.             setvalidity = 144;
  1785.         if (msg->sms.validity >= 5 && msg->sms.validity <= 720)
  1786.             setvalidity = (msg->sms.validity - 1) / 5 - 1 + 1;
  1787.         if (msg->sms.validity < 5)
  1788.             setvalidity = 0;
  1789.     } else
  1790.         setvalidity = (privdata->validityperiod != NULL ? 
  1791.             atoi(octstr_get_cstr(privdata->validityperiod)) : 167);
  1793.     if (setvalidity >= 0 && setvalidity <= 143)
  1794.         debug("bb.smsc.at2", 0, "AT2[%s]: TP-Validity-Period: %d minutes",
  1795.               octstr_get_cstr(privdata->name), (setvalidity + 1)*5);
  1796.     else if (setvalidity >= 144 && setvalidity <= 167)
  1797.         debug("bb.smsc.at2", 0, "AT2[%s]: TP-Validity-Period: %3.1f hours",
  1798.               octstr_get_cstr(privdata->name), ((float)(setvalidity - 143) / 2) + 12);
  1799.     else if (setvalidity >= 168 && setvalidity <= 196)
  1800.         debug("bb.smsc.at2", 0, "AT2[%s]: TP-Validity-Period: %d days",
  1801.               octstr_get_cstr(privdata->name), (setvalidity - 166));
  1802.     else
  1803.         debug("bb.smsc.at2", 0, "AT2[%s]: TP-Validity-Period: %d weeks",
  1804.               octstr_get_cstr(privdata->name), (setvalidity - 192));
  1805.     octstr_append_char(buffer, setvalidity);
  1807.     /* user data length - include length of UDH if it exists */
  1808.     len = sms_msgdata_len(msg);
  1810.     if (octstr_len(msg->sms.udhdata)) {
  1811.         if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  1812.             len += octstr_len(msg->sms.udhdata);
  1813.             if (len > SMS_8BIT_MAX_LEN) { /* truncate user data to allow UDH to fit */
  1814.                 octstr_delete(msg->sms.msgdata, SMS_8BIT_MAX_LEN - octstr_len(msg->sms.udhdata), 9999);
  1815.                 len = SMS_8BIT_MAX_LEN;
  1816.             }
  1817.         } else {
  1818.             /*
  1819.              * The reason we branch here is because UDH data length is determined
  1820.              * in septets if we are in GSM coding, otherwise it's in octets. Adding 6
  1821.              * will ensure that for an octet length of 0, we get septet length 0,
  1822.              * and for octet length 1 we get septet length 2. 
  1823.              */
  1824.             int temp_len;
  1825.             len += (temp_len = (((8 * octstr_len(msg->sms.udhdata)) + 6) / 7));
  1826.             if (len > SMS_7BIT_MAX_LEN) { /* truncate user data to allow UDH to fit */
  1827.                 octstr_delete(msg->sms.msgdata, SMS_7BIT_MAX_LEN - temp_len, 9999);
  1828.                 len = SMS_7BIT_MAX_LEN;
  1829.             }
  1830.         }
  1831.     }
  1833.     octstr_append_char(buffer,len);
  1835.     if (octstr_len(msg->sms.udhdata)) /* udh */
  1836. octstr_append(buffer, msg->sms.udhdata);
  1838.     /* user data */
  1839.     if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  1840.         octstr_append(buffer, msg->sms.msgdata);
  1841.     } else {
  1842.         int offset = 0;
  1844.         /*
  1845.          * calculate the number of fill bits needed to align
  1846.          * the 7bit encoded user data on septet boundry
  1847.          */
  1848.         if (octstr_len(msg->sms.udhdata)) { /* Have UDH */
  1849.             int nbits = octstr_len(msg->sms.udhdata) * 8; /* Includes UDH length byte */
  1850.             offset = (((nbits / 7) + 1) * 7 - nbits) % 7; /* Fill bits */
  1851.         }
  1853.         charset_latin1_to_gsm(msg->sms.msgdata);
  1854.         
  1855.         if ((temp = at2_encode7bituncompressed(msg->sms.msgdata, offset)) != NULL)
  1856.     octstr_append(buffer, temp);
  1857.         O_DESTROY(temp);
  1858.     }
  1860.     /* convert PDU to HEX representation suitable for the AT2 command set */
  1861.     pdu = at2_encode8bituncompressed(buffer);
  1862.     O_DESTROY(buffer);
  1864.     return pdu;
  1865. error:
  1866.     O_DESTROY(temp);
  1867.     O_DESTROY(buffer);
  1868.     O_DESTROY(pdu);
  1869.     return NULL;
  1870. }
  1873. Octstr* at2_encode7bituncompressed(Octstr *source, int offset)
  1874. {
  1875.     int LSBmask[8] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F };
  1876.     int MSBmask[8] = { 0x00, 0x40, 0x60, 0x70, 0x78, 0x7C, 0x7E, 0x7F };
  1877.     int destRemain = (int)ceil ((octstr_len(source) * 7.0) / 8.0);
  1878.     int i = (offset?8-offset:7), iStore = offset;
  1879.     int posT, posS;
  1880.     Octstr *target = octstr_create("");
  1881.     int target_chr = 0, source_chr;
  1883.     /* start packing the septet stream into an octet stream */
  1884.     for (posS = 0, posT = 0; (source_chr = octstr_get_char(source, posS++)) != -1;) {
  1885. /* grab least significant bits from current septet and store them packed to the right */
  1886. target_chr |= (source_chr & LSBmask[i]) << iStore;
  1887. /* store current byte if last command filled it */
  1888. if (iStore != 0) {
  1889.     destRemain--;
  1890.     octstr_append_char(target, target_chr);
  1891.     target_chr = 0;
  1892. }
  1893. /* grab most significant bits from current septet and store them packed to the left */
  1894. target_chr |= (source_chr & MSBmask[7 - i]) >> (8 - iStore) % 8;
  1895. /* advance target bit index by 7 ( modulo 8 addition ) */
  1896. iStore = (--iStore < 0 ? 7 : iStore);
  1897. if (iStore != 0) /* if just finished packing 8 septets (into 7 octets) don't advance mask index */
  1898.     i = (++i > 7 ? 1 : i); 
  1899.     }
  1901.     /* don't forget to pack the leftovers ;-) */
  1902.     if (destRemain > 0)
  1903. octstr_append_char(target, target_chr);
  1905.     return target;
  1906. }
  1909. Octstr* at2_encode8bituncompressed(Octstr *input)
  1910. {
  1911.     int len, i;
  1912.     Octstr* out = octstr_create("");
  1914.     len = octstr_len(input);
  1916.     for (i = 0; i < len; i++) {
  1917.         /* each character is encoded in its hex representation (2 chars) */
  1918.         octstr_append_char(out, at2_numtext( (octstr_get_char(input, i) & 0xF0) >> 4));
  1919.         octstr_append_char(out, at2_numtext( (octstr_get_char(input, i) & 0x0F)));
  1920.     }
  1921.     return out;
  1922. }
  1925. int at2_numtext(int num)
  1926. {
  1927.     return (num > 9) ? (num + 55) : (num + 48);
  1928. }
  1931. int at2_detect_speed(PrivAT2data *privdata)
  1932. {
  1933.     int i;
  1934. #ifdef B57600
  1935.     int autospeeds[] = { 57600, 38400, 19200, 9600 };
  1936. #else
  1937.     int autospeeds[] = { 38400, 19200, 9600 };
  1938. #endif
  1940.     debug("bb.smsc.at2", 0, "AT2[%s]: detecting modem speed. ", 
  1941.           octstr_get_cstr(privdata->name));
  1943.     for (i = 0; i < (sizeof(autospeeds) / sizeof(int)); i++) {
  1944. if(at2_test_speed(privdata, autospeeds[i]) == 0) {
  1945.     privdata->speed = autospeeds[i];
  1946.     break;
  1947. }
  1948.     }
  1949.     if (privdata->speed == 0) {
  1950.         info(0, "AT2[%s]: cannot detect speed", octstr_get_cstr(privdata->name));
  1951.         return -1;
  1952.     }
  1953.     info(0, "AT2[%s]: detect speed is %ld", octstr_get_cstr(privdata->name), privdata->speed);
  1954.     return 0;
  1955. }
  1957. int at2_test_speed(PrivAT2data *privdata, long speed) {
  1959.     int res;
  1961.     if (at2_open_device1(privdata) == -1)
  1962. return -1;
  1964.     at2_set_speed(privdata, speed);
  1965.     /* send a return so the modem can detect the speed */
  1966.     res = at2_send_modem_command(privdata, "", 1, 0); 
  1967.     res = at2_send_modem_command(privdata, "AT", 0, 0);
  1969.     if (res != 0)
  1970. res = at2_send_modem_command(privdata, "AT", 0, 0);
  1971.     if (res != 0)
  1972. res = at2_send_modem_command(privdata, "AT", 0, 0);
  1973.     at2_close_device(privdata);
  1975.     return res;
  1976. }
  1979. int at2_detect_modem_type(PrivAT2data *privdata)
  1980. {
  1981.     int res;
  1982.     ModemDef *modem;
  1983.     int i;
  1985.     debug("bb.smsc.at2", 0, "AT2[%s]: detecting modem type", octstr_get_cstr(privdata->name));
  1987.     if (at2_open_device1(privdata) == -1)
  1988.         return -1;
  1990.     at2_set_speed(privdata, privdata->speed);
  1991.     /* send a return so the modem can detect the speed */
  1992.     res = at2_send_modem_command(privdata, "", 1, 0); 
  1993.     res = at2_send_modem_command(privdata, "AT", 0, 0);
  1995.     if (at2_send_modem_command(privdata, "AT&F", 0, 0) == -1)
  1996.         return -1;
  1997.     if (at2_send_modem_command(privdata, "ATE0", 0, 0) == -1)
  1998.         return -1;
  2000.     at2_flush_buffer(privdata);
  2002.     if (at2_send_modem_command(privdata, "ATI", 0, 0) == -1)
  2003.         return -1;
  2005.     /* we try to detect the modem automatically */
  2006.     i = 1;
  2007.     while ((modem = at2_read_modems(privdata, privdata->configfile, NULL, i++)) != NULL) {
  2009.         if (octstr_len(modem->detect_string) == 0) {
  2010.             at2_destroy_modem(modem);
  2011.             continue;
  2012.         }
  2014.         /* 
  2015.         debug("bb.smsc.at2",0,"AT2[%s]: searching for %s", octstr_get_cstr(privdata->name), 
  2016.               octstr_get_cstr(modem->name)); 
  2017.         */
  2019.         if (octstr_search(privdata->lines, modem->detect_string, 0) != -1) {
  2020.             if (octstr_len(modem->detect_string2) == 0) {
  2021.                 debug("bb.smsc.at2", 0, "AT2[%s]: found string <%s>, using modem definition <%s>", 
  2022.                       octstr_get_cstr(privdata->name), octstr_get_cstr(modem->detect_string), 
  2023.                       octstr_get_cstr(modem->name));
  2024.                 privdata->modem = modem;
  2025.                 break;
  2026.             } else {
  2027.                 if (octstr_search(privdata->lines, modem->detect_string2, 0) != -1) {
  2028.                     debug("bb.smsc.at2", 0, "AT2[%s]: found string <%s> plus <%s>, using modem "
  2029.                           "definition <%s>", octstr_get_cstr(privdata->name), 
  2030.                           octstr_get_cstr(modem->detect_string), 
  2031.                           octstr_get_cstr(modem->detect_string2), 
  2032.                           octstr_get_cstr(modem->name));
  2033.                     privdata->modem = modem;
  2034.                     break;
  2035.                 }
  2036.             }
  2037.         }
  2038.     }
  2040.     if (privdata->modem == NULL) {
  2041.         debug("bb.smsc.at2", 0, "AT2[%s]: Cannot detect modem, using generic", 
  2042.               octstr_get_cstr(privdata->name));
  2043.         if ((modem = at2_read_modems(privdata, privdata->configfile, octstr_imm("generic"), 0)) == NULL) {
  2044.             panic(0, "AT2[%s]: Cannot detect modem and generic not found", 
  2045.                   octstr_get_cstr(privdata->name));
  2046.         } else {
  2047.             privdata->modem = modem;
  2048.         }
  2049.     }
  2051.     /* lets see if it supports GSM SMS 2+ mode */
  2052.     res = at2_send_modem_command(privdata, "AT+CSMS=?", 0, 0);
  2053.     if (res != 0)
  2054.         /* if it doesnt even understand the command, I'm sure it won't support it */
  2055.         privdata->phase2plus = 0; 
  2056.     else {
  2057.         /* we have to take a part a string like +CSMS: (0,1,128) */
  2058.         Octstr *ts;
  2059.         int i;
  2060.         List *vals;
  2062.         ts = privdata->lines;
  2063.         privdata->lines = NULL;
  2065.         i = octstr_search_char(ts, '(', 0);
  2066.         if (i > 0) {
  2067.             octstr_delete(ts, 0, i + 1);
  2068.         }
  2069.         i = octstr_search_char(ts, ')', 0);
  2070.         if (i > 0) {
  2071.             octstr_truncate(ts, i);
  2072.         }
  2073.         vals = octstr_split(ts, octstr_imm(","));
  2074.         octstr_destroy(ts);
  2075.         ts = list_search(vals, octstr_imm("1"), (void*) octstr_item_match);
  2076.         if (ts)
  2077.             privdata->phase2plus = 1;
  2078.         list_destroy(vals, octstr_destroy_item);
  2079.     }
  2080.     if (privdata->phase2plus)
  2081.         info(0, "AT2[%s]: Phase 2+ is supported", octstr_get_cstr(privdata->name));
  2082.     at2_close_device(privdata);
  2083.     return 0;
  2084. }
  2087. ModemDef *at2_read_modems(PrivAT2data *privdata, Octstr *file, Octstr *id, int idnumber)
  2088. {
  2090.     Cfg *cfg;
  2091.     List *grplist;
  2092.     CfgGroup *grp;
  2093.     Octstr *p;
  2094.     ModemDef *modem;
  2095.     int i = 1;
  2097.     /* 
  2098.      * Use id and idnumber=0 or id=NULL and idnumber > 0 
  2099.      */
  2100.     if (octstr_len(id) == 0 && idnumber == 0)
  2101.         return NULL;
  2103.     if (idnumber == 0)
  2104.         debug("bb.smsc.at2", 0, "AT2[%s]: Reading modem definitions from <%s>", 
  2105.               octstr_get_cstr(privdata->name), octstr_get_cstr(file));
  2106.     cfg = cfg_create(file);
  2108.     if (cfg_read(cfg) == -1)
  2109.         panic(0, "Cannot read modem definition file");
  2111.     grplist = cfg_get_multi_group(cfg, octstr_imm("modems"));
  2112.     if (idnumber == 0)
  2113.         debug("bb.smsc.at2", 0, "AT2[%s]: Found <%ld> modems in config", 
  2114.               octstr_get_cstr(privdata->name), list_len(grplist));
  2116.     if (grplist == NULL)
  2117.         panic(0, "Where are the modem definitions ?!?!");
  2119.     grp = NULL;
  2120.     while (grplist && (grp = list_extract_first(grplist)) != NULL) {
  2121.         p = cfg_get(grp, octstr_imm("id"));
  2122.         if (p == NULL) {
  2123.             info(0, "Modems group without id, bad");
  2124.             continue;
  2125.         }
  2126.         /* Check by id */
  2127.         if (octstr_len(id) != 0 && octstr_compare(p, id) == 0) {
  2128.             O_DESTROY(p);
  2129.             break;
  2130.         }
  2131.         /* Check by idnumber */
  2132.         if (octstr_len(id) == 0 && idnumber == i) {
  2133.             O_DESTROY(p);
  2134.             break;
  2135.         }
  2136.         O_DESTROY(p);
  2137.         i++;
  2138.         grp = NULL;
  2139.     }
  2140.     if (grplist != NULL)
  2141.         list_destroy(grplist, NULL);
  2143.     if (grp != NULL) {
  2144.         modem = gw_malloc(sizeof(ModemDef));
  2146.         modem->id = cfg_get(grp, octstr_imm("id"));
  2148.         modem->name = cfg_get(grp, octstr_imm("name"));
  2149.         if (modem->name == NULL)
  2150.             modem->name = octstr_duplicate(modem->id);
  2152.         modem->detect_string = cfg_get(grp, octstr_imm("detect-string"));
  2153.         modem->detect_string2 = cfg_get(grp, octstr_imm("detect-string2"));
  2155.         modem->init_string = cfg_get(grp, octstr_imm("init-string"));
  2156.         if (modem->init_string == NULL)
  2157.             modem->init_string = octstr_create("AT+CNMI=1,2,0,1,0");
  2159.         modem->speed = 9600;
  2160.         cfg_get_integer(&modem->speed, grp, octstr_imm("speed"));
  2162.         cfg_get_bool(&modem->need_sleep, grp, octstr_imm("need-sleep"));
  2164.         modem->enable_hwhs = cfg_get(grp, octstr_imm("enable-hwhs"));
  2165.         if (modem->enable_hwhs == NULL)
  2166.             modem->enable_hwhs = octstr_create("AT+IFC=2,2");
  2168.         cfg_get_bool(&modem->no_pin, grp, octstr_imm("no-pin"));
  2170.         cfg_get_bool(&modem->no_smsc, grp, octstr_imm("no-smsc"));
  2172.         modem->sendline_sleep = 100;
  2173.         cfg_get_integer(&modem->sendline_sleep, grp, octstr_imm("sendline-sleep"));
  2175.         modem->keepalive_cmd = cfg_get(grp, octstr_imm("keepalive-cmd"));
  2176.         if (modem->keepalive_cmd == NULL)
  2177.             modem->keepalive_cmd = octstr_create("AT");
  2179.         modem->message_storage = cfg_get(grp, octstr_imm("message-storage"));
  2181.         cfg_get_bool(&modem->enable_mms, grp, octstr_imm("enable-mms"));
  2183.         /*
  2184.         if (modem->message_storage == NULL)
  2185.             modem->message_storage = octstr_create("SM");
  2186.         */
  2188.         cfg_get_bool(&modem->broken, grp, octstr_imm("broken"));
  2190.         cfg_destroy(cfg);
  2191.         return modem;
  2193.     } else {
  2194.         cfg_destroy(cfg);
  2195.         return NULL;
  2196.     }
  2197. }
  2200. void at2_destroy_modem(ModemDef *modem)
  2201. {
  2202.     if (modem != NULL) {
  2203.         O_DESTROY(modem->id);
  2204.         O_DESTROY(modem->name);
  2205.         O_DESTROY(modem->detect_string);
  2206.         O_DESTROY(modem->detect_string2);
  2207.         O_DESTROY(modem->init_string);
  2208.         O_DESTROY(modem->enable_hwhs);
  2209.         O_DESTROY(modem->keepalive_cmd);
  2210.         O_DESTROY(modem->message_storage);
  2211.         gw_free(modem);
  2212.     }
  2213. }
  2216. int swap_nibbles(char byte)
  2217. {
  2218.     return ( ( byte & 15 ) * 10 ) + ( byte >> 4 );
  2219. }
  2221. Octstr* at2_format_address_field(Octstr* msisdn)
  2222. {
  2223.     int ntype = PNT_UNKNOWN;
  2224.     Octstr* out = octstr_create("");
  2225.     Octstr* temp = octstr_duplicate(msisdn);
  2227.     octstr_strip_blanks(temp);
  2228.     /*
  2229.      * Check for international numbers
  2230.      * number starting with '+' or '00' are international,
  2231.      * others are national.
  2232.      */
  2233.     if (strncmp(octstr_get_cstr(msisdn), "+", 1) == 0) {
  2234. octstr_delete(temp, 0, 1);
  2235.         ntype = PNT_INTER; /* international */
  2236.     } else if (strncmp(octstr_get_cstr(msisdn), "00", 2) == 0) {
  2237.         octstr_delete(temp, 0, 2);
  2238.         ntype = PNT_INTER; /* international */
  2239.     }
  2241.     /* address length */
  2242.     octstr_append_char(out, octstr_len(temp));
  2244.     /* Type of address : bit mapped values */
  2245.     octstr_append_char(out, 0x80 /* Type-of-address prefix */ |
  2246.     0x01 /* Numbering-plan: MSISDN */ |
  2247.     (ntype == PNT_INTER ? 0x10 : 0x00) /* Type-of-number: International or National */
  2248.     );
  2250.     /* grab the digits from the MSISDN and encode as swapped semi-octets */
  2251.     while (octstr_len(temp)) {
  2252. int digit1, digit2;
  2253. /* get the first two digit */
  2254. digit1 = octstr_get_char(temp,0) - 48;
  2255. if ((digit2 = octstr_get_char(temp,1) - 48) < 0)
  2256.     digit2 = 0x0F;
  2257. octstr_append_char(out, (digit2 << 4) | digit1);
  2258. octstr_delete(temp, 0, 2);
  2259.     }
  2261.     O_DESTROY(temp);
  2262.     return out;
  2263. }